zodrift 0.1.0

package/dist/core/ts-parser.js

@@ -0,0 +1,239 @@
+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 literalFromTypeNode(node) {
+    if (node.literal.kind === ts.SyntaxKind.NullKeyword) {
+        return { kind: "literal", value: null };
+    }
+    if (ts.isStringLiteral(node.literal)) {
+        return { kind: "literal", value: node.literal.text };
+    }
+    if (ts.isNumericLiteral(node.literal)) {
+        return { kind: "literal", value: Number(node.literal.text) };
+    }
+    if (node.literal.kind === ts.SyntaxKind.TrueKeyword) {
+        return { kind: "literal", value: true };
+    }
+    if (node.literal.kind === ts.SyntaxKind.FalseKeyword) {
+        return { kind: "literal", value: false };
+    }
+    return makePrimitive("unknown");
+}
+function parseProperty(member, sourceFile, context, visiting) {
+    if (!ts.isPropertySignature(member) || !member.type || !member.name) {
+        return null;
+    }
+    const propName = ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)
+        ? member.name.text
+        : ts.isNumericLiteral(member.name)
+            ? member.name.text
+            : member.name.getText(sourceFile);
+    let parsedType = parseTypeNode(member.type, sourceFile, context, visiting);
+    let optional = Boolean(member.questionToken);
+    if (parsedType.kind === "union") {
+        const stripped = stripUndefinedFromUnion(parsedType);
+        optional = optional || stripped.optional;
+        parsedType = stripped.node;
+    }
+    const unwrapped = unwrapOptional(parsedType);
+    optional = optional || unwrapped.optional;
+    parsedType = unwrapped.node;
+    return {
+        name: propName,
+        optional,
+        type: parsedType,
+        location: getLocationFromNode(sourceFile, member.name),
+    };
+}
+function parseObjectMembers(members, sourceFile, context, visiting) {
+    const properties = {};
+    for (const member of members) {
+        const parsed = parseProperty(member, sourceFile, context, visiting);
+        if (!parsed) {
+            continue;
+        }
+        properties[parsed.name] = parsed;
+    }
+    return {
+        kind: "object",
+        properties,
+    };
+}
+function parseTypeReference(node, sourceFile, context, visiting) {
+    const name = node.typeName.getText(sourceFile);
+    const args = node.typeArguments ?? [];
+    if ((name === "Array" || name === "ReadonlyArray") && args.length === 1) {
+        return {
+            kind: "array",
+            element: parseTypeNode(args[0], sourceFile, context, visiting),
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (context.declarations.has(name)) {
+        return parseNamedDeclaration(name, sourceFile, context, visiting);
+    }
+    return {
+        kind: "reference",
+        name,
+        location: getLocationFromNode(sourceFile, node),
+    };
+}
+function parseTypeNode(node, sourceFile, context, visiting) {
+    switch (node.kind) {
+        case ts.SyntaxKind.StringKeyword:
+            return { kind: "primitive", name: "string", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.NumberKeyword:
+            return { kind: "primitive", name: "number", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.BooleanKeyword:
+            return { kind: "primitive", name: "boolean", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.AnyKeyword:
+            return { kind: "primitive", name: "any", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.UnknownKeyword:
+            return { kind: "primitive", name: "unknown", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.NullKeyword:
+            return { kind: "primitive", name: "null", location: getLocationFromNode(sourceFile, node) };
+        case ts.SyntaxKind.UndefinedKeyword:
+            return { kind: "primitive", name: "undefined", location: getLocationFromNode(sourceFile, node) };
+        default:
+            break;
+    }
+    if (ts.isParenthesizedTypeNode(node)) {
+        return parseTypeNode(node.type, sourceFile, context, visiting);
+    }
+    if (ts.isLiteralTypeNode(node)) {
+        const literal = literalFromTypeNode(node);
+        return {
+            ...literal,
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (ts.isArrayTypeNode(node)) {
+        return {
+            kind: "array",
+            element: parseTypeNode(node.elementType, sourceFile, context, visiting),
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (ts.isTupleTypeNode(node)) {
+        return {
+            kind: "tuple",
+            items: node.elements.map((element) => parseTypeNode(element, sourceFile, context, visiting)),
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (ts.isUnionTypeNode(node)) {
+        return {
+            kind: "union",
+            members: node.types.map((item) => parseTypeNode(item, sourceFile, context, visiting)),
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (ts.isTypeLiteralNode(node)) {
+        return {
+            ...parseObjectMembers(node.members, sourceFile, context, visiting),
+            location: getLocationFromNode(sourceFile, node),
+        };
+    }
+    if (ts.isTypeReferenceNode(node)) {
+        return parseTypeReference(node, sourceFile, context, visiting);
+    }
+    return {
+        kind: "primitive",
+        name: "unknown",
+        location: getLocationFromNode(sourceFile, node),
+    };
+}
+function parseNamedDeclaration(name, sourceFile, context, visiting) {
+    const cached = context.cache.get(name);
+    if (cached) {
+        return cloneTypeNode(cached);
+    }
+    if (visiting.has(name)) {
+        return {
+            kind: "reference",
+            name,
+            location: getLocationFromNode(sourceFile, sourceFile),
+        };
+    }
+    const declaration = context.declarations.get(name);
+    if (!declaration) {
+        return {
+            kind: "reference",
+            name,
+            location: getLocationFromNode(sourceFile, sourceFile),
+        };
+    }
+    visiting.add(name);
+    let parsed;
+    if (ts.isInterfaceDeclaration(declaration.node)) {
+        parsed = {
+            ...parseObjectMembers(declaration.node.members, declaration.sourceFile, context, visiting),
+            location: getLocationFromNode(declaration.sourceFile, declaration.node),
+        };
+    }
+    else {
+        parsed = parseTypeNode(declaration.node.type, declaration.sourceFile, context, visiting);
+    }
+    visiting.delete(name);
+    context.cache.set(name, parsed);
+    return cloneTypeNode(parsed);
+}
+export function parseTypeDeclarations(filePaths) {
+    const errors = [];
+    if (filePaths.length === 0) {
+        return { declarations: [], errors };
+    }
+    const uniqueFilePaths = Array.from(new Set(filePaths.map((item) => path.resolve(item))));
+    const pathSet = new Set(uniqueFilePaths);
+    const program = ts.createProgram(uniqueFilePaths, {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        allowJs: false,
+        skipLibCheck: true,
+    });
+    const declarationsMap = new Map();
+    for (const sourceFile of program.getSourceFiles()) {
+        const sourcePath = path.resolve(sourceFile.fileName);
+        if (!pathSet.has(sourcePath)) {
+            continue;
+        }
+        for (const statement of sourceFile.statements) {
+            if ((ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) &&
+                isExported(statement)) {
+                declarationsMap.set(statement.name.text, {
+                    node: statement,
+                    sourceFile,
+                });
+            }
+        }
+    }
+    const context = {
+        declarations: declarationsMap,
+        cache: new Map(),
+    };
+    const declarations = [];
+    for (const [name, record] of declarationsMap.entries()) {
+        try {
+            const node = parseNamedDeclaration(name, record.sourceFile, context, new Set());
+            declarations.push({
+                name,
+                node,
+                location: getLocationFromNode(record.sourceFile, record.node),
+                sourceFilePath: path.resolve(record.sourceFile.fileName),
+            });
+        }
+        catch (error) {
+            errors.push(`Failed to parse type declaration ${name} in ${record.sourceFile.fileName}: ${String(error)}`);
+        }
+    }
+    return { declarations, errors };
+}

package/dist/core/type-utils.d.ts

@@ -0,0 +1,16 @@
+import type { ObjectProperty, PrimitiveTypeName, SourceLocation, TypeNode, UnionNode } from "./types.js";
+export declare function normalizePath(base: string, segment: string): string;
+export declare function locationFromTs(sourceFilePath: string, line: number, character: number): SourceLocation;
+export declare function makePrimitive(name: PrimitiveTypeName): TypeNode;
+export declare function unwrapOptional(node: TypeNode): {
+    node: TypeNode;
+    optional: boolean;
+};
+export declare function stringifyType(node: TypeNode): string;
+export declare function canonicalSignature(node: TypeNode): string;
+export declare function stripUndefinedFromUnion(node: UnionNode): {
+    optional: boolean;
+    node: TypeNode;
+};
+export declare function cloneProperty(property: ObjectProperty): ObjectProperty;
+export declare function cloneTypeNode(node: TypeNode): TypeNode;

package/dist/core/type-utils.js

@@ -0,0 +1,139 @@
+export function normalizePath(base, segment) {
+    return base ? `${base}.${segment}` : segment;
+}
+export function locationFromTs(sourceFilePath, line, character) {
+    return {
+        filePath: sourceFilePath,
+        line: line + 1,
+        column: character + 1,
+    };
+}
+export function makePrimitive(name) {
+    return { kind: "primitive", name };
+}
+export function unwrapOptional(node) {
+    if (node.kind === "optional") {
+        return { node: node.inner, optional: true };
+    }
+    return { node, optional: false };
+}
+export function stringifyType(node) {
+    switch (node.kind) {
+        case "primitive":
+            return node.name;
+        case "literal":
+            if (typeof node.value === "string") {
+                return `"${node.value}"`;
+            }
+            return String(node.value);
+        case "array":
+            return `${stringifyType(node.element)}[]`;
+        case "tuple":
+            return `[${node.items.map((item) => stringifyType(item)).join(", ")}]`;
+        case "union":
+            return node.members.map((member) => stringifyType(member)).join(" | ");
+        case "object":
+            return "object";
+        case "reference":
+            return node.name;
+        case "optional":
+            return `${stringifyType(node.inner)} | undefined`;
+        default:
+            return "unknown";
+    }
+}
+export function canonicalSignature(node) {
+    switch (node.kind) {
+        case "primitive":
+            return `p:${node.name}`;
+        case "literal":
+            return `l:${JSON.stringify(node.value)}`;
+        case "reference":
+            return `r:${node.name}`;
+        case "array":
+            return `a:${canonicalSignature(node.element)}`;
+        case "tuple":
+            return `t:[${node.items.map((item) => canonicalSignature(item)).join(",")}]`;
+        case "optional":
+            return `o:${canonicalSignature(node.inner)}`;
+        case "object": {
+            const sorted = Object.values(node.properties)
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((property) => `${property.name}${property.optional ? "?" : ""}:${canonicalSignature(property.type)}`)
+                .join(";");
+            return `obj:{${sorted}}`;
+        }
+        case "union": {
+            const members = node.members.map((member) => canonicalSignature(member)).sort();
+            return `u:${members.join("|")}`;
+        }
+        default:
+            return "unknown";
+    }
+}
+export function stripUndefinedFromUnion(node) {
+    const nonUndefined = node.members.filter((member) => !(member.kind === "primitive" && member.name === "undefined"));
+    if (nonUndefined.length === node.members.length) {
+        return { optional: false, node };
+    }
+    if (nonUndefined.length === 0) {
+        return { optional: true, node: makePrimitive("undefined") };
+    }
+    if (nonUndefined.length === 1) {
+        return { optional: true, node: nonUndefined[0] };
+    }
+    return {
+        optional: true,
+        node: {
+            kind: "union",
+            members: nonUndefined,
+            location: node.location,
+        },
+    };
+}
+export function cloneProperty(property) {
+    return {
+        ...property,
+        type: cloneTypeNode(property.type),
+    };
+}
+export function cloneTypeNode(node) {
+    switch (node.kind) {
+        case "primitive":
+        case "literal":
+        case "reference":
+            return { ...node };
+        case "optional":
+            return {
+                ...node,
+                inner: cloneTypeNode(node.inner),
+            };
+        case "array":
+            return {
+                ...node,
+                element: cloneTypeNode(node.element),
+            };
+        case "tuple":
+            return {
+                ...node,
+                items: node.items.map((item) => cloneTypeNode(item)),
+            };
+        case "union":
+            return {
+                ...node,
+                members: node.members.map((member) => cloneTypeNode(member)),
+            };
+        case "object": {
+            const properties = {};
+            for (const [name, property] of Object.entries(node.properties)) {
+                properties[name] = cloneProperty(property);
+            }
+            return {
+                ...node,
+                properties,
+            };
+        }
+        default:
+            return node;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,133 @@
+export type PrimitiveTypeName = "string" | "number" | "boolean" | "any" | "unknown" | "null" | "undefined";
+export type NodeKind = "primitive" | "literal" | "object" | "array" | "tuple" | "union" | "reference" | "optional";
+export interface SourceLocation {
+    filePath: string;
+    line: number;
+    column: number;
+}
+export interface PrimitiveNode {
+    kind: "primitive";
+    name: PrimitiveTypeName;
+    location?: SourceLocation;
+}
+export interface LiteralNode {
+    kind: "literal";
+    value: string | number | boolean | null;
+    location?: SourceLocation;
+}
+export interface ObjectProperty {
+    name: string;
+    type: TypeNode;
+    optional: boolean;
+    location?: SourceLocation;
+}
+export interface ObjectNode {
+    kind: "object";
+    properties: Record<string, ObjectProperty>;
+    location?: SourceLocation;
+}
+export interface ArrayNode {
+    kind: "array";
+    element: TypeNode;
+    location?: SourceLocation;
+}
+export interface TupleNode {
+    kind: "tuple";
+    items: TypeNode[];
+    location?: SourceLocation;
+}
+export interface UnionNode {
+    kind: "union";
+    members: TypeNode[];
+    location?: SourceLocation;
+}
+export interface ReferenceNode {
+    kind: "reference";
+    name: string;
+    location?: SourceLocation;
+}
+export interface OptionalNode {
+    kind: "optional";
+    inner: TypeNode;
+    location?: SourceLocation;
+}
+export type TypeNode = PrimitiveNode | LiteralNode | ObjectNode | ArrayNode | TupleNode | UnionNode | ReferenceNode | OptionalNode;
+export interface TypeDeclaration {
+    name: string;
+    node: TypeNode;
+    location: SourceLocation;
+    sourceFilePath: string;
+}
+export interface SchemaDeclaration {
+    name: string;
+    node: TypeNode;
+    location: SourceLocation;
+    sourceFilePath: string;
+    objectNodeText?: string;
+}
+export type DriftIssueKind = "missing_in_schema" | "extra_in_schema" | "optional_mismatch" | "type_mismatch";
+export interface DriftIssue {
+    kind: DriftIssueKind;
+    pairName: string;
+    path: string;
+    message: string;
+    typeValue?: string;
+    schemaValue?: string;
+    typeLocation?: SourceLocation;
+    schemaLocation?: SourceLocation;
+}
+export interface DriftPairResult {
+    typeName: string;
+    schemaName: string;
+    typeDecl: TypeDeclaration;
+    schemaDecl: SchemaDeclaration;
+    issues: DriftIssue[];
+}
+export interface CheckResult {
+    pairs: DriftPairResult[];
+    totalIssues: number;
+    checkedPairs: number;
+    unmatchedTypes: string[];
+    unmatchedSchemas: string[];
+    errors: string[];
+}
+export interface Pairing {
+    typeDecl: TypeDeclaration;
+    schemaDecl: SchemaDeclaration;
+}
+export interface ReporterPayload {
+    result: CheckResult;
+    cwd: string;
+}
+export type OutputFormat = "pretty" | "json" | "sarif";
+export interface CheckOptions {
+    cwd: string;
+    pattern: string;
+    format: OutputFormat;
+    maxIssues?: number;
+    changedOnly: boolean;
+}
+export interface FixOptions {
+    cwd: string;
+    pattern: string;
+    write: boolean;
+    dryRun: boolean;
+    target: "schema" | "type";
+}
+export interface CodegenOptions {
+    cwd: string;
+    pattern: string;
+    from: "ts" | "zod";
+    write: boolean;
+    outDir: string;
+}
+export interface OpenApiOptions {
+    cwd: string;
+    pattern: string;
+    outFile?: string;
+}
+export interface FormsOptions {
+    cwd: string;
+    pattern: string;
+    outFile?: string;
+}

package/dist/core/types.js

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

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

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