@rexeus/typeweaver-zod-to-ts 0.0.3

package/README.md

@@ -0,0 +1,57 @@
+# @rexeus/typeweaver-zod-to-ts
+
+Generates TypeScript types from Zod schemas.
+
+## Overview
+
+This package provides utilities to transform Zod schemas into TypeScript type representations. It's
+used internally by TypeWeaver framework.
+
+## Features
+
+- Converts Zod schemas to TypeScript AST nodes
+- Prints TypeScript type definitions from Zod schemas
+- Supports all common Zod types (string, number, boolean, object, array, union, etc.)
+
+## Installation
+
+```bash
+npm install @rexeus/typeweaver-zod-to-ts
+```
+
+## Usage
+
+```typescript
+import { TsTypeNode, TsTypePrinter } from "@rexeus/typeweaver-zod-to-ts";
+import { z } from "zod/v4";
+
+// Define a Zod schema
+const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  age: z.number().optional(),
+});
+
+// Convert to TypeScript AST node
+const typeNode = TsTypeNode.fromZod(userSchema);
+
+// Print as TypeScript type string
+const typeString = TsTypePrinter.print(typeNode);
+// Output: { id: string; name: string; email: string; age?: number | undefined; }
+```
+
+## API
+
+### TsTypeNode
+
+- `static fromZod(zodType: $ZodType): TypeNode` - Converts a Zod schema to a TypeScript AST node
+
+### TsTypePrinter
+
+- `static print(tsType: TypeNode): string` - Converts a TypeScript AST node to a string
+  representation
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { TypeNode } from 'typescript';
+import { $ZodType } from 'zod/v4/core';
+
+declare class TsTypeNode {
+    static fromZod(zodType: $ZodType): TypeNode;
+    private static fromZodString;
+    private static fromZodNumber;
+    private static fromZodBigInt;
+    private static fromZodBoolean;
+    private static fromZodDate;
+    private static fromZodSymbol;
+    private static fromZodUndefined;
+    private static fromZodNullable;
+    private static fromZodNull;
+    private static fromZodAny;
+    private static fromZodUnknown;
+    private static fromZodNever;
+    private static fromZodVoid;
+    private static fromZodArray;
+    private static fromZodObject;
+    private static fromZodUnion;
+    private static fromZodIntersection;
+    private static fromZodTuple;
+    private static fromZodRecord;
+    private static fromZodMap;
+    private static fromZodSet;
+    private static fromZodLiteral;
+    private static fromZodEnum;
+    private static fromZodPromise;
+    private static fromZodLazy;
+    private static fromZodOptional;
+    private static fromZodDefault;
+    private static fromZodTemplateLiteral;
+    private static fromZodCustom;
+    private static fromZodTransform;
+    private static fromZodNonOptional;
+    private static fromZodReadonly;
+    private static fromZodNaN;
+    private static fromZodPipe;
+    private static fromZodSuccess;
+    private static fromZodCatch;
+    private static fromZodFile;
+    /**
+     * Returns a TypeScript AST node representing the property key.
+     * If the key is a valid JavaScript identifier, returns an Identifier node.
+     * Otherwise, returns a StringLiteral node.
+     *
+     * @param {string} key - The property key to convert.
+     * @returns {Identifier | StringLiteral} The corresponding AST node for the property key.
+     */
+    private static createTsAstPropertyKey;
+}
+
+declare class TsTypePrinter {
+    static print(tsType: TypeNode): string;
+}
+
+export { TsTypeNode, TsTypePrinter };

package/dist/index.js

@@ -0,0 +1,352 @@
+import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
+import { $ZodString, $ZodNumber, $ZodBigInt, $ZodBoolean, $ZodDate, $ZodSymbol, $ZodUndefined, $ZodNullable, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodVoid, $ZodArray, $ZodObject, $ZodUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodMap, $ZodSet, $ZodLiteral, $ZodEnum, $ZodPromise, $ZodLazy, $ZodOptional, $ZodDefault, $ZodTemplateLiteral, $ZodCustom, $ZodTransform, $ZodNonOptional, $ZodReadonly, $ZodNaN, $ZodPipe, $ZodSuccess, $ZodCatch, $ZodFile } from 'zod/v4/core';
+
+class TsTypeNode {
+  static fromZod(zodType) {
+    if (zodType instanceof $ZodString) {
+      return TsTypeNode.fromZodString(zodType);
+    }
+    if (zodType instanceof $ZodNumber) {
+      return TsTypeNode.fromZodNumber(zodType);
+    }
+    if (zodType instanceof $ZodBigInt) {
+      return TsTypeNode.fromZodBigInt(zodType);
+    }
+    if (zodType instanceof $ZodBoolean) {
+      return TsTypeNode.fromZodBoolean(zodType);
+    }
+    if (zodType instanceof $ZodDate) {
+      return TsTypeNode.fromZodDate(zodType);
+    }
+    if (zodType instanceof $ZodSymbol) {
+      return TsTypeNode.fromZodSymbol(zodType);
+    }
+    if (zodType instanceof $ZodUndefined) {
+      return TsTypeNode.fromZodUndefined(zodType);
+    }
+    if (zodType instanceof $ZodNullable) {
+      return TsTypeNode.fromZodNullable(zodType);
+    }
+    if (zodType instanceof $ZodNull) {
+      return TsTypeNode.fromZodNull(zodType);
+    }
+    if (zodType instanceof $ZodAny) {
+      return TsTypeNode.fromZodAny(zodType);
+    }
+    if (zodType instanceof $ZodUnknown) {
+      return TsTypeNode.fromZodUnknown(zodType);
+    }
+    if (zodType instanceof $ZodNever) {
+      return TsTypeNode.fromZodNever(zodType);
+    }
+    if (zodType instanceof $ZodVoid) {
+      return TsTypeNode.fromZodVoid(zodType);
+    }
+    if (zodType instanceof $ZodArray) {
+      return TsTypeNode.fromZodArray(zodType);
+    }
+    if (zodType instanceof $ZodObject) {
+      return TsTypeNode.fromZodObject(zodType);
+    }
+    if (zodType instanceof $ZodUnion) {
+      return TsTypeNode.fromZodUnion(zodType);
+    }
+    if (zodType instanceof $ZodIntersection) {
+      return TsTypeNode.fromZodIntersection(zodType);
+    }
+    if (zodType instanceof $ZodTuple) {
+      return TsTypeNode.fromZodTuple(zodType);
+    }
+    if (zodType instanceof $ZodRecord) {
+      return TsTypeNode.fromZodRecord(zodType);
+    }
+    if (zodType instanceof $ZodMap) {
+      return TsTypeNode.fromZodMap(zodType);
+    }
+    if (zodType instanceof $ZodSet) {
+      return TsTypeNode.fromZodSet(zodType);
+    }
+    if (zodType instanceof $ZodLiteral) {
+      if (!TsTypeNode) {
+        throw new Error("ZodLiteral has no values");
+      }
+      return TsTypeNode.fromZodLiteral(zodType);
+    }
+    if (zodType instanceof $ZodEnum) {
+      return TsTypeNode.fromZodEnum(zodType);
+    }
+    if (zodType instanceof $ZodPromise) {
+      return TsTypeNode.fromZodPromise(zodType);
+    }
+    if (zodType instanceof $ZodLazy) {
+      return TsTypeNode.fromZodLazy(zodType);
+    }
+    if (zodType instanceof $ZodOptional) {
+      return TsTypeNode.fromZodOptional(zodType);
+    }
+    if (zodType instanceof $ZodDefault) {
+      return TsTypeNode.fromZodDefault(zodType);
+    }
+    if (zodType instanceof $ZodTemplateLiteral) {
+      return TsTypeNode.fromZodTemplateLiteral(zodType);
+    }
+    if (zodType instanceof $ZodCustom) {
+      return TsTypeNode.fromZodCustom(zodType);
+    }
+    if (zodType instanceof $ZodTransform) {
+      return TsTypeNode.fromZodTransform(zodType);
+    }
+    if (zodType instanceof $ZodNonOptional) {
+      return TsTypeNode.fromZodNonOptional(zodType);
+    }
+    if (zodType instanceof $ZodReadonly) {
+      return TsTypeNode.fromZodReadonly(zodType);
+    }
+    if (zodType instanceof $ZodNaN) {
+      return TsTypeNode.fromZodNaN(zodType);
+    }
+    if (zodType instanceof $ZodPipe) {
+      return TsTypeNode.fromZodPipe(zodType);
+    }
+    if (zodType instanceof $ZodSuccess) {
+      return TsTypeNode.fromZodSuccess(zodType);
+    }
+    if (zodType instanceof $ZodCatch) {
+      return TsTypeNode.fromZodCatch(zodType);
+    }
+    if (zodType instanceof $ZodFile) {
+      return TsTypeNode.fromZodFile(zodType);
+    }
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodString(zodString) {
+    return factory.createKeywordTypeNode(SyntaxKind.StringKeyword);
+  }
+  static fromZodNumber(zodNumber) {
+    return factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
+  }
+  static fromZodBigInt(zodBigInt) {
+    return factory.createKeywordTypeNode(SyntaxKind.BigIntKeyword);
+  }
+  static fromZodBoolean(zodBoolean) {
+    return factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword);
+  }
+  static fromZodDate(zodDate) {
+    return factory.createTypeReferenceNode(factory.createIdentifier("Date"));
+  }
+  static fromZodSymbol(zodSymbol) {
+    return factory.createKeywordTypeNode(SyntaxKind.SymbolKeyword);
+  }
+  static fromZodUndefined(zodUndefined) {
+    return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
+  }
+  static fromZodNullable(zodNullable) {
+    const innerType = TsTypeNode.fromZod(zodNullable._zod.def.innerType);
+    return factory.createUnionTypeNode([
+      innerType,
+      factory.createLiteralTypeNode(factory.createNull())
+    ]);
+  }
+  static fromZodNull(zodNull) {
+    return factory.createLiteralTypeNode(factory.createNull());
+  }
+  static fromZodAny(zodAny) {
+    return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
+  }
+  static fromZodUnknown(zodUnknown) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNever(zodNever) {
+    return factory.createKeywordTypeNode(SyntaxKind.NeverKeyword);
+  }
+  static fromZodVoid(zodVoid) {
+    return factory.createKeywordTypeNode(SyntaxKind.VoidKeyword);
+  }
+  static fromZodArray(zodArray) {
+    const innerType = TsTypeNode.fromZod(zodArray._zod.def.element);
+    return factory.createArrayTypeNode(innerType);
+  }
+  static fromZodObject(zodObject) {
+    const entries = Object.entries(zodObject._zod.def.shape);
+    const members = entries.map(([key, nextZodNode]) => {
+      const type = TsTypeNode.fromZod(nextZodNode);
+      if (!nextZodNode._zod?.def) {
+        console.warn(
+          `Zod node for key "${key}" does not have a _zod.def property. This may indicate an issue with the Zod schema.`,
+          {
+            key
+          }
+        );
+      }
+      const { type: nextZodNodeTypeName } = nextZodNode._zod?.def ?? {};
+      const isOptional = nextZodNodeTypeName === "optional";
+      const propertySignature = factory.createPropertySignature(
+        void 0,
+        TsTypeNode.createTsAstPropertyKey(key),
+        isOptional ? factory.createToken(SyntaxKind.QuestionToken) : void 0,
+        type
+      );
+      return propertySignature;
+    });
+    return factory.createTypeLiteralNode(members);
+  }
+  static fromZodUnion(zodUnion) {
+    const options = zodUnion._zod.def.options.map(TsTypeNode.fromZod);
+    return factory.createUnionTypeNode(options);
+  }
+  static fromZodIntersection(zodIntersection) {
+    const left = TsTypeNode.fromZod(zodIntersection._zod.def.left);
+    const right = TsTypeNode.fromZod(zodIntersection._zod.def.right);
+    return factory.createIntersectionTypeNode([left, right]);
+  }
+  static fromZodTuple(zodTuple) {
+    const elements = zodTuple._zod.def.items.map(TsTypeNode.fromZod);
+    return factory.createTupleTypeNode(elements);
+  }
+  static fromZodRecord(zodRecord) {
+    const keyType = TsTypeNode.fromZod(zodRecord._zod.def.keyType);
+    const valueType = TsTypeNode.fromZod(zodRecord._zod.def.valueType);
+    return factory.createTypeReferenceNode(factory.createIdentifier("Record"), [
+      keyType,
+      valueType
+    ]);
+  }
+  static fromZodMap(zodMap) {
+    const keyType = TsTypeNode.fromZod(zodMap._zod.def.keyType);
+    const valueType = TsTypeNode.fromZod(zodMap._zod.def.valueType);
+    return factory.createTypeReferenceNode(factory.createIdentifier("Map"), [
+      keyType,
+      valueType
+    ]);
+  }
+  static fromZodSet(zodSet) {
+    const innerType = TsTypeNode.fromZod(zodSet._zod.def.valueType);
+    return factory.createTypeReferenceNode(factory.createIdentifier("Set"), [
+      innerType
+    ]);
+  }
+  static fromZodLiteral(zodLiteral) {
+    if (zodLiteral._zod.def.values.length === 0) {
+      throw new Error("ZodLiteral has no values");
+    }
+    const value = zodLiteral._zod.def.values[0];
+    if (typeof value === "string") {
+      return factory.createLiteralTypeNode(factory.createStringLiteral(value));
+    }
+    if (typeof value === "number") {
+      return factory.createLiteralTypeNode(factory.createNumericLiteral(value));
+    }
+    if (typeof value === "boolean") {
+      return factory.createLiteralTypeNode(
+        value ? factory.createTrue() : factory.createFalse()
+      );
+    }
+    if (typeof value === "bigint") {
+      return factory.createLiteralTypeNode(
+        factory.createBigIntLiteral(value.toString())
+      );
+    }
+    if (value === null) {
+      return factory.createLiteralTypeNode(factory.createNull());
+    }
+    if (value === void 0) {
+      return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
+    }
+    throw new Error(`Unsupported literal type: ${typeof value}`);
+  }
+  static fromZodEnum(zodEnum) {
+    const entries = Object.entries(zodEnum._zod.def.entries);
+    const types = entries.map(([key, value]) => {
+      return factory.createLiteralTypeNode(factory.createStringLiteral(key));
+    });
+    return factory.createUnionTypeNode(types);
+  }
+  static fromZodPromise(zodPromise) {
+    const innerType = TsTypeNode.fromZod(zodPromise._zod.def.innerType);
+    return factory.createTypeReferenceNode(
+      factory.createIdentifier("Promise"),
+      [innerType]
+    );
+  }
+  static fromZodLazy(zodLazy) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodOptional(zodOptional) {
+    const innerType = TsTypeNode.fromZod(zodOptional._zod.def.innerType);
+    return factory.createUnionTypeNode([
+      innerType,
+      factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword)
+    ]);
+  }
+  static fromZodDefault(zodDefault) {
+    const innerType = TsTypeNode.fromZod(zodDefault._zod.def.innerType);
+    const filteredNodes = [];
+    innerType.forEachChild((node) => {
+      if (node.kind !== SyntaxKind.UndefinedKeyword) {
+        filteredNodes.push(node);
+      }
+    });
+    innerType.types = filteredNodes;
+    return innerType;
+  }
+  static fromZodTemplateLiteral(zodTemplateLiteral) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodCustom(zodCustom) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodTransform(zodTransform) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNonOptional(zodNonOptional) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodReadonly(zodReadonly) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNaN(zodNaN) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodPipe(zodPipe) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodSuccess(zodSuccess) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodCatch(zodCatch) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  static fromZodFile(zodFile) {
+    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
+  }
+  /**
+   * Returns a TypeScript AST node representing the property key.
+   * If the key is a valid JavaScript identifier, returns an Identifier node.
+   * Otherwise, returns a StringLiteral node.
+   *
+   * @param {string} key - The property key to convert.
+   * @returns {Identifier | StringLiteral} The corresponding AST node for the property key.
+   */
+  static createTsAstPropertyKey(key) {
+    if (/^[$A-Z_a-z][\w$]*$/.test(key)) {
+      return factory.createIdentifier(key);
+    }
+    return factory.createStringLiteral(key);
+  }
+}
+
+class TsTypePrinter {
+  static print(tsType) {
+    const sourceFile = createSourceFile(
+      "print.ts",
+      "",
+      ScriptTarget.Latest,
+      false,
+      ScriptKind.TS
+    );
+    const printer = createPrinter();
+    return printer.printNode(EmitHint.Unspecified, tsType, sourceFile);
+  }
+}
+
+export { TsTypeNode, TsTypePrinter };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@rexeus/typeweaver-zod-to-ts",
+  "version": "0.0.3",
+  "description": "Generates TypeScript types from Zod schemas, used by TypeWeaver framework",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "zod",
+    "typescript",
+    "type",
+    "conversion",
+    "generator",
+    "typeweaver"
+  ],
+  "author": "Dennis Wentzien <dw@rexeus.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rexeus/typeweaver.git",
+    "directory": "packages/zod-to-ts"
+  },
+  "bugs": {
+    "url": "https://github.com/rexeus/typeweaver/issues"
+  },
+  "homepage": "https://github.com/rexeus/typeweaver#readme",
+  "dependencies": {
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "zod": "^3.25.67"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "build": "pkgroll --clean-dist",
+    "preversion": "npm run build"
+  }
+}