Reuse jsonschema/zod to create input/object/interface type

[wenerme]

by resuing zod schema, can make zod as single source of truth for client schema.
it's also possible to add a middleware for validate, but I dont want to, I prefer doing the validate at the service level.

zod can also create NestJS's DTO, that make generate openapi easier and sync the fields between the gql and restful.

---

zod v4 has built-in support for jsonschema, that make create/instrospect types eaiser. I used to generate typebox from ts types, but now I juse use zod to define schema is enough.(typebox is almost equal to jsonschema).

---

The result

const BankAccountCreateInput = createSchemaInputType(BankAccountCreateInputSchema);
const BankAccountUpdateInput = createSchemaInputType(BankAccountUpdateInputSchema);

type CreateBankAccountInput = InstanceType<typeof CreateBankAccountInput>;
const CreateBankAccountInput = createCreateResourceInput(BankAccountCreateInput);

type UpdateBankAccountInput = InstanceType<typeof UpdateBankAccountInput>;
const UpdateBankAccountInput = createUpdateResourceInput(BankAccountUpdateInput);

This is how to create dynamic types from jsonschema

export function createSchemaInputType<T extends TypeSchema>(schema: T): Constructor<SchemaOutput<T>> {
  return computeIfAbsent(_cache, schema, () => {
    class SchemaHolder {}

    let target = SchemaHolder;
    collectSchemaMeta(schema, {
      target,
      input: true,
    });

    return target as Constructor<SchemaOutput<T>>;
  });
}

type CollectSchemaMetaOptions = {
  target: Function;
  input?: boolean;
  object?: boolean;
  name?: string;
};

function collectSchemaMeta(
  schema: TypeSchema,
  { object, input, target, name }: CollectSchemaMetaOptions,
): ObjectClassMetadata {
  const js = toJsonSchema(schema);
  const fields: FieldMetadata[] = [];
  name ||= js.title || `Resource${getObjectId(schema)}Type`;
  const def: ObjectClassMetadata = {
    name,
    target: target,
    fields: fields,
    interfaceClasses: [],
  };
  for (let [k, v] of Object.entries(js.properties!)) {
    if (input && v.readOnly) {
      continue;
    }
    if (object && v.writeOnly) {
      continue;
    }
    const field: FieldMetadata = {
      target,
      name: k,
      schemaName: k,
      typeOptions: {
        nullable: v.nullable,
        defaultValue: v.default,
      },
      description: undefined,
      deprecationReason: undefined,
      complexity: undefined,
      getType: () => String,
    };
    switch (v.type) {
      case 'integer':
        field.getType = () => Int;
        break;
      case 'number':
        field.getType = () => Number;
        break;
      case 'array':
        // todo improve this later - create nested

        field.getType = () => Object;
        field.typeOptions.array = true;
        field.typeOptions.arrayDepth = 1;
        break;
    }

    switch (v.format) {
      case 'date-time':
        field.getType = () => GraphQLDateTime;
        break;
      case 'date':
        field.getType = () => GraphQLDate;
        break;
      case 'email':
        field.getType = () => GraphQLEmailAddress;
        break;
    }

    fields.push(field);
  }

  const ms = getMetadataStorage();
  if (input) {
    ms.inputTypes.push(def);
  }
  if (object) {
    ms.objectTypes.push(def);
  }

  Object.defineProperty(target, 'name', {
    get() {
      return def.name;
    },
  });

  return def;
}

Some factory https://github.com/wenerme/wode/blob/main/packages/wener-nestjs/src/type-graphql/resource/factory.ts

export function createCreateResourceInput<T extends object>(Type: Constructor<T>): Constructor<CreateResourceInput<T>> {
  // ResourceCreateInput
  let name = Type.name.replace(/(Update|Create)?Input$/, '');

  // CreateResourceInput
  let key = `Create${name}Input`;
  return computeIfAbsent(getTypeCache(), key, () => {
    @InputType(key)
    class CreateResourceInput extends RelayMutationPayload {
      @Field((type) => Type)
      data!: T;
    }

    return CreateResourceInput;
  });
}

I used mixin for resuing fields before https://github.com/wenerme/wode/tree/main/packages/wener-nestjs/src/type-graphql/mixins

but zod schema reusing is better and easier.

[MichalLytek]

This is not a NestJS oriented repo. They have their own implementation of GraphQL, although similar to this.

[wenerme]

Understood, I use nestjs for ioc, hono for http, yoga for server and type-graphql for schema builder, everything works perfect.