Typescript: Check if object has property and check property value

I'm trying to create a type guard by checking if an object has a property and then proceed to check if it equals a certain value:

const isJson = (myObject: unknown): myObject is Json => {
  return Boolean(
    myObject && typeof myObject === 'object' && 'type' in myObject && myObject.type === 'something'
  );
};

This will fail: Property 'type' does not exist on type 'object'.
Please note that it only fails when trying to build the project, otherwise typescript will be fine with the above code.

The only solution I could think of is to separate the check into two stages which isn't very neat:

const isJson = (myObject: unknown): myObject is Json => {
  const hasType = (myObject: unknown): myObject is { [key: string]: unknown; type: unknown } => {
    return Boolean(myObject && typeof myObject === 'object' && 'type' in myObject);
  };
  if (!hasType(myObject)) {
    return false;
  }

  return Boolean(myObject.type === 'something');
};

This will work. Is there a better and simpler way?

My tsconfig settings:

  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "@emotion/react",
    "allowJs": true,
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  },

As an alternative approach, we can create a type guard that checks if the argument is any object.

const isObject = <T>(arg: unknown): arg is T => {
  return !!arg && typeof arg === 'object' && !Array.isArray(arg);
};

We are going to pass some object T, which will be inferred as the type of the arg if arg is not falsy and it's not an array, and it's type is object.

The reason to pass the T is to avoid as assertion afterward, however, if we pass the desired type directly to isObject, this won't be absolutely type-safe since we won't need to check the properties of the object for the existence/correctness. Instead of passing the final type we will modify our type with the following utility:

type PartialUnknown<T> = {
  [K in keyof T]?: unknown;
};

This will make all fields optional and type them as unknown. With this, we won't have to use in operator to remove the error with the key not being in the object. The rest is pretty straightforward, just check the type of the fields and you are ready to go.

Usage:

const isJson = (myObject: unknown): myObject is Json => {
  if (!isObject<PartialUnknown<Json>>(myObject)) return false;

  const { type } = myObject;

  return typeof type === 'string' && type === 'something';
};

playground