graphql-type-json#GraphQLJSONObject TypeScript Examples

/**
   * Subscriptions
   */

  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  @Subscription(() => Whisp, {
    filter: (payload, variables) => filterPayload(variables.filter, payload.whispAdded),
  })
  whispAdded(
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    @Args('filter', { type: () => GraphQLJSONObject }) filter: Record<string, unknown>,
  ): AsyncIterator<IWhisp> {
    return this.pubSub.asyncIterator('whispAdded');
  }

buildEntity = (label: string, entityFields: Field[], operations: OperationType[]) => {
  const formattedLabel = formatName(label);

  const fields = {
    fields: {
      type: new GraphQLObjectType({
        name: formatName(`${formattedLabel}Fields`),
        fields: buildFields(`${formattedLabel}Fields`, entityFields),
      }),
    },
  };

  operations.forEach((operation) => {
    const capitalizedOperation = operation.charAt(0).toUpperCase() + operation.slice(1);

    fields[operation] = {
      type: new GraphQLObjectType({
        name: `${formattedLabel}${capitalizedOperation}Access`,
        fields: {
          permission: { type: new GraphQLNonNull(GraphQLBoolean) },
          where: { type: GraphQLJSONObject },
        },
      }),
    };
  });

  return fields;
}

@ApiProperty({
    required: false,
    type: GraphQLJSONObject,
  })
  @IsOptional()
  @Field(() => GraphQLJSONObject, {
    nullable: true,
  })
  not?: JsonValue;

@ApiProperty({
    required: false,
    type: GraphQLJSONObject,
  })
  @IsOptional()
  @Field(() => GraphQLJSONObject, {
    nullable: true,
  })
  equals?: JsonValue;

@ApiProperty({
    required: false,
    type: GraphQLJSONObject,
  })
  @IsOptional()
  @Field(() => GraphQLJSONObject, {
    nullable: true,
  })
  not?: InputJsonValue;

@ApiProperty({
    required: false,
    type: GraphQLJSONObject,
  })
  @IsOptional()
  @Field(() => GraphQLJSONObject, {
    nullable: true,
  })
  equals?: InputJsonValue;

@Query(() => [WhispCount])
  async countWhisps(
    @Args('filter', { type: () => [GraphQLJSONObject], nullable: true })
      filter: Record<string, unknown>[],
    @Args('group', { type: () => GraphQLJSONObject, nullable: true })
      group: Record<string, unknown>,
  ): Promise<WhispCount[]> {
    return this.whispService.countWhispsGroup(filter, group);
  }

@UseGuards(GqlJwtAuthGuard)
  @Query(() => [Whisp], { nullable: true })
  async whispsAuthBeta(
    @Args('filter', { type: () => GraphQLJSONObject, nullable: true })
      filter?: Record<string, unknown>,
    @Args('sort', { type: () => GraphQLJSONObject, nullable: true })
      sort?: Record<string, unknown>,
    @Args('limit', { type: () => Int, nullable: true }) limit?: number,
  ): Promise<IWhisp[]> {
    return this.whispService.findAll(filter, sort, limit);
  }

@Query(() => [Whisp], { nullable: true })
  async whisps(
    @Args('filter', { type: () => GraphQLJSONObject, nullable: true })
      filter?: Record<string, unknown>,
    @Args('sort', { type: () => GraphQLJSONObject, nullable: true })
      sort?: Record<string, unknown>,
    @Args('limit', { type: () => Int, nullable: true }) limit?: number,
  ): Promise<IWhisp[]> {
    return this.whispService.findAll(filter, sort, limit);
  }

NotionGraphqlResolvers = {
	JSONObject: GraphQLJSONObject,
	Query: NotionGraphqlQueryResolvers,
	Page: NotionGraphqlPageResolver,
	Collection: NotionGraphqlCollectionResolver,
	CollectionView: NotionGraphqlCollectionBlockResolver,
	CollectionViewPage: NotionGraphqlCollectionBlockResolver,
	Space: NotionGraphqlSpaceResolver,
	TPage: {
		__resolveType: getBlockResolveType
	},
	TParent: {
		__resolveType: getParentResolveType
	},
	TCollectionBlock: {
		__resolveType: getBlockResolveType
	},
	TBlock: {
		__resolveType: getBlockResolveType
	},
	Block: {
		__resolveType: getBlockResolveType
	}
}

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: Attribute, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.Attribute, entity.id, fields);
    }

@Field(() => GraphQLJSONObject, { nullable: true })
    attributes: Record<string, string | number | 'any'> | undefined | null;

@Field(() => GraphQLJSONObject)
    metadata: Record<string, any>;

@Field(() => GraphQLJSONObject)
    config: DbmsPluginConfig;

@Field(() => GraphQLJSONObject)
    metadata: Record<string, any>;

@Field(() => GraphQLJSONObject, {nullable: true})
    parameters?: Record<string, any>;

@Field((type) => GraphQLJSONObject)
  data: any

export async function createModule(options: ModuleOptions): Promise<Module> {
  const catalogClient = new CatalogClient(
    options.config.getString('backend.baseUrl'),
  );

  const resolvers: Resolvers = {
    JSON: GraphQLJSON,
    JSONObject: GraphQLJSONObject,
    DefaultEntitySpec: {
      raw: rootValue => {
        const { entity } = rootValue as { entity: Entity };
        return entity.spec ?? null;
      },
    },
    Query: {
      catalog: () => ({} as CatalogQuery),
    },
    CatalogQuery: {
      list: async () => {
        return await catalogClient.list();
      },
    },
    CatalogEntity: {
      metadata: entity => ({ ...entity.metadata!, entity }),
      spec: entity => ({ ...entity.spec!, entity }),
    },
    EntityMetadata: {
      __resolveType: rootValue => {
        const {
          entity: { kind },
        } = rootValue as { entity: Entity };

        switch (kind) {
          case 'Component':
            return 'ComponentMetadata';
          case 'Template':
            return 'TemplateMetadata';
          default:
            return 'DefaultEntityMetadata';
        }
      },
      annotation: (e, { name }) => e.annotations?.[name] ?? null,
      labels: e => e.labels ?? {},
      annotations: e => e.annotations ?? {},
      label: (e, { name }) => e.labels?.[name] ?? null,
    },
    EntitySpec: {
      __resolveType: rootValue => {
        const {
          entity: { kind },
        } = rootValue as { entity: Entity };

        switch (kind) {
          case 'Component':
            return 'ComponentEntitySpec';
          case 'Template':
            return 'TemplateEntitySpec';
          default:
            return 'DefaultEntitySpec';
        }
      },
    },
  };

  return createGraphQLModule({
    id: 'plugin-catalog-graphql',
    typeDefs: gql(typeDefs),
    resolvers,
  });
}

@Field(type => GraphQLJSONObject)
  @prop({ default: {} })
  public payload?: Object;

@Field(() => GraphQLJSONObject, {
    nullable: true,
    description: undefined
  })
  properties!: JsonValue;

@Field(() => GraphQLJSONObject, {
    nullable: true,
    description: undefined
  })
  settings?: JsonValue;

@Field(() => GraphQLJSONObject, {
    nullable: true,
    description: undefined
  })
  properties?: JsonObject | null;

@Field(() => GraphQLJSONObject, {
    nullable: false,
    description: undefined
  })
  properties!: JsonObject;

@Field(() => GraphQLJSONObject)
  meta!: JsonValue;

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: User, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.User, entity.id, fields);
    }

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: Coupon, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.Coupon, entity.id, fields);
    }

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: CustomEntity, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.CustomEntity, entity.id, fields);
    }

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: Order, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.Order, entity.id, fields);
    }

@Field(() => GraphQLJSONObject, { nullable: true })
  _id: any;