@onreza/sqlx-js 0.1.0 → 0.2.0

package/dist/src/runtime.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { PgClient, parseDatabaseUrl } from "./pg/wire.js";
+import { PgClient, parseDatabaseUrl, PgError } from "./pg/wire.js";
 import { applyPending, acquireMigrateLock, releaseMigrateLock, DEFAULT_MIGRATE_LOCK_KEY } from "./commands/migrate.js";
 const SUFFIX = /[!?]$/;
 function renameRows(rows) {
@@ -148,6 +148,63 @@ export class TooManyRowsError extends Error {
         this.actual = actual;
     }
 }
+// SQLSTATE is exactly five characters from [0-9A-Z]; lowercase or other shapes
+// are never valid, so transport codes like "EPIPE" must not match on shape alone.
+const SQLSTATE = /^[0-9A-Z]{5}$/;
+function firstString(...candidates) {
+    for (const value of candidates) {
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+export function toPgError(e) {
+    if (e instanceof PgError)
+        return e;
+    if (e === null || typeof e !== "object")
+        return null;
+    const o = e;
+    const code = typeof o.code === "string" ? o.code : undefined;
+    // `_name` variants are postgres.js; bare forms are node-postgres. Bare
+    // `column`/`schema`/`table` can also collide with runtime-added Error
+    // properties, so we read namespaced variants first and only accept strings.
+    const severity = firstString(o.severity, o.severity_local);
+    // A genuine database error is identified by the driver's branded name
+    // (Postgres.js) or by a SQLSTATE-shaped code paired with a severity. Transport
+    // and system errors (EPIPE, ECONNREFUSED, CONNECTION_ENDED) carry neither, so
+    // they pass through untouched instead of masquerading as a PgError.
+    const isDatabaseError = o.name === "PostgresError" ||
+        (code !== undefined && SQLSTATE.test(code) && severity !== undefined);
+    if (!isDatabaseError)
+        return null;
+    const fields = {};
+    if (typeof o.message === "string" && o.message.length > 0)
+        fields.M = o.message;
+    if (code)
+        fields.C = code;
+    if (typeof o.detail === "string" && o.detail.length > 0)
+        fields.D = o.detail;
+    if (typeof o.hint === "string" && o.hint.length > 0)
+        fields.H = o.hint;
+    const position = firstString(o.position) ?? (typeof o.position === "number" && Number.isFinite(o.position) ? String(o.position) : undefined);
+    if (position)
+        fields.P = position;
+    if (severity)
+        fields.S = severity;
+    const table = firstString(o.table_name, o.table);
+    if (table)
+        fields.t = table;
+    const column = firstString(o.column_name, o.column);
+    if (column)
+        fields.c = column;
+    const constraint = firstString(o.constraint_name, o.constraint);
+    if (constraint)
+        fields.n = constraint;
+    const schema = firstString(o.schema_name, o.schema);
+    if (schema)
+        fields.s = schema;
+    return new PgError(fields, { cause: e });
+}
 export const _internal = {
     renameRows,
     encodeParam,
@@ -156,13 +213,32 @@ export const _internal = {
     loadSqlFile,
     buildSetTransaction,
     clearIdentifierCache,
+    toPgError,
 };
 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);
+    const onQuery = client.onQuery;
+    if (!onQuery) {
+        try {
+            return renameRows(await client.query(query, encoded));
+        }
+        catch (e) {
+            throw toPgError(e) ?? e;
+        }
+    }
+    const start = performance.now();
+    try {
+        const rows = await client.query(query, encoded);
+        onQuery({ query, params, durationMs: performance.now() - start, rowCount: rows.length });
+        return renameRows(rows);
+    }
+    catch (e) {
+        const error = toPgError(e) ?? e;
+        onQuery({ query, params, durationMs: performance.now() - start, error });
+        throw error;
+    }
 }
 async function runOne(client, query, params) {
     const rows = await runQuery(client, query, params);
@@ -422,6 +498,10 @@ export async function migrate(opts = {}) {
                 log(`migrate: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
                 appliedAny = true;
             }
+            else if (e.kind === "adopted") {
+                log(`migrate: adopted ${String(e.version).padStart(4, "0")}_${e.name} (${e.replaced} replaced)`);
+                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)}…)`);
             }

package/dist/src/scan/scanner.js

@@ -2,7 +2,7 @@ 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 SQLX_MODULES = new Set(["@onreza/sqlx-js"]);
 const EXT = /\.(ts|tsx|mts|cts)$/;
 function walk(dir, out) {
     for (const name of readdirSync(dir)) {

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
   "sideEffects": false,
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -12,12 +15,6 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js",
       "default": "./dist/src/index.js"
-    },
-    "./bun": {
-      "types": "./dist/src/bun.d.ts",
-      "bun": "./dist/src/bun.js",
-      "import": "./dist/src/bun.js",
-      "default": "./dist/src/bun.js"
     }
   },
   "bin": {
@@ -52,7 +49,7 @@
     "migrations"
   ],
   "scripts": {
-    "prepare": "[ -d .git ] && lefthook install >/dev/null 2>&1 || true",
+    "prepare": "(test -f dist/bin/sqlx-js.js || bun run build) && ([ ! -d .git ] || lefthook install >/dev/null 2>&1 || true)",
     "test": "bun test tests",
     "test:typecheck": "tsc --noEmit",
     "test:example": "bunx tsc -p example --noEmit",

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

@@ -1,7 +0,0 @@
-import { SQL } from "bun";
-export type BunClient = SQL;
-export declare function getClient(): BunClient;
-export declare function setClient(client: BunClient): 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/bun-runtime.js

@@ -1,45 +0,0 @@
-import { SQL } from "bun";
-import { createSqlRuntime } from "./runtime.js";
-class BunRuntimeClient {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async query(query, params) {
-        return await this.client.unsafe(query, params);
-    }
-    async transaction(fn) {
-        return await this.client.begin(async (tx) => {
-            return await fn(new BunRuntimeClient(tx));
-        });
-    }
-    async close() {
-        await this.client.close();
-    }
-}
-let defaultClient = null;
-function createDefaultClient() {
-    const url = process.env.DATABASE_URL;
-    if (!url)
-        throw new Error("sqlx-js: DATABASE_URL is not set");
-    return new BunRuntimeClient(new SQL({ url, bigint: true }));
-}
-function getRuntimeClient() {
-    defaultClient ??= createDefaultClient();
-    return defaultClient;
-}
-export function getClient() {
-    return getRuntimeClient().client;
-}
-export function setClient(client) {
-    defaultClient = new BunRuntimeClient(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/bun.d.ts

@@ -1,22 +0,0 @@
-import * as rt from "./bun-runtime.js";
-import type { Typed as TypedFor, TypedFile as TypedFileFor, TypedSql as TypedSqlFor } from "./typed.js";
-export interface KnownQueries {
-}
-export interface KnownFileQueries {
-}
-export type { SqlxJsConfig } from "./config.js";
-export type { SslMode, ConnConfig } from "./pg/wire.js";
-export { PgError, ConnectionLostError } from "./pg/wire.js";
-export { NoRowsError, TooManyRowsError } from "./runtime.js";
-export type { TransactionOptions, MigrateOptions } from "./runtime.js";
-export type { BunClient } from "./bun-runtime.js";
-export type TypedFile = TypedFileFor<KnownFileQueries>;
-export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
-export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;
-export declare const sql: Typed;
-export type Unsafe = (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
-export declare const unsafe: Unsafe;
-export declare const getClient: typeof rt.getClient;
-export declare const setClient: typeof rt.setClient;
-export declare const close: typeof rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";

package/dist/src/bun.js

@@ -1,9 +0,0 @@
-import * as rt from "./bun-runtime.js";
-export { PgError, ConnectionLostError } from "./pg/wire.js";
-export { NoRowsError, TooManyRowsError } from "./runtime.js";
-export const sql = rt.sql;
-export const unsafe = rt.unsafe;
-export const getClient = rt.getClient;
-export const setClient = rt.setClient;
-export const close = rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";