@zintrust/db-postgres 0.9.1 → 0.9.3

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/db-postgres",
-  "version": "0.9.1",
-  "buildDate": "2026-04-21T12:31:14.649Z",
+  "version": "0.9.3",
+  "buildDate": "2026-04-22T15:45:45.967Z",
   "buildEnvironment": {
-    "node": "v22.22.1",
-    "platform": "darwin",
-    "arch": "arm64"
+    "node": "v20.20.2",
+    "platform": "linux",
+    "arch": "x64"
   },
   "git": {
-    "commit": "a017e573",
-    "branch": "dev"
+    "commit": "552dfdf4",
+    "branch": "master"
   },
   "package": {
     "engines": {
@@ -23,25 +23,13 @@
     ]
   },
   "files": {
-    "PostgresWorkersDurableObjectAdapter.d.ts": {
-      "size": 225,
-      "sha256": "7658ded3e8a7fb3c96e0171a538b76dd75985c4f0b736d5bd56261d88d540f44"
-    },
-    "PostgresWorkersDurableObjectAdapter.js": {
-      "size": 7325,
-      "sha256": "2c7fd4cc70356947b6d2206ffd154485c726d56bb3f9b46a5b6091417552ea55"
-    },
-    "build-manifest.json": {
-      "size": 1420,
-      "sha256": "5d43aaab89d6d77ec6275ef09fbef47a4103e8a2e37eb44ebe7861512d939a67"
-    },
     "index.d.ts": {
       "size": 1347,
       "sha256": "6090d1757bf63ac7ac510a59ccfd9137e5b0b9e32b2cbebd0d5bbbe3834a7233"
     },
     "index.js": {
       "size": 7208,
-      "sha256": "9bebd1b813c666df6cf47d1a32e385d4118ec31e50b5bbfd67569b7a525803b4"
+      "sha256": "9c6c963e3101e6618144a55ac52d8571f18d0ded3272870eee9e6d8b0874d5fd"
     },
     "register.d.ts": {
       "size": 183,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/db-postgres",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "PostgreSQL database adapter for ZinTrust.",
   "private": false,
   "type": "module",
@@ -23,7 +23,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "*"
+    "@zintrust/core": "^0.9.2"
   },
   "publishConfig": {
     "access": "public"

package/dist/PostgresWorkersDurableObjectAdapter.d.ts

@@ -1,5 +0,0 @@
-import type { IDatabaseAdapter } from './index.js';
-export declare const PostgresWorkersDurableObjectAdapter: Readonly<{
-    create(_config: unknown): IDatabaseAdapter;
-}>;
-export default PostgresWorkersDurableObjectAdapter;

package/dist/PostgresWorkersDurableObjectAdapter.js

@@ -1,191 +0,0 @@
-import { ErrorFactory, Logger } from '@zintrust/core';
-const POSTGRES_TYPE = 'postgresql';
-const CREATE_MIGRATIONS_TABLE_SQL = `CREATE TABLE IF NOT EXISTS migrations (
-  id SERIAL PRIMARY KEY,
-  name VARCHAR(255) NOT NULL,
-  scope VARCHAR(255) NOT NULL DEFAULT 'global',
-  service VARCHAR(255) NOT NULL DEFAULT '',
-  batch INTEGER NOT NULL,
-  status VARCHAR(255) NOT NULL,
-  applied_at TIMESTAMP NULL,
-  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  UNIQUE(name, scope, service)
-)`;
-const getDoTimeoutMs = () => {
-    const globalEnv = globalThis.env;
-    const raw = globalEnv?.['POSTGRES_DO_TIMEOUT_MS'] ?? globalEnv?.['DO_REQUEST_TIMEOUT_MS'];
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 15000;
-};
-const createTimeoutSignal = (timeoutMs) => {
-    if (timeoutMs <= 0)
-        return undefined;
-    const timeout = AbortSignal.timeout;
-    return typeof timeout === 'function' ? timeout(timeoutMs) : undefined;
-};
-const createSendQueryFunction = (getStub, connect) => {
-    return async (sql, params, method) => {
-        await connect();
-        const stub = getStub();
-        const executePath = 'http://do/execute'; //NOSONAR
-        const queryPath = 'http://do/query'; //NOSONAR
-        const payload = JSON.stringify({
-            command: sql,
-            sql,
-            params,
-            method,
-        });
-        const timeoutMs = getDoTimeoutMs();
-        const send = async (path) => {
-            const startedAt = Date.now();
-            try {
-                const response = await stub.fetch(path, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: payload,
-                    signal: createTimeoutSignal(timeoutMs),
-                });
-                Logger.debug('[PostgresWorkersDurableObjectAdapter] DO request completed', {
-                    path,
-                    status: response.status,
-                    durationMs: Date.now() - startedAt,
-                    timeoutMs,
-                    sqlPreview: sql.slice(0, 80),
-                });
-                return response;
-            }
-            catch (error) {
-                Logger.error('[PostgresWorkersDurableObjectAdapter] DO request failed', {
-                    path,
-                    durationMs: Date.now() - startedAt,
-                    timeoutMs,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                if (error instanceof Error && error.name === 'AbortError') {
-                    throw ErrorFactory.createGeneralError(`PostgreSQL DO request timed out after ${timeoutMs}ms (${path})`, error);
-                }
-                throw error;
-            }
-        };
-        let response = await send(executePath);
-        if (!response.ok && (response.status === 404 || response.status === 405)) {
-            response = await send(queryPath);
-        }
-        if (!response.ok) {
-            const text = await response.text();
-            let errDetail;
-            try {
-                errDetail = JSON.parse(text);
-            }
-            catch {
-                errDetail = { error: text };
-            }
-            const msg = errDetail.error ||
-                errDetail.message ||
-                response.statusText;
-            throw ErrorFactory.createGeneralError(`DO Query Failed: ${msg}`);
-        }
-        const json = (await response.json());
-        if (json !== null && typeof json === 'object' && 'result' in json) {
-            return json.result;
-        }
-        return json;
-    };
-};
-const createConnectionManager = (getNamespace) => {
-    let connected = false;
-    const getStub = () => {
-        const namespace = getNamespace();
-        if (!namespace) {
-            throw ErrorFactory.createConfigError('POSTGRES_POOL binding not found. Cannot connect to Durable Object pool.');
-        }
-        const id = namespace.idFromName('default');
-        return namespace.get(id);
-    };
-    const connect = async () => {
-        if (connected)
-            return;
-        try {
-            const stub = getStub();
-            const health = 'http://do/health'; //NOSONAR
-            const timeoutMs = getDoTimeoutMs();
-            const res = await stub.fetch(health, {
-                method: 'POST',
-                signal: createTimeoutSignal(timeoutMs),
-            });
-            if (!res.ok) {
-                const details = await res.text();
-                throw ErrorFactory.createGeneralError(`DO health check failed: ${res.status} ${details || res.statusText}`);
-            }
-            const body = (await res.json());
-            if (!body.connected) {
-                Logger.info('[PostgresWorkersDurableObjectAdapter] DO not connected yet, will init on first query');
-            }
-            connected = true;
-        }
-        catch (err) {
-            Logger.error('[PostgresWorkersDurableObjectAdapter] Connection failed', err);
-            throw ErrorFactory.createGeneralError('Failed to connect to PostgreSQL DO', err);
-        }
-    };
-    const sendQuery = createSendQueryFunction(getStub, connect);
-    return {
-        connect,
-        sendQuery,
-        disconnect: () => {
-            connected = false;
-        },
-        isConnected: () => connected,
-    };
-};
-export const PostgresWorkersDurableObjectAdapter = Object.freeze({
-    create(_config) {
-        const connectionManager = createConnectionManager(() => {
-            const globalEnv = globalThis.env;
-            return globalEnv?.['POSTGRES_POOL'];
-        });
-        return {
-            async connect() {
-                return connectionManager.connect();
-            },
-            async disconnect() {
-                connectionManager.disconnect();
-            },
-            async query(sql, parameters = []) {
-                return connectionManager.sendQuery(sql, parameters, 'query');
-            },
-            async queryOne(sql, parameters = []) {
-                const result = await connectionManager.sendQuery(sql, parameters, 'query');
-                if (result.rows.length === 0)
-                    return null;
-                return result.rows[0];
-            },
-            async rawQuery(sql, parameters) {
-                const result = await connectionManager.sendQuery(sql, parameters || [], 'query');
-                return result.rows;
-            },
-            async ping() {
-                await connectionManager.connect();
-                await connectionManager.sendQuery('SELECT 1', [], 'query');
-            },
-            async transaction(_callback) {
-                throw ErrorFactory.createGeneralError('Transactions are not yet supported in PostgresWorkersDurableObjectAdapter');
-            },
-            getType() {
-                return POSTGRES_TYPE;
-            },
-            isConnected() {
-                return connectionManager.isConnected();
-            },
-            getPlaceholder(index) {
-                return `$${index}`;
-            },
-            async ensureMigrationsTable() {
-                await connectionManager.sendQuery(CREATE_MIGRATIONS_TABLE_SQL, [], 'query');
-            },
-        };
-    },
-});
-export default PostgresWorkersDurableObjectAdapter;