@davars/graphql-codegen-zod 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 davars
+Copyright (c) 2022 codehex (original graphql-codegen-typescript-validation-schema)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @davars/graphql-codegen-zod
+
+[GraphQL Code Generator](https://the-guild.dev/graphql/codegen) plugin that generates [Zod v4](https://zod.dev) validation schemas from GraphQL types, with support for custom transforms.
+
+Derived from [graphql-codegen-typescript-validation-schema](https://github.com/Code-Hex/graphql-codegen-typescript-validation-schema) by Code-Hex (MIT licensed). Stripped to Zod v4 only, with added transform support for custom type constructors.
+
+## Installation
+
+```bash
+pnpm add -D @davars/graphql-codegen-zod
+```
+
+## Usage
+
+```yaml
+# codegen.yml
+generates:
+  path/to/schemas.ts:
+    plugins:
+      - @davars/graphql-codegen-zod
+    config:
+      schema: zodv4
+      withObjectType: true
+      importFrom: ./graphql-operations
+      scalarSchemas:
+        UUID: z.string().uuid()
+        DateTime: z.coerce.date()
+```
+
+## Transforms
+
+Transforms let you convert plain parsed objects into custom class instances using Zod's `.transform()`.
+
+### 1. Define a transform function alongside your model
+
+```typescript
+// models/DateRange.ts
+export class DateRange {
+  constructor(readonly start: Date, readonly end: Date) {}
+}
+
+export function transformDateRange(raw: { start?: Date | null; end?: Date | null }): DateRange | null {
+  if (raw.start == null || raw.end == null) return null
+  return new DateRange(raw.start, raw.end)
+}
+```
+
+### 2. Create a transforms config
+
+```typescript
+// transforms.config.ts
+import type { TransformConfig } from '@davars/graphql-codegen-zod/config'
+import { transformDateRange } from './models/DateRange'
+
+const config: TransformConfig = {
+  DateRange: transformDateRange,
+}
+export default config
+```
+
+### 3. Reference in codegen.yml
+
+```yaml
+config:
+  transforms: ./path/to/transforms.config.ts
+```
+
+The generated schema will include:
+```typescript
+import { transformDateRange } from './models/DateRange'
+
+export function DateRangeSchema() {
+  return z.object({
+    __typename: z.literal('DateRange').optional(),
+    start: z.coerce.date().nullish(),
+    end: z.coerce.date().nullish(),
+  }).transform(transformDateRange)
+}
+```
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,363 @@
+import type { TypeScriptPluginConfig } from '@graphql-codegen/typescript';
+import type { NamingConventionMap } from '@graphql-codegen/visitor-plugin-common';
+export type ValidationSchema = 'yup' | 'zod' | 'zodv4' | 'myzod' | 'valibot';
+export type ValidationSchemaExportType = 'function' | 'const';
+export interface DirectiveConfig {
+    [directive: string]: {
+        [argument: string]: string | string[] | DirectiveObjectArguments;
+    };
+}
+export interface DirectiveObjectArguments {
+    [matched: string]: string | string[];
+}
+interface ScalarSchemas {
+    [name: string]: string;
+}
+export interface ValidationSchemaPluginConfig extends TypeScriptPluginConfig {
+    /**
+     * @description Specifies a custom import path for the zod package. This is useful when you want to use a specific
+     * version or subpath of zod, such as the v3 compatibility layer in zod v4 ('zod/v3').
+     * Only applies when schema is set to 'zod'.
+     * @default 'zod'
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: zod
+     *       # Use zod v3 compatibility layer when using zod v4
+     *       zodImportPath: zod/v3
+     * ```
+     */
+    zodImportPath?: string;
+    /**
+     * @description specify generate schema
+     * @default yup
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - typescript
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     * ```
+     */
+    schema?: ValidationSchema;
+    /**
+     * @description import types from generated typescript type path
+     * if not given, omit import statement.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     *       importFrom: ./path/to/types
+     * ```
+     */
+    importFrom?: string;
+    /**
+     * @description If defined, will use named imports from the specified module (defined in `importFrom`)
+     * rather than individual imports for each type.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     *       importFrom: ./path/to/types
+     *       schemaNamespacedImportName: types
+     * ```
+     */
+    schemaNamespacedImportName?: string;
+    /**
+     * @description Will use `import type {}` rather than `import {}` when importing generated typescript types.
+     * This gives compatibility with TypeScript's "importsNotUsedAsValues": "error" option
+     * Should used in conjunction with `importFrom` option.
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     *       importFrom: ./path/to/types
+     *       useTypeImports: true
+     * ```
+     */
+    useTypeImports?: boolean;
+    /**
+     * @description Prefixes all import types from generated typescript type.
+     * @default ""
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       typesPrefix: I
+     *       importFrom: ./path/to/types
+     * ```
+     */
+    typesPrefix?: string;
+    /**
+     * @description Suffixes all import types from generated typescript type.
+     * @default ""
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       typesSuffix: I
+     *       importFrom: ./path/to/types
+     * ```
+     */
+    typesSuffix?: string;
+    /**
+     * @description Generates validation schema for enum as TypeScript `type`
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       enumsAsTypes: true
+     * ```
+     *
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - typescript
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       enumsAsTypes: true
+     * ```
+     */
+    enumsAsTypes?: boolean;
+    /**
+     * @description Generates validation string schema as do not allow empty characters by default.
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       notAllowEmptyString: true
+     * ```
+     */
+    notAllowEmptyString?: boolean;
+    /**
+     * @description Extends or overrides validation schema for the built-in scalars and custom GraphQL scalars.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * config:
+     *   schema: yup
+     *   scalarSchemas:
+     *     Date: yup.date()
+     *     Email: yup.string().email()
+     * ```
+     *
+     * @exampleMarkdown
+     * ```yml
+     * config:
+     *   schema: zod
+     *   scalarSchemas:
+     *     Date: z.date()
+     *     Email: z.string().email()
+     * ```
+     */
+    scalarSchemas?: ScalarSchemas;
+    /**
+     * @description Fallback scalar type for undefined scalar types in the schema not found in `scalarSchemas`.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * config:
+     *   schema: yup
+     *   defaultScalarSchema: yup.unknown()
+     * ```
+     *
+     * @exampleMarkdown
+     * ```yml
+     * config:
+     *   schema: zod
+     *   defaultScalarSchema: z.unknown()
+     * ```
+     */
+    defaultScalarTypeSchema?: string;
+    /**
+     * @description Generates validation schema with GraphQL type objects.
+     * but excludes "Query", "Mutation", "Subscription" objects.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/types.ts:
+     *     plugins:
+     *       - typescript
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     *       withObjectType: true
+     * ```
+     */
+    withObjectType?: boolean;
+    /**
+     * @description Specify validation schema export type.
+     * @default function
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - typescript
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       validationSchemaExportType: const
+     * ```
+     */
+    validationSchemaExportType?: ValidationSchemaExportType;
+    /**
+     * @description Uses the full path of the enum type as the default value instead of the stringified value.
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - typescript
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       useEnumTypeAsDefaultValue: true
+     * ```
+     */
+    useEnumTypeAsDefaultValue?: boolean;
+    /**
+     * @description Uses the full path of the enum type as the default value instead of the stringified value.
+     * @default { enumValues: "change-case-all#pascalCase" }
+     * @link https://the-guild.dev/graphql/codegen/docs/config-reference/naming-convention
+     *
+     * Note: This option has not been tested with `namingConvention.transformUnderscore` and `namingConvention.typeNames` options,
+     * and may not work as expected.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - typescript
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       namingConvention:
+     *        enumValues: change-case-all#pascalCase
+     * ```
+     */
+    namingConvention?: NamingConventionMap;
+    /**
+     * @description Generates validation schema with more API based on directive schema.
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/file.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: yup
+     *       directives:
+     *         required:
+     *           msg: required
+     *         # This is example using constraint directive.
+     *         # see: https://github.com/confuser/graphql-constraint-directive
+     *         constraint:
+     *           minLength: min # same as ['min', '$1']
+     *           maxLength: max
+     *           startsWith: ["matches", "/^$1/"]
+     *           endsWith: ["matches", "/$1$/"]
+     *           contains: ["matches", "/$1/"]
+     *           notContains: ["matches", "/^((?!$1).)*$/"]
+     *           pattern: ["matches", "/$1/"]
+     *           format:
+     *             # For example, `@constraint(format: "uri")`. this case $1 will be "uri".
+     *             # Therefore the generator generates yup schema `.url()` followed by `uri: 'url'`
+     *             # If $1 does not match anywhere, the generator will ignore.
+     *             uri: url
+     *             email: email
+     *             uuid: uuid
+     *             # yup does not have `ipv4` API. If you want to add this,
+     *             # you need to add the logic using `yup.addMethod`.
+     *             # see: https://github.com/jquense/yup#addmethodschematype-schema-name-string-method--schema-void
+     *             ipv4: ipv4
+     *           min: ["min", "$1 - 1"]
+     *           max: ["max", "$1 + 1"]
+     *           exclusiveMin: min
+     *           exclusiveMax: max
+     * ```
+     */
+    directives?: DirectiveConfig;
+    /**
+     * @description Path to a TypeScript config file that exports transform definitions.
+     * The config maps GraphQL type names to imported transform functions.
+     * When a transform is configured for a type, the generated schema will append
+     * `.transform(fn)` to produce custom class instances instead of plain objects.
+     *
+     * @exampleMarkdown
+     * ```yml
+     * generates:
+     *   path/to/schemas.ts:
+     *     plugins:
+     *       - graphql-codegen-validation-schema
+     *     config:
+     *       schema: zod
+     *       transforms: ./path/to/transforms.config.ts
+     * ```
+     */
+    transforms?: string;
+}
+export {};

package/dist/config.js

@@ -0,0 +1 @@
+export {};

package/dist/directive.d.ts

@@ -0,0 +1,24 @@
+import type { ConstArgumentNode, ConstDirectiveNode, ConstValueNode } from 'graphql';
+import type { DirectiveConfig, DirectiveObjectArguments } from './config.js';
+export interface FormattedDirectiveConfig {
+    [directive: string]: FormattedDirectiveArguments;
+}
+export interface FormattedDirectiveArguments {
+    [argument: string]: string[] | FormattedDirectiveObjectArguments | undefined;
+}
+export interface FormattedDirectiveObjectArguments {
+    [matched: string]: string[] | undefined;
+}
+export declare function formatDirectiveConfig(config: DirectiveConfig): FormattedDirectiveConfig;
+export declare function formatDirectiveObjectArguments(args: DirectiveObjectArguments): FormattedDirectiveObjectArguments;
+export declare function buildApi(config: FormattedDirectiveConfig, directives: ReadonlyArray<ConstDirectiveNode>): string;
+export declare function buildApiForValibot(config: FormattedDirectiveConfig, directives: ReadonlyArray<ConstDirectiveNode>): string[];
+declare function buildApiFromDirectiveArguments(config: FormattedDirectiveArguments, args: ReadonlyArray<ConstArgumentNode>): string;
+declare function buildApiFromDirectiveObjectArguments(config: FormattedDirectiveObjectArguments, argValue: ConstValueNode): string;
+declare function applyArgToApiSchemaTemplate(template: string, apiArgs: any[]): string;
+export declare const exportedForTesting: {
+    applyArgToApiSchemaTemplate: typeof applyArgToApiSchemaTemplate;
+    buildApiFromDirectiveObjectArguments: typeof buildApiFromDirectiveObjectArguments;
+    buildApiFromDirectiveArguments: typeof buildApiFromDirectiveArguments;
+};
+export {};