@zintrust/db-postgres 0.1.8

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export type DatabaseConfig = {
+    driver: 'sqlite' | 'postgresql' | 'mysql' | 'sqlserver' | 'd1';
+    database?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+    readHosts?: string[];
+};
+export type QueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+};
+export interface IDatabaseAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query(sql: string, parameters: unknown[]): Promise<QueryResult>;
+    queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null>;
+    ping(): Promise<void>;
+    transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T>;
+    rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    getType(): string;
+    isConnected(): boolean;
+    getPlaceholder(index: number): string;
+}
+export declare const PostgreSQLAdapter: Readonly<{
+    create(config: DatabaseConfig): IDatabaseAdapter;
+}>;
+export default PostgreSQLAdapter;

package/dist/index.js

@@ -0,0 +1,123 @@
+import { ErrorFactory, FeatureFlags, Logger, QueryBuilder } from '@zintrust/core';
+function isMissingEsmPackage(error, packageName) {
+    if (error === null || typeof error !== 'object')
+        return false;
+    const maybe = error;
+    if (maybe.code === 'ERR_MODULE_NOT_FOUND') {
+        return typeof maybe.message === 'string' && maybe.message.includes(packageName);
+    }
+    if (typeof maybe.message === 'string') {
+        return (maybe.message.includes(`Cannot find package '${packageName}'`) ||
+            maybe.message.includes(`Cannot find module '${packageName}'`));
+    }
+    return false;
+}
+export const PostgreSQLAdapter = Object.freeze({
+    create(config) {
+        return createPostgresAdapter(config);
+    },
+});
+function getConnectionParams(config) {
+    return {
+        host: config.host ?? 'localhost',
+        port: config.port ?? 5432,
+        database: config.database ?? 'postgres',
+        user: config.username ?? 'postgres',
+        password: config.password ?? '',
+    };
+}
+async function loadPgPoolCtor() {
+    // Dynamic import keeps this package usable even if pg is missing.
+    return (await import('pg'));
+}
+function ensurePool(state) {
+    if (!state.connected || state.pool === undefined) {
+        throw ErrorFactory.createConnectionError('Database not connected');
+    }
+    return state.pool;
+}
+async function connect(state, config) {
+    if (state.connected)
+        return;
+    try {
+        const { Pool } = await loadPgPoolCtor();
+        const { host, port, database, user, password } = getConnectionParams(config);
+        state.pool = new Pool({ host, port, database, user, password });
+        await state.pool.query('SELECT 1');
+        state.connected = true;
+        Logger.info(`✓ PostgreSQL connected (${host}:${port})`);
+    }
+    catch (error) {
+        if (isMissingEsmPackage(error, 'pg')) {
+            throw ErrorFactory.createConfigError("PostgreSQL adapter requires the 'pg' package (run `zin add db:postgres` or `npm install pg`).");
+        }
+        throw ErrorFactory.createTryCatchError('Failed to connect to PostgreSQL', error);
+    }
+}
+async function disconnect(state) {
+    if (!state.connected)
+        return;
+    const current = state.pool;
+    state.pool = undefined;
+    state.connected = false;
+    if (current !== undefined) {
+        await current.end();
+    }
+    Logger.info('✓ PostgreSQL disconnected');
+}
+async function query(state, sql, parameters) {
+    const current = ensurePool(state);
+    try {
+        const result = await current.query(sql, parameters);
+        return {
+            rows: (result.rows ?? []),
+            rowCount: result.rowCount ?? result.rows?.length ?? 0,
+        };
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('PostgreSQL query failed', error);
+    }
+}
+async function transaction(state, adapter, callback) {
+    if (!state.connected)
+        throw ErrorFactory.createConnectionError('Database not connected');
+    try {
+        await adapter.query('BEGIN', []);
+        const result = await callback(adapter);
+        await adapter.query('COMMIT', []);
+        return result;
+    }
+    catch (error) {
+        await adapter.query('ROLLBACK', []);
+        throw ErrorFactory.createTryCatchError('PostgreSQL transaction failed', error);
+    }
+}
+async function rawQuery(adapter, sql, parameters) {
+    if (!FeatureFlags.isRawQueryEnabled()) {
+        throw ErrorFactory.createConfigError('Raw SQL queries are disabled. Set USE_RAW_QRY=true environment variable to enable.');
+    }
+    const result = await adapter.query(sql, parameters ?? []);
+    return result.rows;
+}
+function createPostgresAdapter(config) {
+    const state = { connected: false, pool: undefined };
+    const adapter = {
+        connect: async () => connect(state, config),
+        disconnect: async () => disconnect(state),
+        query: async (sql, parameters) => query(state, sql, parameters),
+        queryOne: async (sql, parameters) => {
+            const result = await adapter.query(sql, parameters);
+            return result.rows[0] ?? null;
+        },
+        ping: async () => {
+            await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
+        },
+        transaction: async (callback) => transaction(state, adapter, callback),
+        rawQuery: async (sql, parameters) => rawQuery(adapter, sql, parameters),
+        getType: () => 'postgresql',
+        isConnected: () => state.connected,
+        getPlaceholder: (index) => `$${index}`,
+    };
+    return adapter;
+}
+export default PostgreSQLAdapter;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type Registry = {
+    register: (driver: string, factory: (cfg: unknown) => unknown) => void;
+};
+export declare function registerPostgresAdapter(registry: Registry): void;
+export {};

package/dist/register.js

@@ -0,0 +1,8 @@
+import { PostgreSQLAdapter } from './index.js';
+export function registerPostgresAdapter(registry) {
+    registry.register('postgresql', (config) => PostgreSQLAdapter.create(config));
+}
+const core = (await import('@zintrust/core'));
+if (core.DatabaseAdapterRegistry !== undefined) {
+    registerPostgresAdapter(core.DatabaseAdapterRegistry);
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@zintrust/db-postgres",
+  "version": "0.1.8",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "pg": "^8.16.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}