feat: add transformer option to zod

packages/generator/src/Generator.ts

@@ -15,7 +15,7 @@ import {
   TypeParameterDeclarationStructure,
   VariableDeclarationKind,
 } from 'ts-morph'
-import { InstructionSourceType } from './runtypes'
+import { InstructionSourceType, InstructionTypeTransformers } from './runtypes'
 import {
   CanDeclareStatics,
   DeclareAndUse,
@@ -54,6 +54,7 @@ export type GeneratorOptions = GeneratorOptionsBase & {
   targetFile: string
   typeFormat?: string
   typeWriters: TypeWriters
+  transformers: InstructionTypeTransformers
 }
 
 export type ImportSpec = Omit<ImportSpecifierStructure, 'kind'> & {
@@ -69,6 +70,7 @@ export default class Generator {
   #project: Project
   #imports: ImportSpec[] = []
   #targetFile: SourceCodeFile
+  #transformers: InstructionTypeTransformers
 
   constructor(options: GeneratorOptions) {
     this.#typeWriters = options.typeWriters
@@ -101,6 +103,7 @@ export default class Generator {
 
     this.#formatRuntypeName = typeNameFormatter(options.runtypeFormat)
     this.#formatTypeName = typeNameFormatter(options.typeFormat)
+    this.#transformers = options.transformers
   }
 
   get project() {
@@ -248,6 +251,9 @@ export default class Generator {
       this.#typeWriters.typeWriter(typeDeclaration.getType(), {
         circular: !!circular,
         recursive,
+        transformer: typeDeclaration.getName()
+          ? this.#transformers[typeDeclaration.getName()!]
+          : undefined,
       })
     )
 

packages/generator/src/TypeWriters.ts

@@ -1,5 +1,5 @@
 import { Symbol as CompilerSymbol, SymbolFlags, ts, Type } from 'ts-morph'
-import { Tuple } from '.'
+import { InstructionTypeTransformer, Tuple } from '.'
 import { getArrayElementType, isArray } from './array'
 import {
   escapeQuottedPropName,
@@ -23,9 +23,11 @@ export default abstract class TypeWriters {
     {
       recursive = false,
       circular = false,
+      transformer,
     }: {
       recursive?: boolean
       circular?: boolean
+      transformer?: InstructionTypeTransformer
     } = {}
   ): TypeWriter {
     const closeGenericFunction =
@@ -133,9 +135,14 @@ export default abstract class TypeWriters {
         break
     }
 
+    if (transformer)
+      yield* this.attachTransformer(transformer.file, transformer.export)
+
     if (closeGenericFunction) yield* closeGenericFunction()
   }
 
+  *attachTransformer(_fileName: string, _exportName: string): TypeWriter {}
+
   #requiresGenericFunction(type: Type) {
     try {
       getTypeName(type)

packages/generator/src/cli.ts

@@ -34,13 +34,15 @@ export default async function cli(
     targetFile,
     sourceTypes,
     runtypeFormat,
+    transformers,
     typeFormat,
   } of castArray(buildInstructions)) {
     const generator = new Generator({
       typeWriters,
       runtypeFormat,
       targetFile,
       tsConfigFile: argv.project,
+      transformers: transformers || {},
       typeFormat,
     })
     const file = await generator.generate(sourceTypes)

packages/generator/src/runtypes.ts

@@ -1,5 +1,20 @@
 import * as z from 'zod'
 
+export const InstructionTypeTransformer = z.object({
+  file: z.string(),
+  export: z.string(),
+})
+
+export type InstructionTypeTransformer = z.infer<
+  typeof InstructionTypeTransformer
+>
+
+export const InstructionTypeTransformers = z.record(InstructionTypeTransformer)
+
+export type InstructionTypeTransformers = z.infer<
+  typeof InstructionTypeTransformers
+>
+
 export const InstructionSourceType = z.object({
   file: z.string(),
   exportStaticType: z.boolean().optional(),
@@ -12,6 +27,7 @@ export const Instruction = z.object({
   runtypeFormat: z.string().optional(),
   sourceTypes: InstructionSourceType.or(z.array(InstructionSourceType)),
   targetFile: z.string(),
+  transformers: InstructionTypeTransformers.optional(),
   typeFormat: z.string().optional(),
 })
 

packages/io-ts/fixtures/transformer.ts

@@ -0,0 +1,7 @@
+import { string, TypeOf } from 'io-ts';
+
+// This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
+// Manual changes might be lost - proceed with caution!
+export const TransformStringToNumber = string;
+
+export type TransformStringToNumber = TypeOf<typeof TransformStringToNumber>;

packages/io-ts/test/typewriter.test.ts

@@ -8,6 +8,7 @@ testTypeWriter<t.Type<any>>({
   createNumberValidator: () => t.number,
   createStringValidator: () => t.string,
   createObjectValidator: t.type,
+  ignore: ['transformer'],
   typeWriters: new IoTsTypeWriters(),
   validate(validator, data) {
     pipe(

packages/runtypes/fixtures/transformer.ts

@@ -0,0 +1,7 @@
+import { Static, String } from 'runtypes';
+
+// This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
+// Manual changes might be lost - proceed with caution!
+export const TransformStringToNumber = String;
+
+export type TransformStringToNumber = Static<typeof TransformStringToNumber>;

packages/runtypes/test/typewriters.test.ts

@@ -6,6 +6,7 @@ testTypeWriters<Runtype>({
   createNumberValidator: () => Number,
   createStringValidator: () => String,
   createObjectValidator: Record,
+  ignore: ['transformer'],
   typeWriters: new RuntypesTypeWriters(),
   validate(validator, data) {
     validator.check(data)

packages/test-type-writers/fixtures/data/transformer.ts

@@ -0,0 +1,7 @@
+import { TestData } from '../../src/types'
+import * as T from '../source/transformer'
+
+export const TransformStringToNumber: TestData<T.TransformStringToNumber> = {
+  success: ['123'],
+  failure: [123],
+}

packages/test-type-writers/fixtures/source/transformer.ts

@@ -0,0 +1 @@
+export type TransformStringToNumber = string

packages/test-type-writers/src/fixture.ts

@@ -73,6 +73,12 @@ async function generate(
     typeWriters,
     targetFile: pathHelper.join(fixturesDestDir, `${testName}.ts`),
     project,
+    transformers: {
+      TransformStringToNumber: {
+        file: '@runtyping/test-type-writers/dist/transformers/stringToNumber',
+        export: 'stringToNumber',
+      },
+    },
     ...generatorOpts,
   })
 

packages/test-type-writers/src/index.ts

@@ -24,6 +24,12 @@ export default function testTypeWriters<Validator>(
     const generator = new Generator({
       typeWriters: props.typeWriters,
       targetFile: pathHelper.join(fixturesDestDir, 'without-static-types.ts'),
+      transformers: {
+        TransformStringToNumber: {
+          file: '@runtyping/test-type-writers/dist/transformers/stringToNumber',
+          export: 'stringToNumber',
+        },
+      },
     })
     const sourceFile = await generator.generate([
       {

packages/test-type-writers/src/transformers/stringToNumber.ts

@@ -0,0 +1,3 @@
+export function stringToNumber(x: string): number {
+  return Number(x)
+}

packages/zod/README.md

@@ -20,6 +20,10 @@ npm install -D @runtyping/zod
 
    targetFile: ./src/other-runtypes.ts # The file to create
    runtypeFormat: {type}Rt # Optional: use a custom name format for the created runtype
+   transformers: # Optional: specify a transformer for a type
+     [TYPENAME]:
+       file: /path/to/transformer
+       export: exportNameOfTranformer
    typeFormat: {type}Type  # Optional: use a custom name format for the created type
    sourceTypes:
      exportStaticType: true # Optional: export static types as well (true by default)

packages/zod/fixtures/array.ts

@@ -1,11 +1,11 @@
-import { array, infer as Infer, number, object, string } from 'zod';
+import { array, number, object, output, string } from 'zod';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const A = object({ foo: string(), });
 
-export type A = Infer<typeof A>;
+export type A = output<typeof A>;
 
 export const B = array(string().or(number()).or(A));
 
-export type B = Infer<typeof B>;
+export type B = output<typeof B>;

packages/zod/fixtures/boolean.ts

@@ -1,7 +1,7 @@
-import { boolean, infer as Infer } from 'zod';
+import { boolean, output } from 'zod';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const A = boolean();
 
-export type A = Infer<typeof A>;
+export type A = output<typeof A>;

packages/zod/fixtures/builtin.ts

@@ -1,7 +1,7 @@
-import { infer as Infer, instanceof as InstanceOf, object } from 'zod';
+import { instanceof as InstanceOf, object, output } from 'zod';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const A = object({ a: InstanceOf(Uint8Array), });
 
-export type A = Infer<typeof A>;
+export type A = output<typeof A>;

packages/zod/fixtures/circular-references.ts

@@ -1,16 +1,16 @@
-import { array, infer as Infer, lazy, literal, object, undefined as Undefined, ZodType } from 'zod';
+import { array, lazy, literal, object, output, undefined as Undefined, ZodType } from 'zod';
 import { Student as _Student, Teacher as _Teacher } from '../../../.yarn/__virtual__/@runtyping-test-type-writers-virtual-f1a80c3a62/1/packages/test-type-writers/fixtures/source/circular-references';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const Teacher: ZodType<_Teacher> = lazy(() => object({ type: literal("teacher"), students: array(Student).or(Undefined()).optional(), reportsTo: Teacher.or(Undefined()).optional(), }));
 
-export type Teacher = Infer<typeof Teacher>;
+export type Teacher = output<typeof Teacher>;
 
 export const Student: ZodType<_Student> = lazy(() => object({ type: literal("student"), teacher: Teacher, }));
 
-export type Student = Infer<typeof Student>;
+export type Student = output<typeof Student>;
 
 export const User = Student.or(Teacher);
 
-export type User = Infer<typeof User>;
+export type User = output<typeof User>;

packages/zod/fixtures/duplicate-references.ts

@@ -1,11 +1,11 @@
-import { infer as Infer, null as Null, object, string } from 'zod';
+import { null as Null, object, output, string } from 'zod';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const FooType = Null().or(string());
 
-export type FooType = Infer<typeof FooType>;
+export type FooType = output<typeof FooType>;
 
 export const HorseType = object({ a: FooType, b: FooType, });
 
-export type HorseType = Infer<typeof HorseType>;
+export type HorseType = output<typeof HorseType>;

packages/zod/fixtures/enum.ts

@@ -1,28 +1,28 @@
-import { infer as Infer, literal, nativeEnum, string } from 'zod';
+import { literal, nativeEnum, output, string } from 'zod';
 import { A as _A, B as _B, C as _C, E as _E } from '../../../.yarn/__virtual__/@runtyping-test-type-writers-virtual-f1a80c3a62/1/packages/test-type-writers/fixtures/source/enum';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const A = nativeEnum(_A);
 
-export type A = Infer<typeof A>;
+export type A = output<typeof A>;
 
 export const B = nativeEnum(_B);
 
-export type B = Infer<typeof B>;
+export type B = output<typeof B>;
 
 export const C = nativeEnum(_C);
 
-export type C = Infer<typeof C>;
+export type C = output<typeof C>;
 
 export const D = literal(_C.A3).or(literal(_C.B3));
 
-export type D = Infer<typeof D>;
+export type D = output<typeof D>;
 
 export const F = string().or(literal(_E.S));
 
-export type F = Infer<typeof F>;
+export type F = output<typeof F>;
 
 export const G = literal(_C.A3).or(literal(_C.B3)).or(literal(_C.C3)).or(literal(_E.S));
 
-export type G = Infer<typeof G>;
+export type G = output<typeof G>;

packages/zod/fixtures/generics.ts

@@ -1,39 +1,39 @@
-import { infer as Infer, number, object, string, ZodType } from 'zod';
+import { number, object, output, string, ZodType } from 'zod';
 
 // This file is generated by runtyping (https://github.com/johngeorgewright/runtyping).
 // Manual changes might be lost - proceed with caution!
 export const A = <T extends any,>(T: ZodType<T>,) => object({ type: T, });
 
-export type A<T> = Infer<ReturnType<typeof A<T>>>;
+export type A<T> = output<ReturnType<typeof A<T>>>;
 
 export const B = <T extends string,>(T: ZodType<T>,) => object({ type: T, });
 
-export type B<T extends string> = Infer<ReturnType<typeof B<T>>>;
+export type B<T extends string> = output<ReturnType<typeof B<T>>>;
 
 export const C = <T extends any,>(T: ZodType<T>,) => string().or(T);
 
-export type C<T> = Infer<ReturnType<typeof C<T>>>;
+export type C<T> = output<ReturnType<typeof C<T>>>;
 
 export const D = <T extends number,>(T: ZodType<T>,) => object({ type: T, });
 
-export type D<T extends number> = Infer<ReturnType<typeof D<T>>>;
+export type D<T extends number> = output<ReturnType<typeof D<T>>>;
 
 export const E = object({ foo: string(), });
 
-export type E = Infer<typeof E>;
+export type E = output<typeof E>;
 
-export const F = <T extends Infer<typeof E>,>(T: ZodType<T>,) => object({ type: T, });
+export const F = <T extends output<typeof E>,>(T: ZodType<T>,) => object({ type: T, });
 
-export type F<T extends E> = Infer<ReturnType<typeof F<T>>>;
+export type F<T extends E> = output<ReturnType<typeof F<T>>>;
 
 export const G = object({ abc: A(object({ data: string(), }),), });
 
-export type G = Infer<typeof G>;
+export type G = output<typeof G>;
 
 export const Test = <T extends any,>(T: ZodType<T>,) => T.and(object({ count: number(), }));
 
-export type Test<T> = Infer<ReturnType<typeof Test<T>>>;
+export type Test<T> = output<ReturnType<typeof Test<T>>>;
 
 export const Foo = object({ abc: Test(object({ data: string(), }),), });
 
-export type Foo = Infer<typeof Foo>;
+export type Foo = output<typeof Foo>;