zod#z TypeScript Examples

createAllStates = <T extends AnyZodObject, R extends AnyZodObject>(
	commons: T,
	removeState: R,
) => {
	return z
		.object({
			action: z.enum([Action.UPDATE, Action.CREATE]),
			data: commons,
		})
		.or(
			z.object({
				action: z.literal(Action.REMOVE),
				data: removeState.merge(commons),
			}),
		);
}

VendorSchema = schemaForType<VendorType>()(
  z.object({
    endDate: z.string().optional(),
    id: z.string(),
    name: z.string().min(1),
    region: z.string().min(1),
    storeLink: allowEmpty(z.string().url()),
  })
)

samlSessionSchema: z.ZodSchema<SamlSession> = z.object({
  profile: z.object({
    email: z.string().optional(),
    displayName: z.string().optional(),
    picture: z.string().optional(),
  }),
  backstageIdentity: z.object({
    token: z.string(),
    identity: z.object({
      type: z.literal('user'),
      userEntityRef: z.string(),
      ownershipEntityRefs: z.array(z.string()),
    }),
  }),
})

receiptSchema = z
  .object({
    airnodeWallet: airnodeWalletSchema,
    deployment: deploymentSchema,
    api: apiSchema,
  })
  .strict()
  .superRefine(({ airnodeWallet, deployment }, ctx) => {
    // TODO: There's no need to have Arnode short address twice in the receipt.json
    if (airnodeWallet.airnodeAddressShort !== deployment.airnodeAddressShort) {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: `Airnode short addresses don't match`,
        path: ['airnodeWallet', 'airnodeAddressShort'],
      });
    }
  })

notionPageSeoSchema = z.object({
  siteName: z
    .string()
    .min(1, 'Name must be at least 1 character long.')
    .max(100, 'Name must be less than 100 characters long.')
    .nonempty('Please enter a name for the site.'),
  siteDesc: z
    .string()
    .min(1, 'Description must be at least 1 character long.')
    .max(100, 'Description must be less than 100 characters long.')
    .nonempty('Please fill in the description.')
    .optional(),
  ogImageUrl: z.string().optional(),
})

createApiResponse = <S extends z.ZodTypeAny>(
  schema: S,
  mimeTypes: MimeDefinition = mimeJson
) => {
  return {
    schema,
    mimeTypes: typeof mimeTypes === "string" ? [mimeTypes] : mimeTypes,
  } as ApiResponse<S>;
}

deploymentSchema = z
  .object({
    nodeVersion: z.string().superRefine((version, ctx) => {
      if (version === packageVersion) return;

      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: `The "nodeVersion" must be ${packageVersion}`,
        path: [],
      });
    }),
    airnodeAddressShort: z.string(),
    stage: z.string().regex(/^[a-z0-9-]{1,16}$/),
    cloudProvider: cloudProviderSchema,
    timestamp: z.string().regex(ISO_DATE_REGEX),
  })
  .strict()

async #parseOutput(output: any) {
    try {
      return await this.outputSchema.parseAsync(output);
    } catch (e) {
      if (e instanceof z.ZodError) {
        throw new z.ZodError([
          {
            message: "Invalid format",
            code: "custom",
            path: ["output"],
          },
          ...e.issues.map((issue) => ({
            ...issue,
            path: issue.path.length === 0 ? ["output"] : issue.path,
          })),
        ]);
      }
      throw e;
    }
  }

oisSchema = z
  .object({
    oisFormat: z.string(),
    title: z.string(),
    version: z.string(),
    apiSpecifications: apiSpecificationSchema,
    endpoints: z.array(endpointSchema),
  })
  .strict()
  .superRefine(ensureSingleParameterUsagePerEndpoint)
  .superRefine(ensureEndpointAndApiSpecificationParamsMatch)

public addExpressMiddleware<
    R extends Request,
    S extends Response,
    AOUT extends FlatObject = {}
  >(
    middleware: ExpressMiddleware<R, S>,
    features?: ExpressMiddlewareFeatures<R, S, AOUT>
  ) {
    const transformer = features?.transformer || ((err: Error) => err);
    const provider = features?.provider || (() => ({} as AOUT));
    const definition = createMiddleware({
      input: z.object({}),
      middleware: async ({ request, response }) =>
        new Promise<AOUT>((resolve, reject) => {
          const next = (err?: any) => {
            if (err && err instanceof Error) {
              return reject(transformer(err));
            }
            resolve(provider(request as R, response as S));
          };
          middleware(request as R, response as S, next);
        }),
    });
    return EndpointsFactory.#create<POS, NEG, IN, OUT & AOUT>(
      this.middlewares.concat(definition as AnyMiddlewareDef),
      this.resultHandler
    );
  }

endpointSchema = z
  .object({
    description: z.string().optional(),
    externalDocs: z.string().optional(),
    fixedOperationParameters: z.array(fixedParameterSchema),
    name: z.string(),
    operation: endpointOperationSchema,
    parameters: z.array(endpointParameterSchema),
    preProcessingSpecifications: z.array(processingSpecificationSchema).optional(),
    postProcessingSpecifications: z.array(processingSpecificationSchema).optional(),
    reservedParameters: z.array(reservedParameterSchema),
    summary: z.string().optional(),
  })
  .strict()

depictDiscriminatedUnion: DepictHelper<
  z.ZodDiscriminatedUnion<string, z.Primitive, z.ZodObject<any>>
> = ({ schema: { options, discriminator }, initial, isResponse }) => {
  return {
    ...initial,
    discriminator: {
      propertyName: discriminator,
    },
    oneOf: Array.from(options.values()).map((option) =>
      depictSchema({ schema: option, isResponse })
    ),
  };
}

apiSpecificationSchema = z
  .object({
    components: apiComponentsSchema,
    paths: pathsSchema,
    servers: z.array(serverSchema),
    security: z.record(z.tuple([])),
  })
  .strict()
  .superRefine((apiSpecifications, ctx) => {
    Object.keys(apiSpecifications.security).forEach((enabledSecuritySchemeName, index) => {
      // Verify that ois.apiSpecifications.security.<securitySchemeName> is
      // referencing a valid ois.apiSpecifications.components.<securitySchemeName> object
      const enabledSecurityScheme = apiSpecifications.components.securitySchemes[enabledSecuritySchemeName];
      if (!enabledSecurityScheme) {
        ctx.addIssue({
          code: z.ZodIssueCode.custom,
          message: `Security scheme "${enabledSecuritySchemeName}" is not defined in "components.securitySchemes"`,
          path: ['security', index],
        });
      }
    });
  })

depictArray: DepictHelper<z.ZodArray<z.ZodTypeAny>> = ({
  schema: { _def: def },
  initial,
  isResponse,
}) => ({
  ...initial,
  type: "array",
  items: depictSchema({ schema: def.type, isResponse }),
  ...(def.minLength ? { minItems: def.minLength.value } : {}),
  ...(def.maxLength ? { maxItems: def.maxLength.value } : {}),
})

priorityFeeSchema = z
  .object({
    value: z.number(),
    unit: z
      .union([
        z.literal('wei'),
        z.literal('kwei'),
        z.literal('mwei'),
        z.literal('gwei'),
        z.literal('szabo'),
        z.literal('finney'),
        z.literal('ether'),
      ])
      .optional(),
  })
  .strict()

describe("Meta data", () => {
  it("should be possible to use description", () => {
    const $z = z.string().describe("My neat string");
    const $j = zodToJsonSchema($z);
    const $e: JSONSchema7 = {
      $schema: "http://json-schema.org/draft-07/schema#",
      type: "string",
      description: "My neat string",
    };

    expect($j).toStrictEqual($e);
  });
});

apiSecuritySchemeSchema = z.discriminatedUnion('type', [
  apiKeySecuritySchemeSchema,
  httpSecuritySchemeSchema,
  relayChainIdSecuritySchemeSchema,
  relayChainTypeSecuritySchemeSchema,
  relayRequesterAddressSecuritySchemeSchema,
  relaySponsorAddressSecuritySchemeSchema,
  relaySponsorWalletAddressSecuritySchemeSchema,
])

describe("effects", () => {
  it("should be possible to use refine", () => {
    const parsedSchema = parseEffectsDef(
      z.number().refine((x) => x + 1)._def,
      new References()
    );
    const jsonSchema: JSONSchema7Type = {
      type: "number",
    };
    expect(parsedSchema).toStrictEqual(jsonSchema);
  });

  it("should default to the input type", () => {
    const schema = z.string().transform((arg) => parseInt(arg));

    const jsonSchema = parseEffectsDef(schema._def, new References());

    expect(jsonSchema).toStrictEqual({
      type: "string",
    });
  });

  it("should default to any if given that effectStrategy", () => {
    const schema = z.string().transform((arg) => parseInt(arg));

    const jsonSchema = parseEffectsDef(
      schema._def,
      new References(undefined, undefined, undefined, "any")
    );

    expect(jsonSchema).toStrictEqual({});
  });
});

defaultRemoveSchema = z.object({archivedAt: dateResolvable})

describe("objects", () => {
  it("should be possible to describe catchAll schema", () => {
    const schema = z
      .object({ normalProperty: z.string() })
      .catchall(z.boolean());

    const parsedSchema = parseObjectDef(schema._def, new References());
    const expectedSchema = {
      type: "object",
      properties: {
        normalProperty: { type: "string" },
      },
      required: ["normalProperty"],
      additionalProperties: {
        type: "boolean",
      },
    };
    expect(parsedSchema).toStrictEqual(expectedSchema);
  });

  it("should be possible to use selective partial", () => {
    const schema = z
      .object({ foo: z.boolean(), bar: z.number() })
      .partial({ foo: true });

    const parsedSchema = parseObjectDef(schema._def, new References());
    const expectedSchema = {
      type: "object",
      properties: {
        foo: { type: "boolean" },
        bar: { type: "number" },
      },
      required: ["bar"],
      additionalProperties: false,
    };
    expect(parsedSchema).toStrictEqual(expectedSchema);
  });
});

chainConfigSchema = z
  .object({
    authorizers: z.array(z.string()),
    blockHistoryLimit: z.number().optional(),
    contracts: chainContractsSchema,
    id: z.string(),
    minConfirmations: z.number().optional(),
    type: chainTypeSchema,
    options: chainOptionsSchema,
    providers: z.record(providerSchema),
    maxConcurrency: z.number(),
  })
  .strict()

describe("promise", () => {
  it("should be possible to use promise", () => {
    const parsedSchema = parsePromiseDef(
      z.promise(z.string())._def,
      new References()
    );
    const jsonSchema: JSONSchema7Type = {
      type: "string",
    };
    expect(parsedSchema).toStrictEqual(jsonSchema);
  });
});

commons = z.object({
	id: z.string().uuid(),
	createdAt: dateResolvable,
	updatedAt: dateResolvable,
	emoji: z.string(),
	userId: z.string().uuid(),
	commentId: z.string().uuid(),
	comment: z.object({
		id: z.string().uuid(),
		body: z.string(),
		userId: z.string().uuid(),
	}),
	user: z.object({
		id: z.string().uuid(),
		name: z.string(),
	}),
})

describe("objects", () => {
  it("should be possible to describe a simple tuple schema", () => {
    const schema = z.tuple([z.string(), z.number()]);

    const parsedSchema = parseTupleDef(schema._def, new References());
    const expectedSchema = {
      type: "array",
      items: [{ type: "string" }, { type: "number" }],
      minItems: 2,
      maxItems: 2,
    };
    expect(parsedSchema).toStrictEqual(expectedSchema);
  });

  it("should be possible to describe a tuple schema with rest()", () => {
    const schema = z.tuple([z.string(), z.number()]).rest(z.boolean());

    const parsedSchema = parseTupleDef(schema._def, new References());
    const expectedSchema = {
      type: "array",
      items: [{ type: "string" }, { type: "number" }],
      minItems: 2,
      additionalItems: {
        type: "boolean",
      },
    };
    expect(parsedSchema).toStrictEqual(expectedSchema);
  });
});

commons = z.object({
	id: z.string().uuid(),
	createdAt: dateResolvable,
	updatedAt: dateResolvable,
	name: z.string(),
	description: z.string(),
	slugId: z.string(),
	color: z.string(),
	state: z.string(),
	creatorId: z.string().uuid(),
	sortOrder: z.number(),
	// TODO(@alii): Find out the type for these arrays
	issueCountHistory: z.array(z.unknown()),
	completedIssueCountHistory: z.array(z.unknown()),
	scopeHistory: z.array(z.unknown()),
	completedScopeHistory: z.array(z.unknown()),
	slackIssueComments: z.boolean(),
	slackIssueStatuses: z.boolean(),
	teamIds: z.array(z.string().uuid()),
	// TODO(@alii): Find out this type
	memberIds: z.array(z.unknown()),
})

describe("Root schema result after parsing", () => {
  it("should return the schema directly in the root if no name is passed", () => {
    expect(zodToJsonSchema(z.any())).toStrictEqual({
      $schema: "http://json-schema.org/draft-07/schema#",
    });
  });
  it('should return the schema inside a named property in "definitions" if a name is passed', () => {
    expect(zodToJsonSchema(z.any(), "MySchema")).toStrictEqual({
      $schema: "http://json-schema.org/draft-07/schema#",
      $ref: `#/definitions/MySchema`,
      definitions: {
        MySchema: {},
      },
    });
  });

  it('should return the schema inside a named property in "$defs" if a name and definitionPath is passed in options', () => {
    expect(
      zodToJsonSchema(z.any(), { name: "MySchema", definitionPath: "$defs" })
    ).toStrictEqual({
      $schema: "http://json-schema.org/draft-07/schema#",
      $ref: `#/$defs/MySchema`,
      $defs: {
        MySchema: {},
      },
    });
  });
});

commons = z.object({
	id: z.string().uuid(),
	createdAt: dateResolvable,
	updatedAt: dateResolvable,
	number: z.number().positive(),
	title: z.string(),
	description: z.string(),
	priority: z.number(),
	boardOrder: z.number(),
	sortOrder: z.number(),
	previousIdentifiers: z.array(z.string()),
	priorityLabel: z.string(),
	teamId: z.string().uuid(),
	stateId: z.string().uuid(),
	assigneeId: z.string().uuid().optional(),
	subscriberIds: z.array(z.string().uuid()),
	creatorId: z.string().uuid(),
	labelIds: z.array(z.string().uuid()),
	state,
	team,
	labels: z.array(label).optional(),
})

endpointParameterSchema = z
  .object({
    name: z.string(),
    operationParameter: operationParameterSchema,
    default: z.string().optional(),
    description: z.string().optional(),
    example: z.string().optional(),
    required: z.boolean().optional(),
  })
  .strict()

GuideEntrySchema = schemaForType<GuideEntryType>()(
  z.object({
    body: z.string().min(1),
    description: z.string().min(1),
    id: z.string().min(1),
    name: z.string().min(1),
    tags: z.string().min(1).array(),
    title: z.string().min(1),
    visibility: z.enum(visibilityVals),
  })
)