@onreza/sqlx-js 0.6.0 → 0.8.0

package/dist/src/cache.js

@@ -2,8 +2,10 @@ import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { isBuiltinOid } from "./pg/oids.js";
-export const CACHE_FORMAT_VERSION = 2;
-export const GENERATOR_REVISION = 3;
+import { isEscapeStringPrefix, isIdentifierContinuation, readBlockComment, readDollarQuoted, readLineComment, readQuotedIdentifier, readSingleQuoted, } from "./sql-lex.js";
+import { rewriteNamedParameters } from "./sql-params.js";
+export const CACHE_FORMAT_VERSION = 3;
+export const GENERATOR_REVISION = 5;
 export const CACHE_MANIFEST_FILE = "cache-manifest.json";
 export function portableCacheOid(oid) {
     return isBuiltinOid(oid) ? oid : 0;
@@ -56,7 +58,7 @@ function normalizeForFingerprint(query) {
             continue;
         }
         if (ch === "$") {
-            const next = readDollarQuoted(query, i);
+            const next = i === 0 || !isIdentifierContinuation(query[i - 1]) ? readDollarQuoted(query, i) : null;
             if (next !== null) {
                 emit(query.slice(i, next));
                 i = next;
@@ -68,77 +70,6 @@ function normalizeForFingerprint(query) {
     }
     return out;
 }
-function readSingleQuoted(query, start, escapeBackslash) {
-    let i = start + 1;
-    while (i < query.length) {
-        const ch = query[i];
-        if (escapeBackslash && ch === "\\") {
-            i += 2;
-            continue;
-        }
-        if (ch === "'") {
-            if (query[i + 1] === "'") {
-                i += 2;
-                continue;
-            }
-            return i + 1;
-        }
-        i++;
-    }
-    return query.length;
-}
-function readQuotedIdentifier(query, start) {
-    let i = start + 1;
-    while (i < query.length) {
-        if (query[i] === "\"") {
-            if (query[i + 1] === "\"") {
-                i += 2;
-                continue;
-            }
-            return i + 1;
-        }
-        i++;
-    }
-    return query.length;
-}
-function readDollarQuoted(query, start) {
-    let tagEnd = start + 1;
-    while (tagEnd < query.length && /[A-Za-z0-9_]/.test(query[tagEnd]))
-        tagEnd++;
-    if (query[tagEnd] !== "$")
-        return null;
-    const tag = query.slice(start, tagEnd + 1);
-    const end = query.indexOf(tag, tagEnd + 1);
-    return end === -1 ? query.length : end + tag.length;
-}
-function readLineComment(query, start) {
-    const end = query.indexOf("\n", start + 2);
-    return end === -1 ? query.length : end + 1;
-}
-function readBlockComment(query, start) {
-    let depth = 1;
-    let i = start + 2;
-    while (i < query.length && depth > 0) {
-        if (query[i] === "/" && query[i + 1] === "*") {
-            depth++;
-            i += 2;
-            continue;
-        }
-        if (query[i] === "*" && query[i + 1] === "/") {
-            depth--;
-            i += 2;
-            continue;
-        }
-        i++;
-    }
-    return i;
-}
-function isEscapeStringPrefix(query, quoteIndex) {
-    if (quoteIndex === 0 || query[quoteIndex - 1]?.toLowerCase() !== "e")
-        return false;
-    const beforePrefix = query[quoteIndex - 2];
-    return beforePrefix === undefined || !/[A-Za-z0-9_$]/.test(beforePrefix);
-}
 export function effectiveNullable(c) {
     if (c.override === "non-null")
         return false;
@@ -166,6 +97,27 @@ function assertEntryShape(fp, raw) {
         throw new Error(`sqlx-js: cache entry ${fp}.json is malformed`);
     }
     const cols = raw.columns;
+    const entry = raw;
+    let expectedNames;
+    try {
+        if (typeof entry.query !== "string")
+            throw new Error("query must be a string");
+        expectedNames = rewriteNamedParameters(entry.query).names;
+    }
+    catch {
+        throw new Error(`sqlx-js: cache entry ${fp}.json has malformed named parameter metadata. Run \`sqlx-js prepare\`.`);
+    }
+    if (entry.paramNames !== undefined || expectedNames.length > 0) {
+        if (!Array.isArray(entry.paramNames) ||
+            !entry.paramNames.every((name) => typeof name === "string") ||
+            !Array.isArray(entry.paramTsTypes) ||
+            entry.paramNames.length !== entry.paramTsTypes.length ||
+            new Set(entry.paramNames).size !== entry.paramNames.length ||
+            entry.paramNames.length !== expectedNames.length ||
+            entry.paramNames.some((name, index) => name !== expectedNames[index])) {
+            throw new Error(`sqlx-js: cache entry ${fp}.json has malformed named parameter metadata. Run \`sqlx-js prepare\`.`);
+        }
+    }
     if (cols.length > 0) {
         const c = cols[0];
         if ("forceNonNull" in c || "forceNullable" in c) {

package/dist/src/codegen.js

@@ -7,7 +7,9 @@ function entrySignature(e) {
         const nullable = e.paramNullable?.[i] === true;
         return nullable ? `${t} | null` : t;
     });
-    const params = paramTypes.length === 0 ? "[]" : `[${paramTypes.join(", ")}]`;
+    const params = e.paramNames && e.paramNames.length > 0
+        ? `{ ${e.paramNames.map((name, index) => `${JSON.stringify(name)}: ${paramTypes[index]}`).join("; ")} }`
+        : paramTypes.length === 0 ? "[]" : `[${paramTypes.join(", ")}]`;
     if (!e.hasResultSet)
         return { params, row: "never" };
     const cols = e.columns.map((c) => {
@@ -23,7 +25,9 @@ export function emitDts(outPath, entries, functions = []) {
     lines.push("// AUTO-GENERATED by sqlx-js. Do not edit.");
     lines.push("// Run `sqlx-js prepare` to regenerate.");
     lines.push("");
-    emitModule(lines, "@onreza/sqlx-js", entries, functions);
+    emitRegistry(lines, entries, functions);
+    lines.push("");
+    emitModuleAugmentation(lines, "@onreza/sqlx-js");
     lines.push("");
     lines.push("export {};");
     const tmp = `${outPath}.tmp-${randomBytes(4).toString("hex")}`;
@@ -39,9 +43,8 @@ export function emitDts(outPath, entries, functions = []) {
         throw err;
     }
 }
-function emitModule(lines, moduleName, entries, functions) {
-    lines.push(`declare module ${JSON.stringify(moduleName)} {`);
-    lines.push("  interface KnownQueries {");
+function emitRegistry(lines, entries, functions) {
+    lines.push("export interface SqlxJsGeneratedQueries {");
     const inlineSeen = new Set();
     const inlinePairs = [];
     for (const e of entries) {
@@ -58,12 +61,12 @@ function emitModule(lines, moduleName, entries, functions) {
         inlineSeen.add(query);
         const { params, row } = entrySignature(entry);
         if (entry.degraded)
-            lines.push(`    /** Nullability inference degraded: ${entry.degraded.reason}. All result columns conservatively typed as nullable. */`);
-        lines.push(`    ${JSON.stringify(query)}: { params: ${params}; row: ${row} };`);
+            lines.push(`  /** Nullability inference degraded: ${entry.degraded.reason}. All result columns conservatively typed as nullable. */`);
+        lines.push(`  ${JSON.stringify(query)}: { params: ${params}; row: ${row} };`);
     }
-    lines.push("  }");
+    lines.push("}");
     lines.push("");
-    lines.push("  interface KnownFileQueries {");
+    lines.push("export interface SqlxJsGeneratedFileQueries {");
     const filePairs = [];
     for (const e of entries) {
         if (!e.filePaths || e.filePaths.length === 0)
@@ -78,21 +81,33 @@ function emitModule(lines, moduleName, entries, functions) {
         filePathsSeen.add(path);
         const { params, row } = entrySignature(entry);
         if (entry.degraded)
-            lines.push(`    /** Nullability inference degraded: ${entry.degraded.reason}. */`);
-        lines.push(`    ${JSON.stringify(path)}: { params: ${params}; row: ${row} };`);
+            lines.push(`  /** Nullability inference degraded: ${entry.degraded.reason}. */`);
+        lines.push(`  ${JSON.stringify(path)}: { params: ${params}; row: ${row} };`);
     }
-    lines.push("  }");
+    lines.push("}");
     lines.push("");
-    lines.push("  interface KnownFunctions {");
+    lines.push("export interface SqlxJsGeneratedFunctions {");
     const functionSeen = new Set();
     for (const fn of functions.slice().sort((a, b) => a.signature.localeCompare(b.signature))) {
         if (functionSeen.has(fn.signature))
             continue;
         functionSeen.add(fn.signature);
         const params = inputParams(fn);
-        lines.push(`    ${JSON.stringify(fn.signature)}: { kind: ${JSON.stringify(fn.kind)}; params: ${params}; returns: ${fn.returns}; returnsSet: ${fn.returnsSet} };`);
+        lines.push(`  ${JSON.stringify(fn.signature)}: { kind: ${JSON.stringify(fn.kind)}; params: ${params}; returns: ${fn.returns}; returnsSet: ${fn.returnsSet} };`);
     }
-    lines.push("  }");
+    lines.push("}");
+    lines.push("");
+    lines.push("export interface SqlxJsGeneratedRegistry {");
+    lines.push("  queries: SqlxJsGeneratedQueries;");
+    lines.push("  fileQueries: SqlxJsGeneratedFileQueries;");
+    lines.push("  functions: SqlxJsGeneratedFunctions;");
+    lines.push("}");
+}
+function emitModuleAugmentation(lines, moduleName) {
+    lines.push(`declare module ${JSON.stringify(moduleName)} {`);
+    lines.push("  interface KnownQueries extends SqlxJsGeneratedQueries {}");
+    lines.push("  interface KnownFileQueries extends SqlxJsGeneratedFileQueries {}");
+    lines.push("  interface KnownFunctions extends SqlxJsGeneratedFunctions {}");
     lines.push("}");
 }
 function inputParams(fn) {

package/dist/src/commands/ci.d.ts

@@ -0,0 +1,28 @@
+import type { SqlxJsConfig } from "../config.js";
+export type CiStep = {
+    name: string;
+    args: string[];
+    check?: "pgschema-plan";
+};
+export type CiStepResult = {
+    name: string;
+    ok: boolean;
+    durationMs: number;
+    exitCode: number;
+    stderr?: string;
+};
+export type CiOptions = {
+    executable: string;
+    cliPath: string;
+    root: string;
+    config: SqlxJsConfig;
+    schemaPath: string;
+    json?: boolean;
+    shadowUrl?: string;
+    shadowAdminUrl?: string;
+    migrationsDir?: string;
+    dtsPath?: string;
+};
+export declare function buildCiSteps(opts: Pick<CiOptions, "config" | "root" | "schemaPath" | "shadowUrl" | "shadowAdminUrl" | "migrationsDir" | "dtsPath">): CiStep[];
+export declare function assertPgschemaPlanClean(path: string): void;
+export declare function runCi(opts: CiOptions): void;

package/dist/src/commands/ci.js

@@ -0,0 +1,103 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const PLAN_PATH = "{sqlx-js-ci-plan}";
+export function buildCiSteps(opts) {
+    const root = ["--root", opts.root];
+    const shadow = opts.shadowUrl ? ["--shadow-url", opts.shadowUrl] : [];
+    const shadowAdmin = opts.shadowAdminUrl ? ["--shadow-admin-url", opts.shadowAdminUrl] : [];
+    const migrations = opts.migrationsDir ? ["--migrations", opts.migrationsDir] : [];
+    const dts = opts.dtsPath ? ["--dts", opts.dtsPath] : [];
+    const steps = opts.config.schema?.provider === "pgschema"
+        ? [
+            { name: "pgschema", args: ["db", "check", ...root] },
+            {
+                name: "pgschema-plan",
+                args: ["db", "plan", ...root, "--", "--output-json", PLAN_PATH, "--no-color"],
+                check: "pgschema-plan",
+            },
+            { name: "prepare-live", args: ["prepare", "--verify", "--strict-inference", ...shadow, ...dts, ...root] },
+        ]
+        : [{
+                name: "migrations",
+                args: ["migrate", "verify", "--strict-inference", ...shadow, ...shadowAdmin, ...migrations, ...dts, ...root],
+            }];
+    steps.push({ name: "prepare-offline", args: ["prepare", "--check", "--strict-inference", ...dts, ...root] });
+    if (existsSync(opts.schemaPath)) {
+        steps.push({ name: "schema", args: ["schema", "check", ...shadow, "--schema", opts.schemaPath, ...migrations, ...root] });
+    }
+    return steps;
+}
+export function assertPgschemaPlanClean(path) {
+    const plan = JSON.parse(readFileSync(path, "utf8"));
+    if (plan.groups === null)
+        return;
+    if (!Array.isArray(plan.groups))
+        throw new Error("plan JSON does not contain groups as an array or null");
+    if (plan.groups.length > 0)
+        throw new Error(`pgschema plan contains ${plan.groups.length} unapplied change group(s)`);
+}
+export function runCi(opts) {
+    const results = [];
+    const temp = mkdtempSync(join(tmpdir(), "sqlx-js-ci-"));
+    try {
+        for (const step of buildCiSteps(opts)) {
+            if (!opts.json)
+                console.log(`ci: ${step.name}`);
+            const started = performance.now();
+            const planPath = join(temp, "pgschema-plan.json");
+            const args = step.args.map((arg) => arg === PLAN_PATH ? planPath : arg);
+            const result = spawnSync(opts.executable, [opts.cliPath, ...args], {
+                encoding: "utf8",
+                env: process.env,
+                stdio: opts.json ? ["ignore", "ignore", "pipe"] : "inherit",
+                maxBuffer: 4 * 1024 * 1024,
+            });
+            let exitCode = result.status ?? 1;
+            let checkError;
+            if (exitCode === 0 && step.check === "pgschema-plan") {
+                try {
+                    assertPgschemaPlanClean(planPath);
+                }
+                catch (error) {
+                    checkError = error.message.startsWith("pgschema plan contains")
+                        ? error.message
+                        : `cannot verify pgschema plan: ${error.message}`;
+                    exitCode = 1;
+                }
+            }
+            if (result.error) {
+                checkError = result.error.message;
+                exitCode = 1;
+            }
+            else if (result.signal) {
+                checkError = `terminated by signal ${result.signal}`;
+                exitCode = 1;
+            }
+            if (checkError && !opts.json)
+                console.error(`ci: ${step.name}: ${checkError}`);
+            results.push({
+                name: step.name,
+                ok: exitCode === 0,
+                durationMs: Math.round(performance.now() - started),
+                exitCode,
+                ...(opts.json && exitCode !== 0 && (checkError || result.stderr)
+                    ? { stderr: [result.stderr?.trim(), checkError].filter(Boolean).join("\n") }
+                    : {}),
+            });
+            if (exitCode !== 0)
+                break;
+        }
+    }
+    finally {
+        rmSync(temp, { recursive: true, force: true });
+    }
+    const ok = results.length > 0 && results.every((result) => result.ok);
+    if (opts.json)
+        console.log(JSON.stringify({ formatVersion: 1, ok, results }, null, 2));
+    else if (ok)
+        console.log(`ci: ok — ${results.length} check(s) passed`);
+    if (!ok)
+        process.exitCode = 1;
+}

package/dist/src/commands/init.js

@@ -36,10 +36,19 @@ const PGSCHEMA_TEMPLATE = `-- Desired PostgreSQL schema managed by pgschema.
 const DTS_TEMPLATE = `// AUTO-GENERATED by sqlx-js. Do not edit.
 // Run \`sqlx-js prepare\` to regenerate.
 
+export interface SqlxJsGeneratedQueries {}
+export interface SqlxJsGeneratedFileQueries {}
+export interface SqlxJsGeneratedFunctions {}
+export interface SqlxJsGeneratedRegistry {
+  queries: SqlxJsGeneratedQueries;
+  fileQueries: SqlxJsGeneratedFileQueries;
+  functions: SqlxJsGeneratedFunctions;
+}
+
 declare module "@onreza/sqlx-js" {
-  interface KnownQueries {}
-  interface KnownFileQueries {}
-  interface KnownFunctions {}
+  interface KnownQueries extends SqlxJsGeneratedQueries {}
+  interface KnownFileQueries extends SqlxJsGeneratedFileQueries {}
+  interface KnownFunctions extends SqlxJsGeneratedFunctions {}
 }
 
 export {};
@@ -132,7 +141,9 @@ export function runInit(opts) {
         const defaults = {
             "sqlx:prepare": "sqlx-js prepare",
             "sqlx:check": "sqlx-js prepare --check",
+            "sqlx:offline": "sqlx-js prepare --offline",
             "sqlx:verify": "sqlx-js prepare --verify --strict-inference",
+            "sqlx:ci": "sqlx-js ci",
         };
         let changed = false;
         for (const [name, command] of Object.entries(defaults)) {

package/dist/src/commands/prepare.d.ts

@@ -1,5 +1,6 @@
 import { PgClient, type ConnConfig, type FieldDescription } from "../pg/wire.js";
 import { SchemaCache } from "../pg/schema.js";
+import { type QueryCallSite } from "../scan/scanner.js";
 import { type SqlxJsConfig } from "../config.js";
 export type PrepareOptions = {
     root: string;
@@ -7,6 +8,7 @@ export type PrepareOptions = {
     cacheDir: string;
     dtsPath: string;
     check: boolean;
+    offline?: boolean;
     verify?: boolean;
     json?: boolean;
     prune?: boolean;
@@ -49,6 +51,11 @@ export type PrepareSession = {
     schema: SchemaCache;
     userCfg: SqlxJsConfig;
 };
+export type PrepareIncrementalInput = {
+    sites?: QueryCallSite[];
+    reuseCacheFps?: ReadonlySet<string>;
+    reuseFunctions?: boolean;
+};
 export declare function openSession(opts: PrepareOptions): Promise<PrepareSession>;
 type DescribeOutcome = {
     ok: true;
@@ -63,7 +70,7 @@ export declare function describeAll(cfg: ConnConfig, sessionClient: PgClient, qu
     fp: string;
     query: string;
 }[], concurrency: number): Promise<Map<string, DescribeOutcome>>;
-export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void, concurrency?: number): Promise<PrepareResult>;
+export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void, concurrency?: number, input?: PrepareIncrementalInput): Promise<PrepareResult>;
 export declare function runPrepare(opts: PrepareOptions): Promise<void>;
 export declare function verifyPrepareArtifacts(opts: PrepareOptions, log?: (msg: string) => void, err?: (msg: string) => void): Promise<{
     ok: boolean;