@onreza/sqlx-js 0.0.0

package/dist/src/postgres-runtime.d.ts

@@ -0,0 +1,11 @@
+import postgres from "postgres";
+export type PostgresClient = postgres.Sql<{
+    bigint: bigint;
+}>;
+export type PostgresOptions = postgres.Options<Record<string, postgres.PostgresType>>;
+export declare function createClient(url?: string | undefined, options?: PostgresOptions): PostgresClient;
+export declare function getClient(): PostgresClient;
+export declare function setClient(client: PostgresClient): void;
+export declare function close(): Promise<void>;
+export declare const sql: import("./runtime.js").SqlRoot;
+export declare const unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;

package/dist/src/postgres-runtime.js

@@ -0,0 +1,150 @@
+import postgres from "postgres";
+import { createSqlRuntime, encodeParam, encodePgArrayLiteral, parsePgArrayLiteral } from "./runtime.js";
+import { arrayElementOid, builtinArrayOids } from "./pg/oids.js";
+class PostgresRuntimeClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async query(query, params) {
+        return await this.client.unsafe(query, params, { prepare: true });
+    }
+    transformParam(param) {
+        const elementOid = postgresNativeArrayElementOid(param);
+        if (elementOid !== undefined)
+            return this.client.array(param, elementOid);
+        return encodeParam(param);
+    }
+    async transaction(fn) {
+        if (!("begin" in this.client))
+            throw new Error("sqlx-js.transaction: nested transactions are not supported");
+        return await this.client.begin(async (tx) => {
+            return await fn(new PostgresRuntimeClient(tx));
+        });
+    }
+    async close() {
+        if ("end" in this.client)
+            await this.client.end();
+    }
+}
+let defaultClient = null;
+const STRING_ARRAY_ELEMENT_OIDS = new Set([
+    18,
+    19,
+    25,
+    27,
+    28,
+    29,
+    142,
+    600,
+    601,
+    602,
+    603,
+    604,
+    628,
+    650,
+    718,
+    774,
+    790,
+    829,
+    869,
+    1042,
+    1043,
+    1083,
+    1186,
+    1266,
+    1560,
+    1562,
+    1700,
+    2950,
+    2205,
+    2206,
+    3220,
+    3614,
+    3615,
+    3904,
+    3906,
+    3908,
+    3910,
+    3912,
+    3926,
+    4451,
+    4536,
+]);
+function parseSimpleArrayElement(oid) {
+    switch (oid) {
+        case 16:
+            return (value) => value === "t";
+        case 20:
+            return (value) => BigInt(value);
+        case 21:
+        case 23:
+        case 26:
+        case 700:
+        case 701:
+            return (value) => Number(value);
+        default:
+            return STRING_ARRAY_ELEMENT_OIDS.has(oid) ? (value) => value : undefined;
+    }
+}
+function postgresNativeArrayElementOid(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    let oid;
+    for (const item of value) {
+        if (item === null)
+            continue;
+        const itemOid = item instanceof Uint8Array ? 17 : undefined;
+        if (itemOid === undefined)
+            return undefined;
+        if (oid !== undefined && oid !== itemOid)
+            return undefined;
+        oid = itemOid;
+    }
+    return oid;
+}
+function postgresTypes() {
+    const types = { bigint: postgres.BigInt };
+    for (const oid of builtinArrayOids()) {
+        const elementOid = arrayElementOid(oid);
+        if (elementOid === undefined)
+            continue;
+        const parseElement = parseSimpleArrayElement(elementOid);
+        if (!parseElement)
+            continue;
+        types[`array_${oid}`] = {
+            to: oid,
+            from: [oid],
+            serialize: (value) => Array.isArray(value) ? encodePgArrayLiteral(value) : String(value),
+            parse: (value) => parsePgArrayLiteral(value, parseElement),
+        };
+    }
+    return types;
+}
+export function createClient(url = process.env.DATABASE_URL, options = {}) {
+    if (!url)
+        throw new Error("sqlx-js: DATABASE_URL is not set");
+    return postgres(url, { ...options, types: { ...postgresTypes(), ...(options.types ?? {}) } });
+}
+function createDefaultClient() {
+    return new PostgresRuntimeClient(createClient());
+}
+function getRuntimeClient() {
+    defaultClient ??= createDefaultClient();
+    return defaultClient;
+}
+export function getClient() {
+    return getRuntimeClient().client;
+}
+export function setClient(client) {
+    defaultClient = new PostgresRuntimeClient(client);
+}
+export async function close() {
+    if (defaultClient) {
+        await defaultClient.close();
+        defaultClient = null;
+    }
+}
+const runtime = createSqlRuntime(getRuntimeClient);
+export const sql = runtime.sql;
+export const unsafe = runtime.unsafe;

package/dist/src/runtime.d.ts

@@ -0,0 +1,69 @@
+export type RuntimeClient = {
+    query: (query: string, params: unknown[]) => Promise<unknown[]>;
+    transformParam?: (param: unknown) => unknown;
+    transaction: <R>(fn: (client: RuntimeClient) => Promise<R>) => Promise<R>;
+    close: () => Promise<void>;
+};
+type AnyFn = (...args: unknown[]) => Promise<unknown[]>;
+type AnyOneFn = (...args: unknown[]) => Promise<unknown>;
+type AnyOptionalFn = (...args: unknown[]) => Promise<unknown | null>;
+type IdentifierFn = (...parts: string[]) => string;
+declare function renameRows(rows: unknown[]): unknown[];
+declare function isPrimitiveArrayElement(v: unknown): boolean;
+export declare function encodePgArrayLiteral(arr: unknown[]): string;
+type PgArrayValue<T> = T | null | PgArrayValue<T>[];
+export declare function parsePgArrayLiteral<T = string>(input: string, parseElement?: (value: string) => T): PgArrayValue<T>[];
+export declare function encodeParam(p: unknown): unknown;
+export declare class NoRowsError extends Error {
+    constructor(message?: string);
+}
+export declare class TooManyRowsError extends Error {
+    actual: number;
+    constructor(actual: number, expected?: "1" | "0 or 1");
+}
+export declare const _internal: {
+    renameRows: typeof renameRows;
+    encodeParam: typeof encodeParam;
+    isPrimitiveArrayElement: typeof isPrimitiveArrayElement;
+    parsePgArrayLiteral: typeof parsePgArrayLiteral;
+    loadSqlFile: typeof loadSqlFile;
+    buildSetTransaction: typeof buildSetTransaction;
+    clearIdentifierCache: typeof clearIdentifierCache;
+};
+declare function loadSqlFile(path: string): string;
+export declare function clearSqlFileCache(): void;
+declare function clearIdentifierCache(): void;
+export declare function id(...parts: string[]): string;
+type FileCallable = AnyFn & {
+    one: AnyOneFn;
+    optional: AnyOptionalFn;
+};
+type SqlCallable = AnyFn & {
+    file: FileCallable;
+    one: AnyOneFn;
+    optional: AnyOptionalFn;
+    id: IdentifierFn;
+};
+export type TransactionOptions = {
+    isolation?: "read uncommitted" | "read committed" | "repeatable read" | "serializable";
+    readOnly?: boolean;
+    deferrable?: boolean;
+};
+export type SqlRoot = SqlCallable & {
+    transaction: <R>(fnOrOpts: TransactionOptions | ((tx: SqlCallable) => Promise<R>), fn?: (tx: SqlCallable) => Promise<R>) => Promise<R>;
+};
+declare function buildSetTransaction(opts: TransactionOptions): string;
+export type RuntimeApi = {
+    sql: SqlRoot;
+    unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
+};
+export declare function createSqlRuntime(getClient: () => RuntimeClient): RuntimeApi;
+export type MigrateOptions = {
+    dir?: string;
+    databaseUrl?: string;
+    log?: (msg: string) => void;
+    lockKey?: number | bigint;
+    lockTimeoutMs?: number;
+};
+export declare function migrate(opts?: MigrateOptions): Promise<void>;
+export {};

package/dist/src/runtime.js

@@ -0,0 +1,446 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { PgClient, parseDatabaseUrl } from "./pg/wire.js";
+import { applyPending, acquireMigrateLock, releaseMigrateLock, DEFAULT_MIGRATE_LOCK_KEY } from "./commands/migrate.js";
+const SUFFIX = /[!?]$/;
+function renameRows(rows) {
+    if (rows.length === 0)
+        return rows;
+    const first = rows[0];
+    if (first === null || typeof first !== "object")
+        return rows;
+    const rename = new Map();
+    for (const k of Object.keys(first)) {
+        if (SUFFIX.test(k))
+            rename.set(k, k.slice(0, -1));
+    }
+    if (rename.size === 0)
+        return rows;
+    const out = new Array(rows.length);
+    for (let i = 0; i < rows.length; i++) {
+        const r = rows[i];
+        const copy = {};
+        for (const k in r) {
+            const dst = rename.get(k);
+            copy[dst ?? k] = r[k];
+        }
+        out[i] = copy;
+    }
+    return out;
+}
+function isPrimitiveArrayElement(v) {
+    if (v === null || v === undefined)
+        return true;
+    const t = typeof v;
+    return t === "string" || t === "number" || t === "bigint" || t === "boolean";
+}
+function quoteArrayElement(raw) {
+    return '"' + raw.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+}
+export function encodePgArrayLiteral(arr) {
+    const parts = [];
+    for (const v of arr) {
+        if (v === null || v === undefined) {
+            parts.push("NULL");
+            continue;
+        }
+        if (typeof v === "bigint") {
+            parts.push(v.toString());
+            continue;
+        }
+        if (typeof v === "number") {
+            parts.push(Number.isFinite(v) ? String(v) : quoteArrayElement(String(v)));
+            continue;
+        }
+        if (typeof v === "boolean") {
+            parts.push(v ? "t" : "f");
+            continue;
+        }
+        const s = String(v);
+        if (s === "" || /[\\"{},\s]/.test(s) || s.toLowerCase() === "null") {
+            parts.push(quoteArrayElement(s));
+        }
+        else {
+            parts.push(s);
+        }
+    }
+    return "{" + parts.join(",") + "}";
+}
+export function parsePgArrayLiteral(input, parseElement = (value) => value) {
+    let i = 0;
+    const parseQuoted = () => {
+        i++;
+        let out = "";
+        while (i < input.length) {
+            const ch = input[i++];
+            if (ch === '"')
+                return parseElement(out);
+            if (ch === "\\") {
+                if (i < input.length)
+                    out += input[i++];
+            }
+            else {
+                out += ch;
+            }
+        }
+        throw new Error("sqlx-js: malformed PostgreSQL array literal");
+    };
+    const parseUnquoted = () => {
+        const start = i;
+        while (i < input.length && input[i] !== "," && input[i] !== "}")
+            i++;
+        const raw = input.slice(start, i);
+        return raw === "NULL" ? null : parseElement(raw);
+    };
+    const parseArray = () => {
+        if (input[i] !== "{")
+            throw new Error("sqlx-js: malformed PostgreSQL array literal");
+        i++;
+        const out = [];
+        while (i < input.length) {
+            if (input[i] === "}") {
+                i++;
+                return out;
+            }
+            const value = input[i] === "{"
+                ? parseArray()
+                : input[i] === '"'
+                    ? parseQuoted()
+                    : parseUnquoted();
+            out.push(value);
+            if (input[i] === ",") {
+                i++;
+                continue;
+            }
+            if (input[i] === "}")
+                continue;
+            if (i >= input.length)
+                break;
+            throw new Error("sqlx-js: malformed PostgreSQL array literal");
+        }
+        throw new Error("sqlx-js: malformed PostgreSQL array literal");
+    };
+    const parsed = parseArray();
+    if (i !== input.length)
+        throw new Error("sqlx-js: malformed PostgreSQL array literal");
+    return parsed;
+}
+export function encodeParam(p) {
+    if (!Array.isArray(p))
+        return p;
+    if (p.length === 0)
+        return p;
+    if (!p.every(isPrimitiveArrayElement))
+        return p;
+    return encodePgArrayLiteral(p);
+}
+export class NoRowsError extends Error {
+    constructor(message = "expected exactly 1 row, got 0") {
+        super(message);
+        this.name = "NoRowsError";
+    }
+}
+export class TooManyRowsError extends Error {
+    actual;
+    constructor(actual, expected = "1") {
+        super(`expected ${expected} row${expected === "1" ? "" : "s"}, got ${actual}`);
+        this.name = "TooManyRowsError";
+        this.actual = actual;
+    }
+}
+export const _internal = {
+    renameRows,
+    encodeParam,
+    isPrimitiveArrayElement,
+    parsePgArrayLiteral,
+    loadSqlFile,
+    buildSetTransaction,
+    clearIdentifierCache,
+};
+async function runQuery(client, query, params) {
+    const encoded = params.length === 0
+        ? params
+        : params.map((p) => client.transformParam ? client.transformParam(p) : encodeParam(p));
+    const rows = await client.query(query, encoded);
+    return renameRows(rows);
+}
+async function runOne(client, query, params) {
+    const rows = await runQuery(client, query, params);
+    if (rows.length === 1)
+        return rows[0];
+    if (rows.length === 0)
+        throw new NoRowsError();
+    throw new TooManyRowsError(rows.length, "1");
+}
+async function runOptional(client, query, params) {
+    const rows = await runQuery(client, query, params);
+    if (rows.length === 0)
+        return null;
+    if (rows.length === 1)
+        return rows[0];
+    throw new TooManyRowsError(rows.length, "0 or 1");
+}
+const sqlFileCache = new Map();
+function loadSqlFile(path) {
+    const full = resolve(process.cwd(), path);
+    try {
+        const st = statSync(full);
+        const cached = sqlFileCache.get(full);
+        if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+            return cached.content;
+        }
+        const content = readFileSync(full, "utf8");
+        sqlFileCache.set(full, { mtimeMs: st.mtimeMs, size: st.size, content });
+        return content;
+    }
+    catch (err) {
+        throw new Error(`sqlx-js.sql.file: cannot read ${path}: ${err.message}`);
+    }
+}
+export function clearSqlFileCache() {
+    sqlFileCache.clear();
+}
+let identifierCache = null;
+function clearIdentifierCache() {
+    identifierCache = null;
+}
+function identifierSnapshotPath() {
+    return process.env.SQLX_JS_SCHEMA_PATH
+        ? resolve(process.cwd(), process.env.SQLX_JS_SCHEMA_PATH)
+        : resolve(process.cwd(), ".sqlx-js/schema/schema.json");
+}
+function addPath(whitelist, parts) {
+    for (const part of parts)
+        whitelist.names.add(part);
+    whitelist.paths.add(parts.join("\0"));
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function arrayProp(obj, key) {
+    const value = obj?.[key];
+    return Array.isArray(value) ? value : [];
+}
+function stringProp(obj, key) {
+    const value = obj?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function buildIdentifierWhitelist(snapshot) {
+    const whitelist = { names: new Set(), paths: new Set() };
+    const root = asRecord(snapshot);
+    for (const schema of arrayProp(root, "schemas")) {
+        if (typeof schema === "string")
+            whitelist.names.add(schema);
+    }
+    for (const relRaw of arrayProp(root, "relations")) {
+        const rel = asRecord(relRaw);
+        const schema = stringProp(rel, "schema");
+        const name = stringProp(rel, "name");
+        if (!schema || !name)
+            continue;
+        addPath(whitelist, [schema, name]);
+        for (const colRaw of arrayProp(rel, "columns")) {
+            const colName = stringProp(asRecord(colRaw), "name");
+            if (!colName)
+                continue;
+            whitelist.names.add(colName);
+            addPath(whitelist, [name, colName]);
+            addPath(whitelist, [schema, name, colName]);
+        }
+        for (const idxRaw of arrayProp(rel, "indexes")) {
+            const idxName = stringProp(asRecord(idxRaw), "name");
+            if (idxName)
+                addPath(whitelist, [schema, idxName]);
+        }
+        for (const constraintRaw of arrayProp(rel, "constraints")) {
+            const constraintName = stringProp(asRecord(constraintRaw), "name");
+            if (constraintName) {
+                addPath(whitelist, [schema, constraintName]);
+                addPath(whitelist, [name, constraintName]);
+                addPath(whitelist, [schema, name, constraintName]);
+            }
+        }
+    }
+    for (const typeRaw of arrayProp(root, "types")) {
+        const t = asRecord(typeRaw);
+        const schema = stringProp(t, "schema");
+        const name = stringProp(t, "name");
+        if (schema && name)
+            addPath(whitelist, [schema, name]);
+    }
+    for (const fnRaw of arrayProp(root, "functions")) {
+        const fn = asRecord(fnRaw);
+        const schema = stringProp(fn, "schema");
+        const name = stringProp(fn, "name");
+        if (schema && name)
+            addPath(whitelist, [schema, name]);
+    }
+    return whitelist;
+}
+function loadIdentifierWhitelist() {
+    const path = identifierSnapshotPath();
+    if (!existsSync(path)) {
+        throw new Error(`sqlx-js.id: schema snapshot not found at ${path}. Run \`sqlx-js schema dump\`.`);
+    }
+    const st = statSync(path);
+    if (identifierCache && identifierCache.path === path && identifierCache.mtimeMs === st.mtimeMs && identifierCache.size === st.size) {
+        return identifierCache.whitelist;
+    }
+    const snapshot = JSON.parse(readFileSync(path, "utf8"));
+    const whitelist = buildIdentifierWhitelist(snapshot);
+    identifierCache = { path, mtimeMs: st.mtimeMs, size: st.size, whitelist };
+    return whitelist;
+}
+function quoteIdentifier(part) {
+    if (part.length === 0)
+        throw new Error("sqlx-js.id: identifier segment must not be empty");
+    if (part.includes("\0"))
+        throw new Error("sqlx-js.id: identifier segment must not contain NUL");
+    return `"${part.replace(/"/g, '""')}"`;
+}
+export function id(...parts) {
+    if (parts.length === 0)
+        throw new Error("sqlx-js.id: at least one identifier segment is required");
+    if (parts.length > 3)
+        throw new Error("sqlx-js.id: expected 1 to 3 identifier segments");
+    const whitelist = loadIdentifierWhitelist();
+    const ok = parts.length === 1
+        ? whitelist.names.has(parts[0])
+        : whitelist.paths.has(parts.join("\0"));
+    if (!ok) {
+        throw new Error(`sqlx-js.id: identifier is not present in schema snapshot: ${parts.join(".")}`);
+    }
+    return parts.map(quoteIdentifier).join(".");
+}
+function makeBoundCallable(client) {
+    const fn = (async (query, ...params) => {
+        return runQuery(client, query, params);
+    });
+    const file = (async (path, ...params) => {
+        return runQuery(client, loadSqlFile(path), params);
+    });
+    file.one = (async (path, ...params) => {
+        return runOne(client, loadSqlFile(path), params);
+    });
+    file.optional = (async (path, ...params) => {
+        return runOptional(client, loadSqlFile(path), params);
+    });
+    fn.file = file;
+    fn.one = (async (query, ...params) => {
+        return runOne(client, query, params);
+    });
+    fn.optional = (async (query, ...params) => {
+        return runOptional(client, query, params);
+    });
+    fn.id = id;
+    return fn;
+}
+function buildSetTransaction(opts) {
+    const parts = [];
+    if (opts.isolation)
+        parts.push(`ISOLATION LEVEL ${opts.isolation.toUpperCase()}`);
+    if (opts.readOnly !== undefined)
+        parts.push(opts.readOnly ? "READ ONLY" : "READ WRITE");
+    if (opts.deferrable !== undefined)
+        parts.push(opts.deferrable ? "DEFERRABLE" : "NOT DEFERRABLE");
+    if (parts.length === 0)
+        return "";
+    return `SET TRANSACTION ${parts.join(" ")}`;
+}
+export function createSqlRuntime(getClient) {
+    const root = (async (query, ...params) => {
+        return runQuery(getClient(), query, params);
+    });
+    const rootFile = (async (path, ...params) => {
+        return runQuery(getClient(), loadSqlFile(path), params);
+    });
+    rootFile.one = (async (path, ...params) => {
+        return runOne(getClient(), loadSqlFile(path), params);
+    });
+    rootFile.optional = (async (path, ...params) => {
+        return runOptional(getClient(), loadSqlFile(path), params);
+    });
+    root.file = rootFile;
+    root.one = (async (query, ...params) => {
+        return runOne(getClient(), query, params);
+    });
+    root.optional = (async (query, ...params) => {
+        return runOptional(getClient(), query, params);
+    });
+    root.id = id;
+    root.transaction = (async (fnOrOpts, maybeFn) => {
+        const c = getClient();
+        let opts = {};
+        let cb;
+        if (typeof fnOrOpts === "function") {
+            cb = fnOrOpts;
+        }
+        else {
+            opts = fnOrOpts;
+            if (!maybeFn)
+                throw new Error("sqlx-js.transaction: callback is required");
+            cb = maybeFn;
+        }
+        const setTx = buildSetTransaction(opts);
+        return await c.transaction(async (txClient) => {
+            if (setTx)
+                await txClient.query(setTx, []);
+            const tx = makeBoundCallable(txClient);
+            return await cb(tx);
+        });
+    });
+    const unsafe = (async (query, ...params) => {
+        return (await runQuery(getClient(), query, params));
+    });
+    return { sql: root, unsafe };
+}
+function normalizeLockKey(lockKey) {
+    if (typeof lockKey === "bigint")
+        return lockKey;
+    if (!Number.isSafeInteger(lockKey)) {
+        throw new Error(`sqlx-js.migrate: lockKey must be a safe integer or bigint, got ${lockKey}`);
+    }
+    return BigInt(lockKey);
+}
+export async function migrate(opts = {}) {
+    const url = opts.databaseUrl ?? process.env.DATABASE_URL;
+    if (!url)
+        throw new Error("sqlx-js.migrate: DATABASE_URL is required");
+    const dir = opts.dir ?? "migrations";
+    const log = opts.log ?? ((m) => console.log(`[sqlx-js] ${m}`));
+    const lockKey = normalizeLockKey(opts.lockKey ?? DEFAULT_MIGRATE_LOCK_KEY);
+    const cfg = parseDatabaseUrl(url);
+    const client = new PgClient(cfg);
+    await client.connect();
+    let locked = false;
+    try {
+        await acquireMigrateLock(client, lockKey, opts.lockTimeoutMs);
+        locked = true;
+        let appliedAny = false;
+        const result = await applyPending(client, dir, (e) => {
+            if (e.kind === "applied") {
+                log(`migrate: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
+                appliedAny = true;
+            }
+            else if (e.kind === "tampered") {
+                throw new Error(`sqlx-js.migrate: ${e.version}_${e.name} hash mismatch (applied ${e.applied.slice(0, 16)}… vs current ${e.current.slice(0, 16)}…)`);
+            }
+            else {
+                throw new Error(`sqlx-js.migrate: ${e.version}_${e.name} failed — ${e.error}`);
+            }
+        });
+        if (!appliedAny)
+            log(`migrate: up-to-date (${result.applied + result.failed + result.tampered === 0 ? "no pending" : ""})`);
+    }
+    finally {
+        if (locked) {
+            try {
+                await releaseMigrateLock(client, lockKey);
+            }
+            catch (e) {
+                log(`migrate: failed to release advisory lock: ${e.message}`);
+            }
+        }
+        await client.end();
+    }
+}

package/dist/src/scan/scanner.d.ts

@@ -0,0 +1,12 @@
+export type QueryCallSite = {
+    file: string;
+    line: number;
+    column: number;
+    query: string;
+    paramCount: number;
+    kind: "inline" | "file";
+    sqlFilePath?: string;
+};
+export declare function findSourceFiles(root: string): string[];
+export declare function scanFile(absPath: string, root: string): QueryCallSite[];
+export declare function scanProject(root: string): QueryCallSite[];