zodrift 0.1.0

package/dist/core/zod-parser.js

@@ -0,0 +1,321 @@
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { cloneTypeNode, locationFromTs, makePrimitive, stripUndefinedFromUnion, unwrapOptional } from "./type-utils.js";
+function isExported(node) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    return !!modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+function getLocationFromNode(sourceFile, node) {
+    const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    return locationFromTs(path.resolve(sourceFile.fileName), pos.line, pos.character);
+}
+function normalizePropertyType(node) {
+    const unwrapped = unwrapOptional(node);
+    let optional = unwrapped.optional;
+    let next = unwrapped.node;
+    if (next.kind === "union") {
+        const stripped = stripUndefinedFromUnion(next);
+        optional = optional || stripped.optional;
+        next = stripped.node;
+    }
+    return {
+        optional,
+        node: next,
+    };
+}
+function parseLiteralExpression(node) {
+    if (ts.isStringLiteral(node)) {
+        return { kind: "literal", value: node.text };
+    }
+    if (ts.isNumericLiteral(node)) {
+        return { kind: "literal", value: Number(node.text) };
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword) {
+        return { kind: "literal", value: true };
+    }
+    if (node.kind === ts.SyntaxKind.FalseKeyword) {
+        return { kind: "literal", value: false };
+    }
+    if (node.kind === ts.SyntaxKind.NullKeyword) {
+        return { kind: "literal", value: null };
+    }
+    return makePrimitive("unknown");
+}
+function wrapUnion(nodes) {
+    if (nodes.length === 1) {
+        return nodes[0];
+    }
+    return {
+        kind: "union",
+        members: nodes,
+    };
+}
+function parseShapeObject(node, sourceFile, variableMap, seen) {
+    const properties = {};
+    for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop)) {
+            continue;
+        }
+        let propName = "";
+        let initializer = null;
+        if (ts.isShorthandPropertyAssignment(prop)) {
+            propName = prop.name.text;
+            initializer = prop.name;
+        }
+        else {
+            if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) || ts.isNumericLiteral(prop.name)) {
+                propName = prop.name.text;
+            }
+            else {
+                propName = prop.name.getText(sourceFile);
+            }
+            initializer = prop.initializer;
+        }
+        if (!initializer) {
+            continue;
+        }
+        const parsed = parseZodExpression(initializer, sourceFile, variableMap, seen);
+        const normalized = normalizePropertyType(parsed);
+        properties[propName] = {
+            name: propName,
+            optional: normalized.optional,
+            type: normalized.node,
+            location: getLocationFromNode(sourceFile, prop.name),
+        };
+    }
+    return {
+        kind: "object",
+        properties,
+        location: getLocationFromNode(sourceFile, node),
+    };
+}
+function parseZodFactory(method, args, sourceFile, variableMap, seen) {
+    switch (method) {
+        case "string":
+            return { kind: "primitive", name: "string" };
+        case "number":
+            return { kind: "primitive", name: "number" };
+        case "boolean":
+            return { kind: "primitive", name: "boolean" };
+        case "any":
+            return { kind: "primitive", name: "any" };
+        case "unknown":
+            return { kind: "primitive", name: "unknown" };
+        case "null":
+            return { kind: "primitive", name: "null" };
+        case "undefined":
+            return { kind: "primitive", name: "undefined" };
+        case "literal":
+            return args[0] ? parseLiteralExpression(args[0]) : makePrimitive("unknown");
+        case "object": {
+            if (args[0] && ts.isObjectLiteralExpression(args[0])) {
+                return parseShapeObject(args[0], sourceFile, variableMap, seen);
+            }
+            return {
+                kind: "object",
+                properties: {},
+            };
+        }
+        case "array":
+            return {
+                kind: "array",
+                element: args[0]
+                    ? parseZodExpression(args[0], sourceFile, variableMap, seen)
+                    : makePrimitive("unknown"),
+            };
+        case "union": {
+            const firstArg = args[0];
+            if (!firstArg || !ts.isArrayLiteralExpression(firstArg)) {
+                return makePrimitive("unknown");
+            }
+            return {
+                kind: "union",
+                members: firstArg.elements.map((element) => parseZodExpression(element, sourceFile, variableMap, seen)),
+            };
+        }
+        case "tuple": {
+            const firstArg = args[0];
+            if (!firstArg || !ts.isArrayLiteralExpression(firstArg)) {
+                return makePrimitive("unknown");
+            }
+            return {
+                kind: "tuple",
+                items: firstArg.elements.map((element) => parseZodExpression(element, sourceFile, variableMap, seen)),
+            };
+        }
+        case "enum": {
+            const firstArg = args[0];
+            if (!firstArg || !ts.isArrayLiteralExpression(firstArg)) {
+                return makePrimitive("unknown");
+            }
+            const members = firstArg.elements
+                .filter((element) => ts.isStringLiteral(element) || ts.isNumericLiteral(element))
+                .map((element) => ts.isStringLiteral(element)
+                ? { kind: "literal", value: element.text }
+                : { kind: "literal", value: Number(element.text) });
+            return members.length > 0 ? wrapUnion(members) : makePrimitive("unknown");
+        }
+        case "optional": {
+            const inner = args[0]
+                ? parseZodExpression(args[0], sourceFile, variableMap, seen)
+                : makePrimitive("unknown");
+            return {
+                kind: "optional",
+                inner,
+            };
+        }
+        case "nullable": {
+            const inner = args[0]
+                ? parseZodExpression(args[0], sourceFile, variableMap, seen)
+                : makePrimitive("unknown");
+            return wrapUnion([inner, { kind: "primitive", name: "null" }]);
+        }
+        default:
+            return makePrimitive("unknown");
+    }
+}
+function applyMethod(base, method, args, sourceFile, variableMap, seen) {
+    switch (method) {
+        case "optional":
+            return {
+                kind: "optional",
+                inner: base,
+            };
+        case "nullable":
+            return wrapUnion([base, { kind: "primitive", name: "null" }]);
+        case "nullish":
+            return {
+                kind: "optional",
+                inner: wrapUnion([base, { kind: "primitive", name: "null" }]),
+            };
+        case "array":
+            return {
+                kind: "array",
+                element: base,
+            };
+        case "or": {
+            const right = args[0]
+                ? parseZodExpression(args[0], sourceFile, variableMap, seen)
+                : makePrimitive("unknown");
+            if (base.kind === "union") {
+                return {
+                    kind: "union",
+                    members: [...base.members, right],
+                };
+            }
+            return {
+                kind: "union",
+                members: [base, right],
+            };
+        }
+        case "and": {
+            const right = args[0]
+                ? parseZodExpression(args[0], sourceFile, variableMap, seen)
+                : makePrimitive("unknown");
+            return {
+                kind: "union",
+                members: [base, right],
+            };
+        }
+        default:
+            // Refinement/metadata methods do not alter the structural type shape.
+            return base;
+    }
+}
+function parseZodExpression(expression, sourceFile, variableMap, seen) {
+    if (ts.isIdentifier(expression)) {
+        const referenced = variableMap.get(expression.text);
+        if (!referenced || !referenced.initializer || seen.has(expression.text)) {
+            return {
+                kind: "reference",
+                name: expression.text,
+                location: getLocationFromNode(sourceFile, expression),
+            };
+        }
+        seen.add(expression.text);
+        const parsed = parseZodExpression(referenced.initializer, sourceFile, variableMap, seen);
+        seen.delete(expression.text);
+        return cloneTypeNode(parsed);
+    }
+    if (ts.isCallExpression(expression)) {
+        const callee = expression.expression;
+        if (ts.isPropertyAccessExpression(callee)) {
+            const method = callee.name.text;
+            if (ts.isIdentifier(callee.expression) && callee.expression.text === "z") {
+                return {
+                    ...parseZodFactory(method, expression.arguments, sourceFile, variableMap, seen),
+                    location: getLocationFromNode(sourceFile, expression),
+                };
+            }
+            const base = parseZodExpression(callee.expression, sourceFile, variableMap, seen);
+            return {
+                ...applyMethod(base, method, expression.arguments, sourceFile, variableMap, seen),
+                location: getLocationFromNode(sourceFile, expression),
+            };
+        }
+        if (ts.isIdentifier(callee) && callee.text === "z") {
+            return makePrimitive("unknown");
+        }
+    }
+    return {
+        kind: "primitive",
+        name: "unknown",
+        location: getLocationFromNode(sourceFile, expression),
+    };
+}
+function collectVariables(sourceFile) {
+    const variableMap = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name)) {
+                variableMap.set(declaration.name.text, declaration);
+            }
+        }
+    }
+    return variableMap;
+}
+export function parseSchemaDeclarations(filePaths) {
+    const declarations = [];
+    const errors = [];
+    for (const filePath of filePaths) {
+        try {
+            const absPath = path.resolve(filePath);
+            const content = fs.readFileSync(absPath, "utf8");
+            const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS);
+            const variableMap = collectVariables(sourceFile);
+            for (const statement of sourceFile.statements) {
+                if (!ts.isVariableStatement(statement) || !isExported(statement)) {
+                    continue;
+                }
+                for (const declaration of statement.declarationList.declarations) {
+                    if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+                        continue;
+                    }
+                    const name = declaration.name.text;
+                    if (!name.endsWith("Schema")) {
+                        continue;
+                    }
+                    const parsed = parseZodExpression(declaration.initializer, sourceFile, variableMap, new Set());
+                    declarations.push({
+                        name,
+                        node: parsed,
+                        location: getLocationFromNode(sourceFile, declaration.name),
+                        sourceFilePath: absPath,
+                        objectNodeText: declaration.initializer.getText(sourceFile),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to parse schemas in ${filePath}: ${String(error)}`);
+        }
+    }
+    return {
+        declarations,
+        errors,
+    };
+}

package/dist/reporters/index.d.ts

@@ -0,0 +1,2 @@
+import type { OutputFormat, ReporterPayload } from "../core/types.js";
+export declare function renderOutput(format: OutputFormat, payload: ReporterPayload): string;

package/dist/reporters/index.js

@@ -0,0 +1,14 @@
+import { renderJson } from "./json.js";
+import { renderPretty } from "./pretty.js";
+import { renderSarif } from "./sarif.js";
+export function renderOutput(format, payload) {
+    switch (format) {
+        case "json":
+            return renderJson(payload);
+        case "sarif":
+            return renderSarif(payload);
+        case "pretty":
+        default:
+            return renderPretty(payload);
+    }
+}

package/dist/reporters/json.d.ts

@@ -0,0 +1,2 @@
+import type { ReporterPayload } from "../core/types.js";
+export declare function renderJson(payload: ReporterPayload): string;

package/dist/reporters/json.js

@@ -0,0 +1,18 @@
+export function renderJson(payload) {
+    return JSON.stringify({
+        summary: {
+            checkedPairs: payload.result.checkedPairs,
+            totalIssues: payload.result.totalIssues,
+            unmatchedTypes: payload.result.unmatchedTypes,
+            unmatchedSchemas: payload.result.unmatchedSchemas,
+            errors: payload.result.errors,
+        },
+        pairs: payload.result.pairs.map((pair) => ({
+            typeName: pair.typeName,
+            schemaName: pair.schemaName,
+            typeFile: pair.typeDecl.sourceFilePath,
+            schemaFile: pair.schemaDecl.sourceFilePath,
+            issues: pair.issues,
+        })),
+    }, null, 2);
+}

package/dist/reporters/pretty.d.ts

@@ -0,0 +1,2 @@
+import type { ReporterPayload } from "../core/types.js";
+export declare function renderPretty(payload: ReporterPayload): string;

package/dist/reporters/pretty.js

@@ -0,0 +1,35 @@
+export function renderPretty(payload) {
+    const lines = [];
+    if (payload.result.errors.length > 0) {
+        lines.push("Errors:");
+        for (const error of payload.result.errors) {
+            lines.push(`  - ${error}`);
+        }
+        lines.push("");
+    }
+    for (const pair of payload.result.pairs) {
+        if (pair.issues.length === 0) {
+            continue;
+        }
+        lines.push(`✗ ${pair.typeName} ↔ ${pair.schemaName}`);
+        for (const issue of pair.issues) {
+            lines.push(`  - ${issue.message}`);
+        }
+        lines.push("");
+    }
+    if (payload.result.totalIssues === 0 && payload.result.errors.length === 0) {
+        lines.push("✓ No drift found");
+    }
+    if (payload.result.unmatchedTypes.length > 0) {
+        lines.push(`Unmatched exported types: ${payload.result.unmatchedTypes
+            .slice(0, 20)
+            .join(", ")}`);
+    }
+    if (payload.result.unmatchedSchemas.length > 0) {
+        lines.push(`Unmatched exported schemas: ${payload.result.unmatchedSchemas
+            .slice(0, 20)
+            .join(", ")}`);
+    }
+    lines.push(`Checked pairs: ${payload.result.checkedPairs} | Issues: ${payload.result.totalIssues}`);
+    return lines.join("\n").trim();
+}

package/dist/reporters/sarif.d.ts

@@ -0,0 +1,2 @@
+import type { ReporterPayload } from "../core/types.js";
+export declare function renderSarif(payload: ReporterPayload): string;

package/dist/reporters/sarif.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+function levelForIssue(kind) {
+    switch (kind) {
+        case "type_mismatch":
+        case "optional_mismatch":
+            return "error";
+        default:
+            return "warning";
+    }
+}
+function ruleName(kind) {
+    switch (kind) {
+        case "missing_in_schema":
+            return "missing-field";
+        case "extra_in_schema":
+            return "extra-field";
+        case "optional_mismatch":
+            return "optional-mismatch";
+        case "type_mismatch":
+            return "type-mismatch";
+        default:
+            return "drift";
+    }
+}
+export function renderSarif(payload) {
+    const rules = [
+        {
+            id: "missing-field",
+            shortDescription: { text: "Field exists in TS type but missing in Zod schema" },
+        },
+        {
+            id: "extra-field",
+            shortDescription: { text: "Field exists in Zod schema but not in TS type" },
+        },
+        {
+            id: "optional-mismatch",
+            shortDescription: { text: "Optional/required mismatch between TS and Zod" },
+        },
+        {
+            id: "type-mismatch",
+            shortDescription: { text: "Type mismatch between TS and Zod" },
+        },
+    ];
+    const results = payload.result.pairs.flatMap((pair) => pair.issues.map((issue) => {
+        const location = issue.schemaLocation ?? issue.typeLocation;
+        return {
+            ruleId: ruleName(issue.kind),
+            level: levelForIssue(issue.kind),
+            message: {
+                text: `${pair.typeName} ↔ ${pair.schemaName}: ${issue.message}`,
+            },
+            locations: location
+                ? [
+                    {
+                        physicalLocation: {
+                            artifactLocation: {
+                                uri: path.relative(payload.cwd, location.filePath) || location.filePath,
+                            },
+                            region: {
+                                startLine: location.line,
+                                startColumn: location.column,
+                            },
+                        },
+                    },
+                ]
+                : undefined,
+        };
+    }));
+    return JSON.stringify({
+        version: "2.1.0",
+        $schema: "https://schemastore.azurewebsites.net/schemas/json/sarif-2.1.0.json",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "zodrift",
+                        informationUri: "https://github.com/greyllmmoder/zodrift",
+                        rules,
+                    },
+                },
+                results,
+            },
+        ],
+    }, null, 2);
+}

package/dist/utils/args.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedArgs {
+    command: string | null;
+    flags: Map<string, string | boolean>;
+    positionals: string[];
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function flagString(flags: Map<string, string | boolean>, key: string, fallback: string): string;
+export declare function flagBoolean(flags: Map<string, string | boolean>, key: string, fallback?: boolean): boolean;
+export declare function flagNumber(flags: Map<string, string | boolean>, key: string): number | undefined;

package/dist/utils/args.js

@@ -0,0 +1,55 @@
+export function parseArgs(argv) {
+    const [commandOrNull, ...rest] = argv;
+    const flags = new Map();
+    const positionals = [];
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const withoutPrefix = token.slice(2);
+        if (!withoutPrefix) {
+            continue;
+        }
+        if (withoutPrefix.includes("=")) {
+            const [key, ...valueParts] = withoutPrefix.split("=");
+            flags.set(key, valueParts.join("="));
+            continue;
+        }
+        const next = rest[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags.set(withoutPrefix, next);
+            i += 1;
+            continue;
+        }
+        flags.set(withoutPrefix, true);
+    }
+    return {
+        command: commandOrNull ?? null,
+        flags,
+        positionals,
+    };
+}
+export function flagString(flags, key, fallback) {
+    const value = flags.get(key);
+    return typeof value === "string" ? value : fallback;
+}
+export function flagBoolean(flags, key, fallback = false) {
+    const value = flags.get(key);
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+    }
+    return fallback;
+}
+export function flagNumber(flags, key) {
+    const value = flags.get(key);
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "zodrift",
+  "version": "0.1.0",
+  "description": "Catch drift between your TypeScript types and Zod schemas.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "zodrift": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test src/**/*.test.ts",
+    "check": "npm run dev -- check",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
+  },
+  "keywords": [
+    "zod",
+    "typescript",
+    "schema",
+    "drift",
+    "cli"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "zod": "^3.25.76"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}