zodrift 0.1.0

package/dist/core/compare.js

@@ -0,0 +1,190 @@
+import { canonicalSignature, normalizePath, stringifyType, unwrapOptional } from "./type-utils.js";
+function isUnknownNode(node) {
+    return node.kind === "primitive" && node.name === "unknown";
+}
+function normalizeComparable(node) {
+    const unwrapped = unwrapOptional(node);
+    return unwrapped.node;
+}
+function addIssue(issues, issue) {
+    issues.push({
+        ...issue,
+        message: issue.message ??
+            `${issue.kind} at ${issue.path || "(root)"}: type=${issue.typeValue ?? "n/a"}, schema=${issue.schemaValue ?? "n/a"}`,
+    });
+}
+function compareUnion(pairName, path, typeNode, schemaNode, issues, typeLocation, schemaLocation) {
+    if (typeNode.kind !== "union" || schemaNode.kind !== "union") {
+        addIssue(issues, {
+            kind: "type_mismatch",
+            pairName,
+            path,
+            typeValue: stringifyType(typeNode),
+            schemaValue: stringifyType(schemaNode),
+            typeLocation,
+            schemaLocation,
+            message: `type mismatch for ${path || "(root)"}: type=${stringifyType(typeNode)}, schema=${stringifyType(schemaNode)}`,
+        });
+        return;
+    }
+    const typeSet = new Set(typeNode.members.map((member) => canonicalSignature(member)));
+    const schemaSet = new Set(schemaNode.members.map((member) => canonicalSignature(member)));
+    const equal = typeSet.size === schemaSet.size &&
+        Array.from(typeSet).every((value) => schemaSet.has(value));
+    if (!equal) {
+        addIssue(issues, {
+            kind: "type_mismatch",
+            pairName,
+            path,
+            typeValue: stringifyType(typeNode),
+            schemaValue: stringifyType(schemaNode),
+            typeLocation,
+            schemaLocation,
+            message: `type mismatch for ${path || "(root)"}: type=${stringifyType(typeNode)}, schema=${stringifyType(schemaNode)}`,
+        });
+    }
+}
+function compareNode(pairName, path, typeNodeRaw, schemaNodeRaw, issues, typeLocation, schemaLocation) {
+    const typeNode = normalizeComparable(typeNodeRaw);
+    const schemaNode = normalizeComparable(schemaNodeRaw);
+    if (isUnknownNode(typeNode) || isUnknownNode(schemaNode)) {
+        return;
+    }
+    if (typeNode.kind === "object" && schemaNode.kind === "object") {
+        const typeProps = typeNode.properties;
+        const schemaProps = schemaNode.properties;
+        for (const [name, typeProp] of Object.entries(typeProps)) {
+            const nestedPath = normalizePath(path, name);
+            const schemaProp = schemaProps[name];
+            if (!schemaProp) {
+                addIssue(issues, {
+                    kind: "missing_in_schema",
+                    pairName,
+                    path: nestedPath,
+                    typeLocation: typeProp.location ?? typeLocation,
+                    schemaLocation,
+                    message: `missing in schema: ${nestedPath}`,
+                });
+                continue;
+            }
+            if (typeProp.optional !== schemaProp.optional) {
+                addIssue(issues, {
+                    kind: "optional_mismatch",
+                    pairName,
+                    path: nestedPath,
+                    typeValue: typeProp.optional ? "optional" : "required",
+                    schemaValue: schemaProp.optional ? "optional" : "required",
+                    typeLocation: typeProp.location ?? typeLocation,
+                    schemaLocation: schemaProp.location ?? schemaLocation,
+                    message: `optional mismatch for ${nestedPath}: type=${typeProp.optional ? "optional" : "required"}, schema=${schemaProp.optional ? "optional" : "required"}`,
+                });
+            }
+            compareNode(pairName, nestedPath, typeProp.type, schemaProp.type, issues, typeProp.location ?? typeLocation, schemaProp.location ?? schemaLocation);
+        }
+        for (const [name, schemaProp] of Object.entries(schemaProps)) {
+            if (typeProps[name]) {
+                continue;
+            }
+            const nestedPath = normalizePath(path, name);
+            addIssue(issues, {
+                kind: "extra_in_schema",
+                pairName,
+                path: nestedPath,
+                typeLocation,
+                schemaLocation: schemaProp.location ?? schemaLocation,
+                message: `extra in schema: ${nestedPath}`,
+            });
+        }
+        return;
+    }
+    if (typeNode.kind === "array" && schemaNode.kind === "array") {
+        compareNode(pairName, `${path}[]`, typeNode.element, schemaNode.element, issues, typeLocation, schemaLocation);
+        return;
+    }
+    if (typeNode.kind === "tuple" && schemaNode.kind === "tuple") {
+        if (typeNode.items.length !== schemaNode.items.length) {
+            addIssue(issues, {
+                kind: "type_mismatch",
+                pairName,
+                path,
+                typeValue: stringifyType(typeNode),
+                schemaValue: stringifyType(schemaNode),
+                typeLocation,
+                schemaLocation,
+                message: `type mismatch for ${path || "(root)"}: type=${stringifyType(typeNode)}, schema=${stringifyType(schemaNode)}`,
+            });
+            return;
+        }
+        for (let i = 0; i < typeNode.items.length; i += 1) {
+            compareNode(pairName, `${path}[${i}]`, typeNode.items[i], schemaNode.items[i], issues, typeLocation, schemaLocation);
+        }
+        return;
+    }
+    if (typeNode.kind === "union" || schemaNode.kind === "union") {
+        compareUnion(pairName, path, typeNode, schemaNode, issues, typeLocation, schemaLocation);
+        return;
+    }
+    if (typeNode.kind === "literal" && schemaNode.kind === "literal") {
+        if (typeNode.value !== schemaNode.value) {
+            addIssue(issues, {
+                kind: "type_mismatch",
+                pairName,
+                path,
+                typeValue: stringifyType(typeNode),
+                schemaValue: stringifyType(schemaNode),
+                typeLocation,
+                schemaLocation,
+                message: `type mismatch for ${path || "(root)"}: type=${stringifyType(typeNode)}, schema=${stringifyType(schemaNode)}`,
+            });
+        }
+        return;
+    }
+    if (typeNode.kind === "reference" && schemaNode.kind === "reference") {
+        if (typeNode.name !== schemaNode.name) {
+            addIssue(issues, {
+                kind: "type_mismatch",
+                pairName,
+                path,
+                typeValue: typeNode.name,
+                schemaValue: schemaNode.name,
+                typeLocation,
+                schemaLocation,
+                message: `type mismatch for ${path || "(root)"}: type=${typeNode.name}, schema=${schemaNode.name}`,
+            });
+        }
+        return;
+    }
+    if (typeNode.kind === "primitive" && schemaNode.kind === "primitive") {
+        if (typeNode.name !== schemaNode.name) {
+            addIssue(issues, {
+                kind: "type_mismatch",
+                pairName,
+                path,
+                typeValue: typeNode.name,
+                schemaValue: schemaNode.name,
+                typeLocation,
+                schemaLocation,
+                message: `type mismatch for ${path || "(root)"}: type=${typeNode.name}, schema=${schemaNode.name}`,
+            });
+        }
+        return;
+    }
+    if (canonicalSignature(typeNode) !== canonicalSignature(schemaNode)) {
+        addIssue(issues, {
+            kind: "type_mismatch",
+            pairName,
+            path,
+            typeValue: stringifyType(typeNode),
+            schemaValue: stringifyType(schemaNode),
+            typeLocation,
+            schemaLocation,
+            message: `type mismatch for ${path || "(root)"}: type=${stringifyType(typeNode)}, schema=${stringifyType(schemaNode)}`,
+        });
+    }
+}
+export function comparePair(pair) {
+    const pairName = `${pair.typeDecl.name} ↔ ${pair.schemaDecl.name}`;
+    const issues = [];
+    compareNode(pairName, "", pair.typeDecl.node, pair.schemaDecl.node, issues, pair.typeDecl.location, pair.schemaDecl.location);
+    return issues;
+}

package/dist/core/emit.d.ts

@@ -0,0 +1,10 @@
+import type { TypeNode } from "./types.js";
+export declare function typeNodeToZod(node: TypeNode): string;
+export declare function typeNodeToTs(node: TypeNode): string;
+export declare function typeNodeToOpenApi(node: TypeNode): Record<string, unknown>;
+export interface FormField {
+    path: string;
+    required: boolean;
+    type: string;
+}
+export declare function typeNodeToFormFields(node: TypeNode): FormField[];

package/dist/core/emit.js

@@ -0,0 +1,229 @@
+import { unwrapOptional } from "./type-utils.js";
+function isSimpleIdentifier(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+function quoteKey(name) {
+    return isSimpleIdentifier(name) ? name : JSON.stringify(name);
+}
+export function typeNodeToZod(node) {
+    const normalized = unwrapOptional(node);
+    let body = "z.unknown()";
+    switch (normalized.node.kind) {
+        case "primitive":
+            switch (normalized.node.name) {
+                case "string":
+                    body = "z.string()";
+                    break;
+                case "number":
+                    body = "z.number()";
+                    break;
+                case "boolean":
+                    body = "z.boolean()";
+                    break;
+                case "any":
+                    body = "z.any()";
+                    break;
+                case "unknown":
+                    body = "z.unknown()";
+                    break;
+                case "null":
+                    body = "z.null()";
+                    break;
+                case "undefined":
+                    body = "z.undefined()";
+                    break;
+                default:
+                    body = "z.unknown()";
+                    break;
+            }
+            break;
+        case "literal":
+            body = `z.literal(${JSON.stringify(normalized.node.value)})`;
+            break;
+        case "array":
+            body = `z.array(${typeNodeToZod(normalized.node.element)})`;
+            break;
+        case "tuple":
+            body = `z.tuple([${normalized.node.items.map((item) => typeNodeToZod(item)).join(", ")}])`;
+            break;
+        case "union":
+            body = `z.union([${normalized.node.members.map((member) => typeNodeToZod(member)).join(", ")}])`;
+            break;
+        case "reference":
+            body = `${normalized.node.name}Schema`;
+            break;
+        case "object": {
+            const fields = Object.values(normalized.node.properties)
+                .map((property) => {
+                const zodType = property.optional
+                    ? `${typeNodeToZod(property.type)}.optional()`
+                    : typeNodeToZod(property.type);
+                return `${quoteKey(property.name)}: ${zodType}`;
+            })
+                .join(", ");
+            body = `z.object({ ${fields} })`;
+            break;
+        }
+        case "optional":
+            body = `${typeNodeToZod(normalized.node.inner)}.optional()`;
+            break;
+        default:
+            body = "z.unknown()";
+            break;
+    }
+    if (normalized.optional) {
+        return `${body}.optional()`;
+    }
+    return body;
+}
+export function typeNodeToTs(node) {
+    const normalized = unwrapOptional(node);
+    let body = "unknown";
+    switch (normalized.node.kind) {
+        case "primitive":
+            body = normalized.node.name;
+            break;
+        case "literal":
+            body = JSON.stringify(normalized.node.value);
+            break;
+        case "array":
+            body = `${typeNodeToTs(normalized.node.element)}[]`;
+            break;
+        case "tuple":
+            body = `[${normalized.node.items.map((item) => typeNodeToTs(item)).join(", ")}]`;
+            break;
+        case "union":
+            body = normalized.node.members.map((member) => typeNodeToTs(member)).join(" | ");
+            break;
+        case "reference":
+            body = normalized.node.name;
+            break;
+        case "object": {
+            const fields = Object.values(normalized.node.properties)
+                .map((property) => `${quoteKey(property.name)}${property.optional ? "?" : ""}: ${typeNodeToTs(property.type)}`)
+                .join("; ");
+            body = `{ ${fields} }`;
+            break;
+        }
+        case "optional":
+            body = `${typeNodeToTs(normalized.node.inner)} | undefined`;
+            break;
+        default:
+            body = "unknown";
+            break;
+    }
+    return normalized.optional ? `${body} | undefined` : body;
+}
+export function typeNodeToOpenApi(node) {
+    const normalized = unwrapOptional(node);
+    switch (normalized.node.kind) {
+        case "primitive":
+            switch (normalized.node.name) {
+                case "string":
+                    return { type: "string" };
+                case "number":
+                    return { type: "number" };
+                case "boolean":
+                    return { type: "boolean" };
+                case "null":
+                    return { type: "null" };
+                default:
+                    return {};
+            }
+        case "literal":
+            return { enum: [normalized.node.value] };
+        case "array":
+            return {
+                type: "array",
+                items: typeNodeToOpenApi(normalized.node.element),
+            };
+        case "tuple":
+            return {
+                type: "array",
+                prefixItems: normalized.node.items.map((item) => typeNodeToOpenApi(item)),
+            };
+        case "union":
+            return {
+                oneOf: normalized.node.members.map((member) => typeNodeToOpenApi(member)),
+            };
+        case "reference":
+            return {
+                $ref: `#/components/schemas/${normalized.node.name}`,
+            };
+        case "object": {
+            const properties = {};
+            const required = [];
+            for (const property of Object.values(normalized.node.properties)) {
+                properties[property.name] = typeNodeToOpenApi(property.type);
+                if (!property.optional) {
+                    required.push(property.name);
+                }
+            }
+            return {
+                type: "object",
+                properties,
+                ...(required.length > 0 ? { required } : {}),
+            };
+        }
+        case "optional": {
+            return {
+                anyOf: [typeNodeToOpenApi(normalized.node.inner), { type: "null" }],
+            };
+        }
+        default:
+            return {};
+    }
+}
+function primitiveUiType(node) {
+    const normalized = unwrapOptional(node);
+    switch (normalized.node.kind) {
+        case "primitive":
+            return normalized.node.name;
+        case "literal":
+            return typeof normalized.node.value;
+        case "array":
+            return "array";
+        case "object":
+            return "object";
+        case "union":
+            return "union";
+        case "tuple":
+            return "tuple";
+        case "reference":
+            return "reference";
+        default:
+            return "unknown";
+    }
+}
+function collectFromProperty(property, basePath, requiredFromParent, fields) {
+    const path = basePath ? `${basePath}.${property.name}` : property.name;
+    const required = requiredFromParent && !property.optional;
+    const normalized = unwrapOptional(property.type);
+    if (normalized.node.kind === "object") {
+        for (const childProperty of Object.values(normalized.node.properties)) {
+            collectFromProperty(childProperty, path, required, fields);
+        }
+        return;
+    }
+    fields.push({
+        path,
+        required,
+        type: primitiveUiType(property.type),
+    });
+}
+export function typeNodeToFormFields(node) {
+    const fields = [];
+    const normalized = unwrapOptional(node);
+    if (normalized.node.kind === "object") {
+        for (const property of Object.values(normalized.node.properties)) {
+            collectFromProperty(property, "", true, fields);
+        }
+        return fields;
+    }
+    fields.push({
+        path: "$",
+        required: true,
+        type: primitiveUiType(node),
+    });
+    return fields;
+}

package/dist/core/file-discovery.d.ts

@@ -0,0 +1,5 @@
+export declare function discoverSourceFiles(options: {
+    cwd: string;
+    pattern: string;
+    changedOnly: boolean;
+}): string[];

package/dist/core/file-discovery.js

@@ -0,0 +1,37 @@
+import { execSync } from "node:child_process";
+import path from "node:path";
+import ts from "typescript";
+function readFilesByPattern(cwd, pattern) {
+    const files = ts.sys.readDirectory(cwd, [".ts", ".tsx"], undefined, [pattern]);
+    return files.filter((filePath) => !filePath.endsWith(".d.ts"));
+}
+function gitChangedFiles(cwd) {
+    try {
+        const output = execSync("git diff --name-only --diff-filter=ACMR && git diff --name-only --cached --diff-filter=ACMR", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString("utf8")
+            .trim();
+        if (!output) {
+            return [];
+        }
+        const all = output
+            .split(/\r?\n/)
+            .map((item) => item.trim())
+            .filter(Boolean)
+            .map((item) => path.resolve(cwd, item));
+        return Array.from(new Set(all));
+    }
+    catch {
+        return [];
+    }
+}
+export function discoverSourceFiles(options) {
+    const allFiles = readFilesByPattern(options.cwd, options.pattern);
+    if (!options.changedOnly) {
+        return allFiles;
+    }
+    const changed = new Set(gitChangedFiles(options.cwd));
+    if (changed.size === 0) {
+        return allFiles;
+    }
+    return allFiles.filter((filePath) => changed.has(path.resolve(filePath)));
+}

package/dist/core/pairing.d.ts

@@ -0,0 +1,6 @@
+import type { Pairing, SchemaDeclaration, TypeDeclaration } from "./types.js";
+export declare function pairTypesWithSchemas(typeDeclarations: TypeDeclaration[], schemaDeclarations: SchemaDeclaration[]): {
+    pairs: Pairing[];
+    unmatchedTypes: string[];
+    unmatchedSchemas: string[];
+};

package/dist/core/pairing.js

@@ -0,0 +1,27 @@
+export function pairTypesWithSchemas(typeDeclarations, schemaDeclarations) {
+    const typeMap = new Map(typeDeclarations.map((declaration) => [declaration.name, declaration]));
+    const schemaMap = new Map(schemaDeclarations.map((declaration) => [declaration.name, declaration]));
+    const pairs = [];
+    for (const schemaDecl of schemaDeclarations) {
+        if (!schemaDecl.name.endsWith("Schema")) {
+            continue;
+        }
+        const baseName = schemaDecl.name.slice(0, -"Schema".length);
+        const typeDecl = typeMap.get(baseName);
+        if (typeDecl) {
+            pairs.push({
+                typeDecl,
+                schemaDecl,
+            });
+        }
+    }
+    const pairedTypeNames = new Set(pairs.map((pair) => pair.typeDecl.name));
+    const pairedSchemaNames = new Set(pairs.map((pair) => pair.schemaDecl.name));
+    const unmatchedTypes = Array.from(typeMap.keys()).filter((name) => !pairedTypeNames.has(name));
+    const unmatchedSchemas = Array.from(schemaMap.keys()).filter((name) => !pairedSchemaNames.has(name));
+    return {
+        pairs,
+        unmatchedTypes,
+        unmatchedSchemas,
+    };
+}

package/dist/core/ts-parser.d.ts

@@ -0,0 +1,5 @@
+import type { TypeDeclaration } from "./types.js";
+export declare function parseTypeDeclarations(filePaths: string[]): {
+    declarations: TypeDeclaration[];
+    errors: string[];
+};