@onreza/sqlx-js 0.0.0

package/dist/src/scan/scanner.js

@@ -0,0 +1,283 @@
+import ts from "typescript";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+const EXCLUDE_DIRS = new Set(["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"]);
+const SQLX_MODULES = new Set(["@onreza/sqlx-js", "@onreza/sqlx-js/bun"]);
+const EXT = /\.(ts|tsx|mts|cts)$/;
+function walk(dir, out) {
+    for (const name of readdirSync(dir)) {
+        if (EXCLUDE_DIRS.has(name))
+            continue;
+        const full = join(dir, name);
+        const st = statSync(full);
+        if (st.isDirectory())
+            walk(full, out);
+        else if (EXT.test(name))
+            out.push(full);
+    }
+}
+export function findSourceFiles(root) {
+    const out = [];
+    walk(root, out);
+    return out;
+}
+function classifyCallee(callee, scope) {
+    if (ts.isIdentifier(callee)) {
+        if (!scope.sqlAliases.has(callee.text))
+            return null;
+        return { kind: "inline" };
+    }
+    if (!ts.isPropertyAccessExpression(callee))
+        return null;
+    if (!ts.isIdentifier(callee.name))
+        return null;
+    const methodName = callee.name.text;
+    if (ts.isIdentifier(callee.expression)) {
+        const id = callee.expression.text;
+        if (scope.namespaces.has(id)) {
+            if (methodName === "sql")
+                return { kind: "inline" };
+            return null;
+        }
+        if (!scope.sqlAliases.has(id))
+            return null;
+        if (methodName === "transaction")
+            return { kind: "transaction" };
+        if (methodName === "file")
+            return { kind: "file" };
+        if (methodName === "one" || methodName === "optional")
+            return { kind: "inline" };
+        return null;
+    }
+    if (ts.isPropertyAccessExpression(callee.expression)) {
+        const mid = callee.expression;
+        if (!ts.isIdentifier(mid.name))
+            return null;
+        // ns.sql.X(...) chains
+        if (ts.isIdentifier(mid.expression) && scope.namespaces.has(mid.expression.text)) {
+            if (mid.name.text !== "sql")
+                return null;
+            if (methodName === "one" || methodName === "optional")
+                return { kind: "inline" };
+            if (methodName === "file")
+                return { kind: "file" };
+            if (methodName === "transaction")
+                return { kind: "transaction" };
+            return null;
+        }
+        // sqlAlias.file.X(...) — file.one / file.optional
+        if (ts.isIdentifier(mid.expression)) {
+            const root = mid.expression.text;
+            if (!scope.sqlAliases.has(root))
+                return null;
+            if (mid.name.text !== "file")
+                return null;
+            if (methodName === "one" || methodName === "optional")
+                return { kind: "file" };
+            return null;
+        }
+        // ns.sql.file.X(...) chains
+        if (ts.isPropertyAccessExpression(mid.expression) &&
+            ts.isIdentifier(mid.expression.expression) &&
+            ts.isIdentifier(mid.expression.name) &&
+            scope.namespaces.has(mid.expression.expression.text) &&
+            mid.expression.name.text === "sql" &&
+            mid.name.text === "file" &&
+            (methodName === "one" || methodName === "optional")) {
+            return { kind: "file" };
+        }
+    }
+    return null;
+}
+export function scanFile(absPath, root) {
+    const text = readFileSync(absPath, "utf8");
+    const source = ts.createSourceFile(absPath, text, ts.ScriptTarget.ESNext, false, ts.ScriptKind.TSX);
+    const importedAliases = new Set();
+    const importedNamespaces = new Set();
+    for (const stmt of source.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        const mod = stmt.moduleSpecifier;
+        if (!ts.isStringLiteral(mod))
+            continue;
+        if (!SQLX_MODULES.has(mod.text))
+            continue;
+        const ic = stmt.importClause;
+        if (!ic)
+            continue;
+        const nb = ic.namedBindings;
+        if (!nb)
+            continue;
+        if (ts.isNamespaceImport(nb)) {
+            importedNamespaces.add(nb.name.text);
+        }
+        else if (ts.isNamedImports(nb)) {
+            for (const elem of nb.elements) {
+                const orig = (elem.propertyName ?? elem.name).text;
+                if (orig === "sql")
+                    importedAliases.add(elem.name.text);
+            }
+        }
+    }
+    if (importedAliases.size === 0 && importedNamespaces.size === 0)
+        return [];
+    const out = [];
+    const here = (node) => {
+        const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+        return { line: line + 1, column: character + 1 };
+    };
+    const fileRel = relative(root, absPath);
+    const recordInline = (first, args) => {
+        if (!ts.isStringLiteralLike(first)) {
+            const pos = here(first);
+            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql() requires a string literal as first argument`);
+        }
+        const pos = here(first);
+        out.push({
+            file: fileRel,
+            line: pos.line,
+            column: pos.column,
+            query: first.text,
+            paramCount: args.length - 1,
+            kind: "inline",
+        });
+        return true;
+    };
+    const recordFile = (first, args, callee) => {
+        if (!ts.isStringLiteralLike(first)) {
+            const pos = first ? here(first) : here(callee);
+            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql.file() requires a string literal path`);
+        }
+        const sqlPath = first.text;
+        const abs = resolve(dirname(absPath), sqlPath);
+        if (!existsSync(abs)) {
+            const pos = here(first);
+            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql.file path not found: ${sqlPath}`);
+        }
+        const query = readFileSync(abs, "utf8");
+        const pos = here(first);
+        out.push({
+            file: fileRel,
+            line: pos.line,
+            column: pos.column,
+            query,
+            paramCount: args.length - 1,
+            kind: "file",
+            sqlFilePath: relative(root, abs),
+        });
+        return true;
+    };
+    const bindingDeclares = (binding, name) => {
+        if (ts.isIdentifier(binding))
+            return binding.text === name;
+        for (const el of binding.elements) {
+            if (ts.isOmittedExpression(el))
+                continue;
+            if (bindingDeclares(el.name, name))
+                return true;
+        }
+        return false;
+    };
+    const scopeWithoutBindingShadows = (scope, bindings) => {
+        let changed = false;
+        const nextSql = new Set(scope.sqlAliases);
+        const nextNs = new Set(scope.namespaces);
+        for (const binding of bindings) {
+            for (const a of scope.sqlAliases) {
+                if (bindingDeclares(binding, a)) {
+                    nextSql.delete(a);
+                    changed = true;
+                }
+            }
+            for (const a of scope.namespaces) {
+                if (bindingDeclares(binding, a)) {
+                    nextNs.delete(a);
+                    changed = true;
+                }
+            }
+        }
+        return changed ? { sqlAliases: nextSql, namespaces: nextNs } : scope;
+    };
+    const visit = (node, scope) => {
+        if (ts.isCallExpression(node)) {
+            const classified = classifyCallee(node.expression, scope);
+            if (classified) {
+                if (classified.kind === "transaction") {
+                    const fn = node.arguments[node.arguments.length - 1];
+                    if (fn && (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) {
+                        const param = fn.parameters[0];
+                        const shadowed = param ? scopeWithoutBindingShadows(scope, [param.name]) : scope;
+                        const innerSql = new Set(shadowed.sqlAliases);
+                        if (param && ts.isIdentifier(param.name)) {
+                            innerSql.add(param.name.text);
+                        }
+                        visit(fn.body, { sqlAliases: innerSql, namespaces: shadowed.namespaces });
+                        return;
+                    }
+                }
+                else if (classified.kind === "file") {
+                    const first = node.arguments[0];
+                    if (first)
+                        recordFile(first, node.arguments, node.expression);
+                }
+                else if (classified.kind === "inline") {
+                    const first = node.arguments[0];
+                    if (first)
+                        recordInline(first, node.arguments);
+                }
+            }
+        }
+        if (ts.isBlock(node) || ts.isSourceFile(node) || ts.isModuleBlock(node)) {
+            let current = scope;
+            const stmts = node.statements;
+            for (const stmt of stmts) {
+                if (ts.isVariableStatement(stmt)) {
+                    current = scopeWithoutBindingShadows(current, stmt.declarationList.declarations.map((d) => d.name));
+                }
+                else if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+                    current = scopeWithoutBindingShadows(current, [stmt.name]);
+                }
+                visit(stmt, current);
+            }
+            return;
+        }
+        if (ts.isCatchClause(node) && node.variableDeclaration?.name) {
+            const next = scopeWithoutBindingShadows(scope, [node.variableDeclaration.name]);
+            if (next !== scope) {
+                visit(node.block, next);
+                return;
+            }
+        }
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isConstructorDeclaration(node) ||
+            ts.isGetAccessorDeclaration(node) ||
+            ts.isSetAccessorDeclaration(node)) &&
+            node.body) {
+            const bindings = node.parameters.map((p) => p.name);
+            if (ts.isFunctionExpression(node) && node.name)
+                bindings.push(node.name);
+            const next = scopeWithoutBindingShadows(scope, bindings);
+            for (const param of node.parameters) {
+                if (param.initializer)
+                    visit(param.initializer, next);
+            }
+            visit(node.body, next);
+            return;
+        }
+        ts.forEachChild(node, (child) => visit(child, scope));
+    };
+    visit(source, { sqlAliases: importedAliases, namespaces: importedNamespaces });
+    return out;
+}
+export function scanProject(root) {
+    const files = findSourceFiles(root);
+    const out = [];
+    for (const f of files) {
+        for (const site of scanFile(f, root))
+            out.push(site);
+    }
+    return out;
+}

package/dist/src/schema-snapshot.d.ts

@@ -0,0 +1,104 @@
+import { PgClient } from "./pg/wire.js";
+export type SchemaRelationKind = "table" | "partitioned_table" | "view" | "materialized_view" | "foreign_table";
+export type SchemaConstraintKind = "primary_key" | "foreign_key" | "unique" | "check" | "exclude";
+export type SchemaFunctionKind = "function" | "procedure" | "aggregate" | "window";
+export type SchemaColumnSnapshot = {
+    name: string;
+    ordinal: number;
+    type: string;
+    typeOid: number;
+    nullable: boolean;
+    writable: boolean;
+    default?: string;
+    identity?: "always" | "by_default";
+    generated?: "stored";
+    generatedExpression?: string;
+};
+export type SchemaConstraintSnapshot = {
+    name: string;
+    kind: SchemaConstraintKind;
+    columns: string[];
+    definition: string;
+    expression?: string;
+    references?: {
+        schema: string;
+        table: string;
+        columns: string[];
+        onUpdate: string;
+        onDelete: string;
+    };
+    deferrable?: boolean;
+    initiallyDeferred?: boolean;
+};
+export type SchemaIndexSnapshot = {
+    name: string;
+    unique: boolean;
+    primary: boolean;
+    method: string;
+    columns: string[];
+    definition: string;
+    predicate?: string;
+};
+export type SchemaRelationSnapshot = {
+    schema: string;
+    name: string;
+    kind: SchemaRelationKind;
+    columns: SchemaColumnSnapshot[];
+    constraints: SchemaConstraintSnapshot[];
+    indexes: SchemaIndexSnapshot[];
+    definition?: string;
+};
+export type SchemaEnumSnapshot = {
+    kind: "enum";
+    schema: string;
+    name: string;
+    values: string[];
+};
+export type SchemaDomainSnapshot = {
+    kind: "domain";
+    schema: string;
+    name: string;
+    baseType: string;
+    notNull: boolean;
+    default?: string;
+    checks: string[];
+};
+export type SchemaCompositeSnapshot = {
+    kind: "composite";
+    schema: string;
+    name: string;
+    fields: {
+        name: string;
+        type: string;
+    }[];
+};
+export type SchemaTypeSnapshot = SchemaEnumSnapshot | SchemaDomainSnapshot | SchemaCompositeSnapshot;
+export type SchemaFunctionSnapshot = {
+    schema: string;
+    name: string;
+    kind: SchemaFunctionKind;
+    identityArguments: string;
+    arguments: string;
+    returnType: string;
+    returnsSet: boolean;
+    volatility: "immutable" | "stable" | "volatile";
+    strict: boolean;
+    securityDefiner: boolean;
+    language: string;
+};
+export type SchemaSnapshot = {
+    version: 1;
+    schemas: string[];
+    relations: SchemaRelationSnapshot[];
+    types: SchemaTypeSnapshot[];
+    functions: SchemaFunctionSnapshot[];
+};
+export declare function introspectDatabase(databaseUrl: string): Promise<SchemaSnapshot>;
+export declare function introspectConnected(client: PgClient): Promise<SchemaSnapshot>;
+export declare function stableSchemaJson(snapshot: SchemaSnapshot): string;
+export declare function writeSchemaSnapshot(path: string, snapshot: SchemaSnapshot): void;
+export declare function readSchemaSnapshot(path: string): SchemaSnapshot;
+export declare function schemaSnapshotEqual(a: SchemaSnapshot, b: SchemaSnapshot): boolean;
+export declare function renderSchemaManifest(snapshot: SchemaSnapshot): string;
+export declare function writeSchemaManifest(path: string, snapshot: SchemaSnapshot): void;
+export declare function schemaSnapshotExists(path: string): boolean;