@onreza/sqlx-js 0.1.0 → 0.3.0

package/dist/src/cache.js

@@ -2,9 +2,136 @@ import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "node:fs";
 import { join } from "node:path";
 export function fingerprint(query) {
-    const norm = query.replace(/\s+/g, " ").trim();
+    const norm = normalizeForFingerprint(query);
     return createHash("sha256").update(norm).digest("hex").slice(0, 16);
 }
+function normalizeForFingerprint(query) {
+    let out = "";
+    let pendingSpace = false;
+    let i = 0;
+    const emit = (text) => {
+        if (pendingSpace && out.length > 0)
+            out += " ";
+        out += text;
+        pendingSpace = false;
+    };
+    const markSpace = () => {
+        if (out.length > 0)
+            pendingSpace = true;
+    };
+    while (i < query.length) {
+        const ch = query[i];
+        if (/\s/.test(ch)) {
+            markSpace();
+            i++;
+            continue;
+        }
+        if (ch === "-" && query[i + 1] === "-") {
+            i = readLineComment(query, i);
+            markSpace();
+            continue;
+        }
+        if (ch === "/" && query[i + 1] === "*") {
+            i = readBlockComment(query, i);
+            markSpace();
+            continue;
+        }
+        if (ch === "'") {
+            const next = readSingleQuoted(query, i, isEscapeStringPrefix(query, i));
+            emit(query.slice(i, next));
+            i = next;
+            continue;
+        }
+        if (ch === "\"") {
+            const next = readQuotedIdentifier(query, i);
+            emit(query.slice(i, next));
+            i = next;
+            continue;
+        }
+        if (ch === "$") {
+            const next = readDollarQuoted(query, i);
+            if (next !== null) {
+                emit(query.slice(i, next));
+                i = next;
+                continue;
+            }
+        }
+        emit(ch);
+        i++;
+    }
+    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;

package/dist/src/codegen.js

@@ -24,8 +24,6 @@ export function emitDts(outPath, entries) {
     lines.push("");
     emitModule(lines, "@onreza/sqlx-js", entries);
     lines.push("");
-    emitModule(lines, "@onreza/sqlx-js/bun", entries);
-    lines.push("");
     lines.push("export {};");
     writeFileSync(outPath, lines.join("\n") + "\n");
 }
@@ -33,21 +31,23 @@ function emitModule(lines, moduleName, entries) {
     lines.push(`declare module ${JSON.stringify(moduleName)} {`);
     lines.push("  interface KnownQueries {");
     const inlineSeen = new Set();
-    const inlineEntries = entries.filter((e) => {
-        if (e.hasInline === true)
-            return true;
-        if (e.hasInline === false)
-            return false;
-        return !e.filePaths || e.filePaths.length === 0;
-    });
-    for (const e of inlineEntries.slice().sort((a, b) => a.query.localeCompare(b.query))) {
-        if (inlineSeen.has(e.query))
+    const inlinePairs = [];
+    for (const e of entries) {
+        const emitInline = e.hasInline === true || (e.hasInline !== false && (!e.filePaths || e.filePaths.length === 0));
+        if (!emitInline)
             continue;
-        inlineSeen.add(e.query);
-        const { params, row } = entrySignature(e);
-        if (e.degraded)
-            lines.push(`    /** Nullability inference degraded: ${e.degraded.reason}. All result columns conservatively typed as nullable. */`);
-        lines.push(`    ${JSON.stringify(e.query)}: { params: ${params}; row: ${row} };`);
+        const queries = e.inlineQueries && e.inlineQueries.length > 0 ? e.inlineQueries : [e.query];
+        for (const query of queries)
+            inlinePairs.push({ query, entry: e });
+    }
+    for (const { query, entry } of inlinePairs.slice().sort((a, b) => a.query.localeCompare(b.query))) {
+        if (inlineSeen.has(query))
+            continue;
+        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("  }");
     lines.push("");

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

@@ -0,0 +1,5 @@
+export type InitOptions = {
+    root: string;
+    log?: (msg: string) => void;
+};
+export declare function runInit(opts: InitOptions): void;

package/dist/src/commands/init.js

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const CONFIG_TEMPLATE = `import type { SqlxJsConfig } from "@onreza/sqlx-js";
+
+const config: SqlxJsConfig = {
+  // Map jsonb columns/params to TypeScript types declared in a .d.ts, e.g.
+  //   "users.settings": "SqlxJsJson.UserSettings",
+  jsonbTypes: {},
+  // Map PostgreSQL type names to TypeScript types, e.g.
+  //   geometry: "GeoJSON.Geometry",
+  customTypes: {},
+};
+
+export default config;
+`;
+const ENV_TEMPLATE = `# Connection string used by sqlx-js prepare/migrate and the runtime.
+DATABASE_URL=postgres://user:password@localhost:5432/your_db
+# Managed Postgres with TLS:
+# DATABASE_URL=postgres://user:password@db.example.com:5432/your_db?sslmode=verify-full
+`;
+export function runInit(opts) {
+    const log = opts.log ?? console.log;
+    const created = [];
+    const skipped = [];
+    const ensureFile = (rel, content) => {
+        const full = join(opts.root, rel);
+        if (existsSync(full)) {
+            skipped.push(rel);
+            return;
+        }
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, content);
+        created.push(rel);
+    };
+    const ensureDir = (rel) => {
+        const full = join(opts.root, rel);
+        if (existsSync(full)) {
+            skipped.push(`${rel}/`);
+            return;
+        }
+        mkdirSync(full, { recursive: true });
+        created.push(`${rel}/`);
+    };
+    ensureFile("sqlx-js.config.ts", CONFIG_TEMPLATE);
+    ensureDir("migrations");
+    ensureFile(".env.example", ENV_TEMPLATE);
+    for (const f of created)
+        log(`created ${f}`);
+    for (const f of skipped)
+        log(`exists  ${f} (left unchanged)`);
+    log("");
+    log("Next steps:");
+    log("  1. Set DATABASE_URL (see .env.example).");
+    log("  2. Add a migration:  sqlx-js migrate add init");
+    log("  3. Make sure tsconfig.json \"include\" covers sqlx-js-env.d.ts.");
+    log("  4. Develop locally:  sqlx-js migrate dev");
+}

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

@@ -3,9 +3,22 @@ export type MigrateOptions = {
     databaseUrl: string;
     migrationsDir: string;
 };
+export type MigrationWorkflowOptions = MigrateOptions & {
+    root: string;
+    cacheDir: string;
+    dtsPath: string;
+    prune?: boolean;
+    shadowUrl?: string;
+    shadowAdminUrl?: string;
+    lockKey?: number | bigint;
+    lockTimeoutMs?: number;
+};
+export type MigrationStore = {
+    table: string;
+};
 export declare const DEFAULT_MIGRATE_LOCK_KEY = 18750938867203960n;
-export declare function ensureTable(c: PgClient): Promise<void>;
-export declare function listApplied(c: PgClient): Promise<Map<number, {
+export declare function ensureTable(c: PgClient): Promise<MigrationStore>;
+export declare function listApplied(c: PgClient, store?: MigrationStore): Promise<Map<number, {
     name: string;
     hash: string;
 }>>;
@@ -13,6 +26,11 @@ export type ApplyOutcome = {
     kind: "applied";
     version: number;
     name: string;
+} | {
+    kind: "adopted";
+    version: number;
+    name: string;
+    replaced: number;
 } | {
     kind: "tampered";
     version: number;
@@ -25,6 +43,123 @@ export type ApplyOutcome = {
     name: string;
     error: string;
 };
+export type PlanOutcome = {
+    kind: "pending";
+    version: number;
+    name: string;
+} | {
+    kind: "adoptable";
+    version: number;
+    name: string;
+    replaced: number;
+} | {
+    kind: "tampered";
+    version: number;
+    name: string;
+    applied: string;
+    current: string;
+} | {
+    kind: "failed";
+    version: number;
+    name: string;
+    error: string;
+};
+export type MigrationPlanItem = {
+    kind: "apply";
+    version: number;
+    name: string;
+} | {
+    kind: "adopt";
+    version: number;
+    name: string;
+    replaced: number;
+};
+export type MigrationPlanDiagnostic = Extract<PlanOutcome, {
+    kind: "tampered" | "failed";
+}>;
+export type MigrationPlanSnapshot = {
+    ok: boolean;
+    pending: number;
+    adoptable: number;
+    tampered: number;
+    failed: number;
+    steps: MigrationPlanItem[];
+    diagnostics: MigrationPlanDiagnostic[];
+};
+export type MigrationInfoStatus = "applied" | "pending" | "adoptable" | "superseded" | "tampered" | "failed";
+export type MigrationInfoItem = {
+    version: number;
+    name: string;
+    status: MigrationInfoStatus;
+    detail?: string;
+};
+export type MigrationInfoSnapshot = {
+    historyTable: string | null;
+    summary: Record<MigrationInfoStatus, number>;
+    items: MigrationInfoItem[];
+};
+export type MigrationArchive = {
+    name: string;
+    path: string;
+    files: string[];
+};
+export type MigrationCheckIssue = {
+    severity: "error";
+    code: "invalid-file-name" | "invalid-version" | "duplicate-version" | "orphan-down" | "invalid-squash-metadata" | "invalid-squash-replacement" | "tampered-squash-replacement";
+    message: string;
+    file?: string;
+    version?: number;
+    name?: string;
+};
+export type MigrationCheckReport = {
+    ok: boolean;
+    migrations: number;
+    archives: number;
+    issues: MigrationCheckIssue[];
+};
+export type SchemaObjectDiff = {
+    added: string[];
+    removed: string[];
+    changed: string[];
+};
+export type SchemaDiffSummary = {
+    relations: SchemaObjectDiff;
+    types: SchemaObjectDiff;
+    functions: SchemaObjectDiff;
+};
+export type RevertDryRunPhase = "validate" | "begin" | "isolate" | "previous-up" | "snapshot-before" | "target-up" | "down" | "snapshot-after" | "rollback";
+export type RevertDryRunOutcome = {
+    kind: "noop";
+} | {
+    kind: "no-down";
+    version: number;
+    name: string;
+} | {
+    kind: "passed";
+    version: number;
+    name: string;
+} | {
+    kind: "schema-mismatch";
+    version: number;
+    name: string;
+    diff: SchemaDiffSummary;
+} | {
+    kind: "failed";
+    version?: number;
+    name?: string;
+    phase: RevertDryRunPhase;
+    error: string;
+};
+export declare function checkMigrationFiles(migrationsDir: string): MigrationCheckReport;
+export declare function planPending(c: PgClient, migrationsDir: string, onEvent?: (e: PlanOutcome) => void): Promise<{
+    pending: number;
+    adoptable: number;
+    tampered: number;
+    failed: number;
+    steps: MigrationPlanItem[];
+}>;
+export declare function inspectMigrationPlan(c: PgClient, migrationsDir: string): Promise<MigrationPlanSnapshot>;
+export declare function inspectMigrations(c: PgClient, migrationsDir: string): Promise<MigrationInfoSnapshot>;
 export declare function applyPending(c: PgClient, migrationsDir: string, onEvent?: (e: ApplyOutcome) => void): Promise<{
     applied: number;
     tampered: number;
@@ -32,11 +167,53 @@ export declare function applyPending(c: PgClient, migrationsDir: string, onEvent
 }>;
 export declare function acquireMigrateLock(c: PgClient, lockKey?: number | bigint, timeoutMs?: number): Promise<void>;
 export declare function releaseMigrateLock(c: PgClient, lockKey?: number | bigint): Promise<void>;
+export declare function sanitizePgDumpSchema(sql: string): string;
+export declare function listMigrationArchives(migrationsDir: string): MigrationArchive[];
+export declare function restoreMigrationArchive(migrationsDir: string, archiveName: string, opts?: {
+    force?: boolean;
+}): {
+    archiveName: string;
+    restored: string[];
+};
+export declare function createSquashMigration(opts: {
+    migrationsDir: string;
+    name: string;
+    schemaSql: string;
+    replace?: boolean;
+}): {
+    version: number;
+    name: string;
+    upPath: string;
+    replaced: number;
+    archiveDir?: string;
+};
+export declare function dumpSchema(databaseUrl: string, pgDumpPath?: string): string;
+export declare function migrateSquash(opts: {
+    databaseUrl?: string;
+    migrationsDir: string;
+    name: string;
+    shadowUrl?: string;
+    shadowAdminUrl?: string;
+    replace?: boolean;
+    pgDumpPath?: string;
+    lockKey?: number | bigint;
+    lockTimeoutMs?: number;
+}): Promise<void>;
 export declare function migrateRun(opts: MigrateOptions & {
     lockKey?: number | bigint;
     lockTimeoutMs?: number;
+    dryRun?: boolean;
+    json?: boolean;
+}): Promise<void>;
+export declare function migrateInfo(opts: MigrateOptions & {
+    json?: boolean;
 }): Promise<void>;
-export declare function migrateInfo(opts: MigrateOptions): Promise<void>;
+export declare function migrateCheck(opts: {
+    migrationsDir: string;
+    json?: boolean;
+}): void;
+export declare function migrateDev(opts: MigrationWorkflowOptions): Promise<void>;
+export declare function migrateVerify(opts: MigrationWorkflowOptions): Promise<void>;
 export type RevertOutcome = {
     kind: "noop";
 } | {
@@ -54,10 +231,20 @@ export type RevertOutcome = {
     error: string;
 };
 export declare function revertLast(c: PgClient, migrationsDir: string): Promise<RevertOutcome>;
+export declare function checkLastDownMigration(c: PgClient, migrationsDir: string): Promise<RevertDryRunOutcome>;
 export declare function migrateRevert(opts: MigrateOptions & {
     lockKey?: number | bigint;
     lockTimeoutMs?: number;
+    dryRun?: boolean;
+    shadowUrl?: string;
+    shadowAdminUrl?: string;
+    json?: boolean;
 }): Promise<void>;
+export declare function migrateArchiveList(opts: Pick<MigrateOptions, "migrationsDir">): void;
+export declare function migrateArchiveRestore(opts: Pick<MigrateOptions, "migrationsDir"> & {
+    name: string;
+    force?: boolean;
+}): void;
 export declare function migrateAdd(opts: MigrateOptions & {
     name: string;
 }): void;