@kubun/db-postgres 0.10.0 → 0.12.0

package/lib/index.d.ts

@@ -4,6 +4,8 @@ import { type Options, type PostgresType } from 'postgres';
 export type AdapterParams = {
     url: string;
     options?: Options<Record<string, PostgresType>>;
+    /** @see CLOSE_TIMEOUT_SECONDS */
+    closeTimeoutSeconds?: number;
 };
 export declare class PostgresAdapter extends AbstractPostgresAdapter {
     #private;

package/lib/index.js

@@ -1 +1,84 @@
-import{AbstractPostgresAdapter as t}from"@kubun/db-adapter";import{PostgresJSDialect as r}from"kysely-postgres-js";import e from"postgres";export class PostgresAdapter extends t{#t;constructor(t){super(),this.#t=new r({postgres:e(t.url,t.options)})}get dialect(){return this.#t}}
+import { AbstractPostgresAdapter } from '@kubun/db-adapter';
+import { PostgresJSDialect } from 'kysely-postgres-js';
+import postgres from 'postgres';
+/**
+ * How long `close()` gives in-flight queries before terminating the connections
+ * out from under them.
+ *
+ * A timeout is not a nicety here. kysely-postgres-js acquires EVERY query
+ * through `postgres.reserve()`, and postgres.js `end()` waits on a reserved
+ * connection for a resolver only `terminate()` ever calls — releasing the
+ * reservation afterwards returns the connection to the pool without ending it.
+ * So a single query overlapping the close wedges the close PERMANENTLY, and any
+ * unawaited background query hangs a process that is shutting down cleanly.
+ * Shutdown has to be able to finish; a component with work worth finishing
+ * drains it before closing the database, and does not rely on this.
+ */ const CLOSE_TIMEOUT_SECONDS = 5;
+class ClosingPostgresJSDialect {
+    #dialect;
+    #end;
+    constructor(params){
+        this.#dialect = params.dialect;
+        this.#end = params.end;
+    }
+    createAdapter() {
+        return this.#dialect.createAdapter();
+    }
+    createDriver() {
+        const driver = this.#dialect.createDriver();
+        // Shadows the prototype's `destroy`, which calls `end()` with no deadline.
+        driver.destroy = this.#end;
+        return driver;
+    }
+    createIntrospector(db) {
+        return this.#dialect.createIntrospector(db);
+    }
+    createQueryCompiler() {
+        return this.#dialect.createQueryCompiler();
+    }
+}
+export class PostgresAdapter extends AbstractPostgresAdapter {
+    #dialect;
+    constructor(params){
+        super();
+        // postgres.js returns int8/bigint columns as strings by default to avoid
+        // precision loss. Our bigint columns hold ms-epoch values (well under
+        // 2^53), and the table types declare them as `number`, so parse them back
+        // to numbers on read. Caller-supplied `types` still take precedence.
+        //
+        // NOTE: this parser is connection-global — it applies to EVERY int8 read
+        // (including `COUNT()` results), not just the hub ms-epoch columns. Safe
+        // today because all int8 values in use are < 2^53 (Number.MAX_SAFE_INTEGER).
+        // A future column holding genuinely large bigints (e.g. a snowflake ID)
+        // would lose precision here and must opt out via a `BigInt`-returning type.
+        const options = {
+            ...params.options,
+            types: {
+                int8: {
+                    to: 20,
+                    from: [
+                        20
+                    ],
+                    serialize: (value)=>String(value),
+                    parse: (value)=>Number(value)
+                },
+                ...params.options?.types
+            }
+        };
+        const client = postgres(params.url, options);
+        const timeout = params.closeTimeoutSeconds ?? CLOSE_TIMEOUT_SECONDS;
+        this.#dialect = new ClosingPostgresJSDialect({
+            dialect: new PostgresJSDialect({
+                postgres: client
+            }),
+            end: async ()=>{
+                await client.end({
+                    timeout
+                });
+            }
+        });
+    }
+    get dialect() {
+        return this.#dialect;
+    }
+}

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@kubun/db-postgres",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "kysely": "^0.29.2",
+    "kysely": "^0.29.4",
     "kysely-postgres-js": "^3.0.0",
     "postgres": "^3.4.8",
-    "@kubun/db-adapter": "^0.10.0"
+    "@kubun/db-adapter": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }