I found this method and it worked for me. Might not be the code-first approach but I guess it would suffice until you figure it out :)

import { Field, ObjectType } from 'type-graphql';
import JSON from 'graphql-type-json';

@ObjectType()
export class YourClass {
  @Field(() => JSON)
  myProperty: any;
}

It's not super elegant, but I did it by creating a @Scalar decorated class that wraps the GraphQLJSON object:

// json.scalar.ts
import { Scalar, CustomScalar } from '@nestjs/graphql';
import * as GraphQLJSON from 'graphql-type-json';

@Scalar('JSON', type => Object)
export class JsonScalar implements CustomScalar<string, any> {
  name = GraphQLJSON.name;
  description = GraphQLJSON.description;

  serialize = GraphQLJSON.serialize;
  parseValue = GraphQLJSON.parseValue;
  parseLiteral = GraphQLJSON.parseLiteral;
}

Then I just added JsonScalar to the resolvers section in the module.

You can use it in a resolver with @Query(returns => Object), same goes with other places you need to specify type to nest, it's just Object

Nestjs should really allow us to add a scalar by object rather than class, surprised it's not a thing. I was switching from schema-first to code-first and ran into this issue.

You can create a @Scalar() type using the approach described in the docs

Code first

npm install graphql-type-json or yarn add graphql-type-json

import { GraphQLJSON } from 'graphql-type-json';

type JSONValue =
    | string
    | number
    | boolean
    | null
    | { [x: string]: JSONValue }
    | Array<JSONValue>;

export class SampleModel {
  @Field(() => GraphQLJSON, { nullable: true })
  data?: JSONValue; // It can different e.g If you're using Prisma ORM => "Prisma.JsonValue" 
}

Using schema first here, here's what works for me, on the schema:

Foo {
  bar: Json
}

Custom

import { CustomScalar, Scalar } from '@nestjs/graphql';
import { Kind, ValueNode } from 'graphql';
import _ from 'lodash';

@Scalar('Json')
export class JsonScalar implements CustomScalar<string, any> {
  description = 'Json custom scalar type';

  parseValue(value: string): string {
    this.validateFormat(value);

    return value;
  }

  serialize(value: string): string {
    return value;
  }
  // parseLiteral is a WIP, take it with a grain of salt
  parseLiteral(ast: ValueNode): string {
    if (ast.kind !== Kind.STRING) {
      throw new Error(`The input value is not a string`);
    }

    this.validateFormat(ast.value);

    return ast.value;
  }

  private validateFormat(input: any): void {
    if (_.isNil(input) || input.constructor !== Object) throw new Error(`The input string is not in JSON format`);
  }
}

and in the resolver's module:

@Module({ providers: [ JsonScalar, ...providers })
export class FooModule(){}