@xfcfam/xf-sql-postgres 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Israel Sanjurjo and the XF contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# `@xfcfam/xf-sql-postgres`
+
+PostgreSQL dialect adapter for [`@xfcfam/xf-sql`](https://www.npmjs.com/package/@xfcfam/xf-sql).
+Encapsulates `kysely`'s `PostgresDialect` over the [`pg`](https://node-postgres.com)
+driver and ships the SQLSTATE → typed-Exception translation so the
+Business Layer never sees `pg` errors.
+
+Peer dependencies: [`@xfcfam/xf`](https://www.npmjs.com/package/@xfcfam/xf),
+[`@xfcfam/xf-sql`](https://www.npmjs.com/package/@xfcfam/xf-sql),
+[`kysely`](https://kysely.dev).
+Runtime dependency: `pg`.
+
+## Install
+
+```bash
+pnpm add @xfcfam/xf @xfcfam/xf-sql @xfcfam/xf-sql-postgres kysely pg
+```
+
+## What ships here
+
+| Export | Role |
+|---|---|
+| `PostgresDatabaseRepository<Schema>` | Ready-to-use Access Layer Generalization. Extends `TransactionalDatabaseRepository` from `@xfcfam/xf-sql`. Wires `PostgresDialect` + `pg.Pool`. Overrides `translateError` with the SQLSTATE mapping. |
+| `PostgresOptions` | Constructor options: `connectionString`, optional `pool: pg.PoolConfig`. |
+| `PostgresErrorUtils` | Static utility class. `translate(err)` maps any `pg`/Kysely error to the corresponding `@xfcfam/xf-sql` Exception. Constants for the SQLSTATEs it recognises (`SQLSTATE_UNIQUE_VIOLATION`, …). |
+
+## Quick usage
+
+```typescript
+import { PostgresDatabaseRepository } from '@xfcfam/xf-sql-postgres'
+import { UniqueViolationException, ConnectionException } from '@xfcfam/xf-sql'
+
+interface Schema {
+  users: {
+    id: number
+    name: string
+    email: string
+    created_at: Date
+  }
+}
+
+export class UsersDb extends PostgresDatabaseRepository<Schema> {
+  constructor() {
+    super({
+      connectionString: process.env.DATABASE_URL!,
+      pool: { max: 10, idleTimeoutMillis: 30_000 },
+    })
+  }
+  async init()      { await super.init() }
+  async terminate() { await super.terminate() }
+
+  getUser(id: number) {
+    return this.exec(() =>
+      this.db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirstOrThrow()
+    )
+  }
+
+  async createUser(input: { name: string; email: string }) {
+    try {
+      return await this.exec(() =>
+        this.db
+          .insertInto('users')
+          .values({ ...input, created_at: new Date() })
+          .returningAll()
+          .executeTakeFirstOrThrow()
+      )
+    } catch (err) {
+      if (err instanceof UniqueViolationException && err.column === 'email') {
+        throw new DomainError('Email already registered')
+      }
+      throw err
+    }
+  }
+
+  async transferOrder(orderId: number, newOwner: number) {
+    // transaction() commits on success, rolls back on throw.
+    return this.transaction(async (trx) => {
+      await trx.updateTable('orders').set({ owner_id: newOwner }).where('id', '=', orderId).execute()
+      await trx.insertInto('order_audit').values({ order_id: orderId, action: 'transfer' }).execute()
+    })
+  }
+}
+```
+
+## SQLSTATE → Exception mapping
+
+The default `translateError` covers the most common PostgreSQL error
+codes. Anything not in this table is returned unchanged (so
+implementer-specific exceptions still propagate cleanly).
+
+| SQLSTATE | Postgres condition | Translates to |
+|---|---|---|
+| `23505` | unique_violation | `UniqueViolationException` |
+| `23503` | foreign_key_violation | `ForeignKeyViolationException` |
+| `23514` | check_violation | `CheckViolationException` |
+| `23502` | not_null_violation | `NotNullViolationException` |
+| `40P01` | deadlock_detected | `DeadlockException` |
+| `ECONNREFUSED`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNRESET`, `EHOSTUNREACH`, `EAI_AGAIN` | transport-level (not a SQLSTATE) | `ConnectionException` |
+| anything else | — | passed through untouched |
+
+When the driver attaches `table`, `column`, `constraint` to the
+error, these are forwarded to the Exception so the Business Layer can
+branch on them without parsing strings.
+
+## Documentation
+
+- Specification — [xfcfam.org](https://xfcfam.org)
+- Kysely docs — [kysely.dev](https://kysely.dev)
+- Postgres SQLSTATE codes — [postgresql.org docs](https://www.postgresql.org/docs/current/errcodes-appendix.html)
+- Source — [github.com/xfcfam/lib-npm](https://github.com/xfcfam/lib-npm)
+
+## License
+
+MIT.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@xfcfam/xf-sql-postgres` — PostgreSQL dialect adapter for
+ * `@xfcfam/xf-sql`.
+ *
+ * Encapsulates `kysely`'s `PostgresDialect` over the `pg` driver
+ * behind a single XF-canonical class (`PostgresDatabaseRepository`)
+ * and ships the SQLSTATE → `@xfcfam/xf-sql` Exception translation
+ * (`PostgresErrorUtils`).
+ *
+ * Peer dependencies: `@xfcfam/xf`, `@xfcfam/xf-sql`, `kysely`.
+ * Runtime dependency: `pg`.
+ */
+export { PostgresDatabaseRepository } from './src/repository/general/PostgresDatabaseRepository.js';
+export type { PostgresOptions } from './src/repository/general/PostgresDatabaseRepository.js';
+export { PostgresErrorUtils } from './src/repository/utils/PostgresErrorUtils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,wDAAwD,CAAA;AACnG,YAAY,EAAE,eAAe,EAAE,MAAM,wDAAwD,CAAA;AAG7F,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@xfcfam/xf-sql-postgres` — PostgreSQL dialect adapter for
+ * `@xfcfam/xf-sql`.
+ *
+ * Encapsulates `kysely`'s `PostgresDialect` over the `pg` driver
+ * behind a single XF-canonical class (`PostgresDatabaseRepository`)
+ * and ships the SQLSTATE → `@xfcfam/xf-sql` Exception translation
+ * (`PostgresErrorUtils`).
+ *
+ * Peer dependencies: `@xfcfam/xf`, `@xfcfam/xf-sql`, `kysely`.
+ * Runtime dependency: `pg`.
+ */
+// ── Access — base ─────────────────────────────────────────
+export { PostgresDatabaseRepository } from './src/repository/general/PostgresDatabaseRepository.js';
+// ── Access — utils ────────────────────────────────────────
+export { PostgresErrorUtils } from './src/repository/utils/PostgresErrorUtils.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,6DAA6D;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,wDAAwD,CAAA;AAGnG,6DAA6D;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAA"}

package/dist/src/api/A.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Interaction Layer Injection — placeholder.
+ *
+ * `A` is the canonical injection of the Interaction Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `A` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `A` from their own artefact.
+ */
+export declare class A {
+    private constructor();
+    static init(): Promise<void>;
+    static terminate(): Promise<void>;
+}
+//# sourceMappingURL=A.d.ts.map

package/dist/src/api/A.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"A.d.ts","sourceRoot":"","sources":["../../../src/api/A.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,CAAC;IACZ,OAAO;WACM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WACrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CACxC"}

package/dist/src/api/A.js

@@ -0,0 +1,17 @@
+/**
+ * Interaction Layer Injection — placeholder.
+ *
+ * `A` is the canonical injection of the Interaction Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `A` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `A` from their own artefact.
+ */
+export class A {
+    constructor() { }
+    static async init() { }
+    static async terminate() { }
+}
+//# sourceMappingURL=A.js.map

package/dist/src/api/A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"A.js","sourceRoot":"","sources":["../../../src/api/A.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,CAAC;IACZ,gBAAuB,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,IAAI,KAAmB,CAAC;IACrC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAmB,CAAC;CAC3C"}

package/dist/src/business/B.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Business Layer Injection — placeholder.
+ *
+ * `B` is the canonical injection of the Business Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `B` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `B` from their own artefact.
+ */
+export declare class B {
+    private constructor();
+    static init(): Promise<void>;
+    static terminate(): Promise<void>;
+}
+//# sourceMappingURL=B.d.ts.map

package/dist/src/business/B.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"B.d.ts","sourceRoot":"","sources":["../../../src/business/B.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,CAAC;IACZ,OAAO;WACM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WACrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CACxC"}

package/dist/src/business/B.js

@@ -0,0 +1,17 @@
+/**
+ * Business Layer Injection — placeholder.
+ *
+ * `B` is the canonical injection of the Business Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `B` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `B` from their own artefact.
+ */
+export class B {
+    constructor() { }
+    static async init() { }
+    static async terminate() { }
+}
+//# sourceMappingURL=B.js.map

package/dist/src/business/B.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"B.js","sourceRoot":"","sources":["../../../src/business/B.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,CAAC;IACZ,gBAAuB,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,IAAI,KAAmB,CAAC;IACrC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAmB,CAAC;CAC3C"}

package/dist/src/repository/R.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Access Layer Injection — placeholder.
+ *
+ * `R` is the canonical injection of the Access Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `R` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `R` from their own artefact.
+ */
+export declare class R {
+    private constructor();
+    static init(): Promise<void>;
+    static terminate(): Promise<void>;
+}
+//# sourceMappingURL=R.d.ts.map

package/dist/src/repository/R.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"R.d.ts","sourceRoot":"","sources":["../../../src/repository/R.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,CAAC;IACZ,OAAO;WACM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WACrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CACxC"}

package/dist/src/repository/R.js

@@ -0,0 +1,17 @@
+/**
+ * Access Layer Injection — placeholder.
+ *
+ * `R` is the canonical injection of the Access Layer. `@xfcfam/xf-sql-postgres`
+ * is a library that contributes Generalizations and Transfer objects;
+ * it does not own any Logical of this layer, so its own `R` declares
+ * no static slots. The class is kept structurally complete (private
+ * constructor + empty `init` / `terminate`) so the artefact passes XF
+ * validation. It is NOT exported from the package — consumers import
+ * `R` from their own artefact.
+ */
+export class R {
+    constructor() { }
+    static async init() { }
+    static async terminate() { }
+}
+//# sourceMappingURL=R.js.map

package/dist/src/repository/R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"R.js","sourceRoot":"","sources":["../../../src/repository/R.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,CAAC;IACZ,gBAAuB,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,IAAI,KAAmB,CAAC;IACrC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAmB,CAAC;CAC3C"}

package/dist/src/repository/base/PostgresDatabaseRepository.d.ts

@@ -0,0 +1,91 @@
+import { TransactionalDatabaseRepository } from '@xfarch/xf-sql';
+import { type PoolConfig } from 'pg';
+/**
+ * Configuration accepted by {@link PostgresDatabaseRepository}'s
+ * constructor.
+ *
+ * Either provide a `connectionString` (the simplest path), a full
+ * `pg.PoolConfig`, or both — they are merged with the connection
+ * string taking precedence for connection coordinates.
+ */
+export interface PostgresOptions {
+    /** Postgres connection string (`postgres://user:pass@host:port/db?…`). */
+    connectionString?: string;
+    /** Extra `pg.PoolConfig` fields: `max`, `idleTimeoutMillis`, `ssl`, … */
+    pool?: PoolConfig;
+}
+/**
+ * Ready-to-use Generalization for the Access Layer when the backing
+ * store is **PostgreSQL**.
+ *
+ * Wraps `kysely`'s `PostgresDialect` over the `pg` driver behind a
+ * single XF-canonical class. The implementer's concrete Logical
+ * extends this and exposes domain-meaningful methods that compose
+ * queries against `this.db`. Transactions via `this.transaction(...)`,
+ * one-shot error translation via `this.exec(...)`.
+ *
+ * The default `translateError` maps Postgres SQLSTATE codes to the
+ * typed Exceptions exported from `@xfarch/xf-sql`
+ * (`UniqueViolationException`, `ForeignKeyViolationException`,
+ * `CheckViolationException`, `NotNullViolationException`,
+ * `DeadlockException`) and transport-level errors (`ECONNREFUSED`,
+ * `ETIMEDOUT`, …) to `ConnectionException`. The implementer's
+ * Business Layer never sees `pg` types.
+ *
+ * @typeParam Schema  Implementer-defined TypeScript interface mapping
+ *                    table names to their column shapes.
+ *
+ * @example
+ * ```ts
+ * import { PostgresDatabaseRepository } from '@xfarch/xf-sql-postgres'
+ * import { UniqueViolationException } from '@xfarch/xf-sql'
+ *
+ * interface Schema {
+ *   users: { id: number; name: string; email: string; created_at: Date }
+ * }
+ *
+ * export class UsersDb extends PostgresDatabaseRepository<Schema> {
+ *   constructor() {
+ *     super({
+ *       connectionString: process.env.DATABASE_URL!,
+ *       pool: { max: 10, idleTimeoutMillis: 30_000 },
+ *     })
+ *   }
+ *   async init()      { await super.init() }       // ← required
+ *   async terminate() { await super.terminate() }  // ← required
+ *
+ *   getUser(id: number) {
+ *     return this.exec(() =>
+ *       this.db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirstOrThrow()
+ *     )
+ *   }
+ *
+ *   async createUser(input: { name: string; email: string }) {
+ *     try {
+ *       return await this.exec(() =>
+ *         this.db.insertInto('users').values({ ...input, created_at: new Date() }).returningAll().executeTakeFirstOrThrow()
+ *       )
+ *     } catch (err) {
+ *       if (err instanceof UniqueViolationException && err.column === 'email') {
+ *         throw new DomainError('Email already registered')
+ *       }
+ *       throw err
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class PostgresDatabaseRepository<Schema = unknown> extends TransactionalDatabaseRepository<Schema> {
+    constructor(options: PostgresOptions);
+    /**
+     * Translate `pg` / Kysely driver errors into the typed Exceptions
+     * exported from `@xfarch/xf-sql`. Delegates to
+     * {@link PostgresErrorUtils.translate}.
+     *
+     * Subclasses may override to layer additional mappings on top, but
+     * should `return super.translateError(err)` for unrecognised
+     * errors so the base policy still applies.
+     */
+    protected translateError(err: unknown): unknown;
+}
+//# sourceMappingURL=PostgresDatabaseRepository.d.ts.map

package/dist/src/repository/base/PostgresDatabaseRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresDatabaseRepository.d.ts","sourceRoot":"","sources":["../../../../src/repository/base/PostgresDatabaseRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,IAAI,CAAA;AAG1C;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,yEAAyE;IACzE,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,8BAAsB,0BAA0B,CAAC,MAAM,GAAG,OAAO,CAC/D,SAAQ,+BAA+B,CAAC,MAAM,CAAC;gBAEnC,OAAO,EAAE,eAAe;IASpC;;;;;;;;OAQG;cACgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;CAGzD"}

package/dist/src/repository/base/PostgresDatabaseRepository.js

@@ -0,0 +1,88 @@
+import { TransactionalDatabaseRepository } from '@xfarch/xf-sql';
+import { PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+import { PostgresErrorUtils } from '../utils/PostgresErrorUtils.js';
+/**
+ * Ready-to-use Generalization for the Access Layer when the backing
+ * store is **PostgreSQL**.
+ *
+ * Wraps `kysely`'s `PostgresDialect` over the `pg` driver behind a
+ * single XF-canonical class. The implementer's concrete Logical
+ * extends this and exposes domain-meaningful methods that compose
+ * queries against `this.db`. Transactions via `this.transaction(...)`,
+ * one-shot error translation via `this.exec(...)`.
+ *
+ * The default `translateError` maps Postgres SQLSTATE codes to the
+ * typed Exceptions exported from `@xfarch/xf-sql`
+ * (`UniqueViolationException`, `ForeignKeyViolationException`,
+ * `CheckViolationException`, `NotNullViolationException`,
+ * `DeadlockException`) and transport-level errors (`ECONNREFUSED`,
+ * `ETIMEDOUT`, …) to `ConnectionException`. The implementer's
+ * Business Layer never sees `pg` types.
+ *
+ * @typeParam Schema  Implementer-defined TypeScript interface mapping
+ *                    table names to their column shapes.
+ *
+ * @example
+ * ```ts
+ * import { PostgresDatabaseRepository } from '@xfarch/xf-sql-postgres'
+ * import { UniqueViolationException } from '@xfarch/xf-sql'
+ *
+ * interface Schema {
+ *   users: { id: number; name: string; email: string; created_at: Date }
+ * }
+ *
+ * export class UsersDb extends PostgresDatabaseRepository<Schema> {
+ *   constructor() {
+ *     super({
+ *       connectionString: process.env.DATABASE_URL!,
+ *       pool: { max: 10, idleTimeoutMillis: 30_000 },
+ *     })
+ *   }
+ *   async init()      { await super.init() }       // ← required
+ *   async terminate() { await super.terminate() }  // ← required
+ *
+ *   getUser(id: number) {
+ *     return this.exec(() =>
+ *       this.db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirstOrThrow()
+ *     )
+ *   }
+ *
+ *   async createUser(input: { name: string; email: string }) {
+ *     try {
+ *       return await this.exec(() =>
+ *         this.db.insertInto('users').values({ ...input, created_at: new Date() }).returningAll().executeTakeFirstOrThrow()
+ *       )
+ *     } catch (err) {
+ *       if (err instanceof UniqueViolationException && err.column === 'email') {
+ *         throw new DomainError('Email already registered')
+ *       }
+ *       throw err
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class PostgresDatabaseRepository extends TransactionalDatabaseRepository {
+    constructor(options) {
+        const poolConfig = { ...options.pool };
+        if (options.connectionString !== undefined) {
+            poolConfig.connectionString = options.connectionString;
+        }
+        const pool = new Pool(poolConfig);
+        super({ dialect: new PostgresDialect({ pool }) });
+    }
+    /**
+     * Translate `pg` / Kysely driver errors into the typed Exceptions
+     * exported from `@xfarch/xf-sql`. Delegates to
+     * {@link PostgresErrorUtils.translate}.
+     *
+     * Subclasses may override to layer additional mappings on top, but
+     * should `return super.translateError(err)` for unrecognised
+     * errors so the base policy still applies.
+     */
+    translateError(err) {
+        return PostgresErrorUtils.translate(err);
+    }
+}
+//# sourceMappingURL=PostgresDatabaseRepository.js.map

package/dist/src/repository/base/PostgresDatabaseRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresDatabaseRepository.js","sourceRoot":"","sources":["../../../../src/repository/base/PostgresDatabaseRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,IAAI,EAAmB,MAAM,IAAI,CAAA;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAiBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,OAAgB,0BACpB,SAAQ,+BAAuC;IAE/C,YAAY,OAAwB;QAClC,MAAM,UAAU,GAAe,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAA;QAClD,IAAI,OAAO,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YAC3C,UAAU,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAA;QACxD,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAA;QACjC,KAAK,CAAC,EAAE,OAAO,EAAE,IAAI,eAAe,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAA;IACnD,CAAC;IAED;;;;;;;;OAQG;IACgB,cAAc,CAAC,GAAY;QAC5C,OAAO,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;IAC1C,CAAC;CACF"}

package/dist/src/repository/general/PostgresDatabaseRepository.d.ts

@@ -0,0 +1,91 @@
+import { TransactionalDatabaseRepository } from '@xfcfam/xf-sql';
+import { type PoolConfig } from 'pg';
+/**
+ * Configuration accepted by {@link PostgresDatabaseRepository}'s
+ * constructor.
+ *
+ * Either provide a `connectionString` (the simplest path), a full
+ * `pg.PoolConfig`, or both — they are merged with the connection
+ * string taking precedence for connection coordinates.
+ */
+export interface PostgresOptions {
+    /** Postgres connection string (`postgres://user:pass@host:port/db?…`). */
+    connectionString?: string;
+    /** Extra `pg.PoolConfig` fields: `max`, `idleTimeoutMillis`, `ssl`, … */
+    pool?: PoolConfig;
+}
+/**
+ * Ready-to-use Generalization for the Access Layer when the backing
+ * store is **PostgreSQL**.
+ *
+ * Wraps `kysely`'s `PostgresDialect` over the `pg` driver behind a
+ * single XF-canonical class. The implementer's concrete Logical
+ * extends this and exposes domain-meaningful methods that compose
+ * queries against `this.db`. Transactions via `this.transaction(...)`,
+ * one-shot error translation via `this.exec(...)`.
+ *
+ * The default `translateError` maps Postgres SQLSTATE codes to the
+ * typed Exceptions exported from `@xfcfam/xf-sql`
+ * (`UniqueViolationException`, `ForeignKeyViolationException`,
+ * `CheckViolationException`, `NotNullViolationException`,
+ * `DeadlockException`) and transport-level errors (`ECONNREFUSED`,
+ * `ETIMEDOUT`, …) to `ConnectionException`. The implementer's
+ * Business Layer never sees `pg` types.
+ *
+ * @typeParam Schema  Implementer-defined TypeScript interface mapping
+ *                    table names to their column shapes.
+ *
+ * @example
+ * ```ts
+ * import { PostgresDatabaseRepository } from '@xfcfam/xf-sql-postgres'
+ * import { UniqueViolationException } from '@xfcfam/xf-sql'
+ *
+ * interface Schema {
+ *   users: { id: number; name: string; email: string; created_at: Date }
+ * }
+ *
+ * export class UsersDb extends PostgresDatabaseRepository<Schema> {
+ *   constructor() {
+ *     super({
+ *       connectionString: process.env.DATABASE_URL!,
+ *       pool: { max: 10, idleTimeoutMillis: 30_000 },
+ *     })
+ *   }
+ *   async init()      { await super.init() }       // ← required
+ *   async terminate() { await super.terminate() }  // ← required
+ *
+ *   getUser(id: number) {
+ *     return this.exec(() =>
+ *       this.db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirstOrThrow()
+ *     )
+ *   }
+ *
+ *   async createUser(input: { name: string; email: string }) {
+ *     try {
+ *       return await this.exec(() =>
+ *         this.db.insertInto('users').values({ ...input, created_at: new Date() }).returningAll().executeTakeFirstOrThrow()
+ *       )
+ *     } catch (err) {
+ *       if (err instanceof UniqueViolationException && err.column === 'email') {
+ *         throw new DomainError('Email already registered')
+ *       }
+ *       throw err
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class PostgresDatabaseRepository<Schema = unknown> extends TransactionalDatabaseRepository<Schema> {
+    constructor(options: PostgresOptions);
+    /**
+     * Translate `pg` / Kysely driver errors into the typed Exceptions
+     * exported from `@xfcfam/xf-sql`. Delegates to
+     * {@link PostgresErrorUtils.translate}.
+     *
+     * Subclasses may override to layer additional mappings on top, but
+     * should `return super.translateError(err)` for unrecognised
+     * errors so the base policy still applies.
+     */
+    protected translateError(err: unknown): unknown;
+}
+//# sourceMappingURL=PostgresDatabaseRepository.d.ts.map

package/dist/src/repository/general/PostgresDatabaseRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresDatabaseRepository.d.ts","sourceRoot":"","sources":["../../../../src/repository/general/PostgresDatabaseRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,IAAI,CAAA;AAG1C;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,yEAAyE;IACzE,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,8BAAsB,0BAA0B,CAAC,MAAM,GAAG,OAAO,CAC/D,SAAQ,+BAA+B,CAAC,MAAM,CAAC;gBAEnC,OAAO,EAAE,eAAe;IASpC;;;;;;;;OAQG;cACgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;CAGzD"}

package/dist/src/repository/general/PostgresDatabaseRepository.js

@@ -0,0 +1,88 @@
+import { TransactionalDatabaseRepository } from '@xfcfam/xf-sql';
+import { PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+import { PostgresErrorUtils } from '../utils/PostgresErrorUtils.js';
+/**
+ * Ready-to-use Generalization for the Access Layer when the backing
+ * store is **PostgreSQL**.
+ *
+ * Wraps `kysely`'s `PostgresDialect` over the `pg` driver behind a
+ * single XF-canonical class. The implementer's concrete Logical
+ * extends this and exposes domain-meaningful methods that compose
+ * queries against `this.db`. Transactions via `this.transaction(...)`,
+ * one-shot error translation via `this.exec(...)`.
+ *
+ * The default `translateError` maps Postgres SQLSTATE codes to the
+ * typed Exceptions exported from `@xfcfam/xf-sql`
+ * (`UniqueViolationException`, `ForeignKeyViolationException`,
+ * `CheckViolationException`, `NotNullViolationException`,
+ * `DeadlockException`) and transport-level errors (`ECONNREFUSED`,
+ * `ETIMEDOUT`, …) to `ConnectionException`. The implementer's
+ * Business Layer never sees `pg` types.
+ *
+ * @typeParam Schema  Implementer-defined TypeScript interface mapping
+ *                    table names to their column shapes.
+ *
+ * @example
+ * ```ts
+ * import { PostgresDatabaseRepository } from '@xfcfam/xf-sql-postgres'
+ * import { UniqueViolationException } from '@xfcfam/xf-sql'
+ *
+ * interface Schema {
+ *   users: { id: number; name: string; email: string; created_at: Date }
+ * }
+ *
+ * export class UsersDb extends PostgresDatabaseRepository<Schema> {
+ *   constructor() {
+ *     super({
+ *       connectionString: process.env.DATABASE_URL!,
+ *       pool: { max: 10, idleTimeoutMillis: 30_000 },
+ *     })
+ *   }
+ *   async init()      { await super.init() }       // ← required
+ *   async terminate() { await super.terminate() }  // ← required
+ *
+ *   getUser(id: number) {
+ *     return this.exec(() =>
+ *       this.db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirstOrThrow()
+ *     )
+ *   }
+ *
+ *   async createUser(input: { name: string; email: string }) {
+ *     try {
+ *       return await this.exec(() =>
+ *         this.db.insertInto('users').values({ ...input, created_at: new Date() }).returningAll().executeTakeFirstOrThrow()
+ *       )
+ *     } catch (err) {
+ *       if (err instanceof UniqueViolationException && err.column === 'email') {
+ *         throw new DomainError('Email already registered')
+ *       }
+ *       throw err
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class PostgresDatabaseRepository extends TransactionalDatabaseRepository {
+    constructor(options) {
+        const poolConfig = { ...options.pool };
+        if (options.connectionString !== undefined) {
+            poolConfig.connectionString = options.connectionString;
+        }
+        const pool = new Pool(poolConfig);
+        super({ dialect: new PostgresDialect({ pool }) });
+    }
+    /**
+     * Translate `pg` / Kysely driver errors into the typed Exceptions
+     * exported from `@xfcfam/xf-sql`. Delegates to
+     * {@link PostgresErrorUtils.translate}.
+     *
+     * Subclasses may override to layer additional mappings on top, but
+     * should `return super.translateError(err)` for unrecognised
+     * errors so the base policy still applies.
+     */
+    translateError(err) {
+        return PostgresErrorUtils.translate(err);
+    }
+}
+//# sourceMappingURL=PostgresDatabaseRepository.js.map

package/dist/src/repository/general/PostgresDatabaseRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresDatabaseRepository.js","sourceRoot":"","sources":["../../../../src/repository/general/PostgresDatabaseRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,IAAI,EAAmB,MAAM,IAAI,CAAA;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAiBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,OAAgB,0BACpB,SAAQ,+BAAuC;IAE/C,YAAY,OAAwB;QAClC,MAAM,UAAU,GAAe,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAA;QAClD,IAAI,OAAO,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YAC3C,UAAU,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAA;QACxD,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAA;QACjC,KAAK,CAAC,EAAE,OAAO,EAAE,IAAI,eAAe,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAA;IACnD,CAAC;IAED;;;;;;;;OAQG;IACgB,cAAc,CAAC,GAAY;QAC5C,OAAO,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;IAC1C,CAAC;CACF"}

package/dist/src/repository/utils/PostgresErrorUtils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Static utility component that translates Postgres / `pg` driver
+ * errors into the typed Exceptions exported from `@xfcfam/xf-sql`.
+ *
+ * The translation is based on the SQLSTATE code attached to the
+ * error by `pg` (see
+ * [Postgres docs](https://www.postgresql.org/docs/current/errcodes-appendix.html)).
+ *
+ * Non-instantiable. All members are static.
+ */
+export declare class PostgresErrorUtils {
+    private constructor();
+    /** Class 23 — integrity constraint violation: unique. */
+    static readonly SQLSTATE_UNIQUE_VIOLATION = "23505";
+    /** Class 23 — integrity constraint violation: foreign key. */
+    static readonly SQLSTATE_FOREIGN_KEY_VIOLATION = "23503";
+    /** Class 23 — integrity constraint violation: check. */
+    static readonly SQLSTATE_CHECK_VIOLATION = "23514";
+    /** Class 23 — integrity constraint violation: not null. */
+    static readonly SQLSTATE_NOT_NULL_VIOLATION = "23502";
+    /** Class 40 — transaction rollback: deadlock detected. */
+    static readonly SQLSTATE_DEADLOCK_DETECTED = "40P01";
+    /**
+     * Translate any `pg` / Kysely error to the corresponding `@xfcfam/xf-sql`
+     * Exception. Returns the input unchanged when:
+     *
+     * - The error is already a `DatabaseException` (already translated).
+     * - The error has no SQLSTATE `code` and isn't a recognised
+     *   transport-level failure.
+     *
+     * @example
+     * ```ts
+     * try {
+     *   await this.db.insertInto('users').values(input).execute()
+     * } catch (err) {
+     *   throw PostgresErrorUtils.translate(err)
+     * }
+     * ```
+     *
+     * (`PostgresDatabaseRepository` overrides `translateError` to call
+     * this automatically — you don't need to wrap manually if you
+     * extend it.)
+     */
+    static translate(err: unknown): unknown;
+    private static isErrorLike;
+    private static isTransportCode;
+}
+//# sourceMappingURL=PostgresErrorUtils.d.ts.map

package/dist/src/repository/utils/PostgresErrorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresErrorUtils.d.ts","sourceRoot":"","sources":["../../../../src/repository/utils/PostgresErrorUtils.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,qBAAa,kBAAkB;IAC7B,OAAO;IAEP,yDAAyD;IACzD,MAAM,CAAC,QAAQ,CAAC,yBAAyB,WAAe;IACxD,8DAA8D;IAC9D,MAAM,CAAC,QAAQ,CAAC,8BAA8B,WAAU;IACxD,wDAAwD;IACxD,MAAM,CAAC,QAAQ,CAAC,wBAAwB,WAAgB;IACxD,2DAA2D;IAC3D,MAAM,CAAC,QAAQ,CAAC,2BAA2B,WAAa;IACxD,0DAA0D;IAC1D,MAAM,CAAC,QAAQ,CAAC,0BAA0B,WAAc;IAExD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAkDvC,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,eAAe;CAW/B"}

package/dist/src/repository/utils/PostgresErrorUtils.js

@@ -0,0 +1,102 @@
+import { DatabaseException, ConnectionException, UniqueViolationException, ForeignKeyViolationException, CheckViolationException, NotNullViolationException, DeadlockException, } from '@xfcfam/xf-sql';
+/**
+ * Static utility component that translates Postgres / `pg` driver
+ * errors into the typed Exceptions exported from `@xfcfam/xf-sql`.
+ *
+ * The translation is based on the SQLSTATE code attached to the
+ * error by `pg` (see
+ * [Postgres docs](https://www.postgresql.org/docs/current/errcodes-appendix.html)).
+ *
+ * Non-instantiable. All members are static.
+ */
+export class PostgresErrorUtils {
+    constructor() { }
+    /** Class 23 — integrity constraint violation: unique. */
+    static SQLSTATE_UNIQUE_VIOLATION = '23505';
+    /** Class 23 — integrity constraint violation: foreign key. */
+    static SQLSTATE_FOREIGN_KEY_VIOLATION = '23503';
+    /** Class 23 — integrity constraint violation: check. */
+    static SQLSTATE_CHECK_VIOLATION = '23514';
+    /** Class 23 — integrity constraint violation: not null. */
+    static SQLSTATE_NOT_NULL_VIOLATION = '23502';
+    /** Class 40 — transaction rollback: deadlock detected. */
+    static SQLSTATE_DEADLOCK_DETECTED = '40P01';
+    /**
+     * Translate any `pg` / Kysely error to the corresponding `@xfcfam/xf-sql`
+     * Exception. Returns the input unchanged when:
+     *
+     * - The error is already a `DatabaseException` (already translated).
+     * - The error has no SQLSTATE `code` and isn't a recognised
+     *   transport-level failure.
+     *
+     * @example
+     * ```ts
+     * try {
+     *   await this.db.insertInto('users').values(input).execute()
+     * } catch (err) {
+     *   throw PostgresErrorUtils.translate(err)
+     * }
+     * ```
+     *
+     * (`PostgresDatabaseRepository` overrides `translateError` to call
+     * this automatically — you don't need to wrap manually if you
+     * extend it.)
+     */
+    static translate(err) {
+        if (err instanceof DatabaseException)
+            return err;
+        if (!PostgresErrorUtils.isErrorLike(err))
+            return err;
+        const message = err.message ?? 'Database error';
+        // Connection-level errors do not have a SQLSTATE; pg sets `code`
+        // to a Node errno like 'ECONNREFUSED' or 'ENOTFOUND'.
+        if (PostgresErrorUtils.isTransportCode(err.code)) {
+            return new ConnectionException(message, { cause: err });
+        }
+        switch (err.code) {
+            case PostgresErrorUtils.SQLSTATE_UNIQUE_VIOLATION:
+                return new UniqueViolationException(message, {
+                    ...(err.constraint !== undefined ? { constraint: err.constraint } : {}),
+                    ...(err.table !== undefined ? { table: err.table } : {}),
+                    ...(err.column !== undefined ? { column: err.column } : {}),
+                    cause: err,
+                });
+            case PostgresErrorUtils.SQLSTATE_FOREIGN_KEY_VIOLATION:
+                return new ForeignKeyViolationException(message, {
+                    ...(err.constraint !== undefined ? { constraint: err.constraint } : {}),
+                    ...(err.table !== undefined ? { table: err.table } : {}),
+                    cause: err,
+                });
+            case PostgresErrorUtils.SQLSTATE_CHECK_VIOLATION:
+                return new CheckViolationException(message, {
+                    ...(err.constraint !== undefined ? { constraint: err.constraint } : {}),
+                    ...(err.table !== undefined ? { table: err.table } : {}),
+                    cause: err,
+                });
+            case PostgresErrorUtils.SQLSTATE_NOT_NULL_VIOLATION:
+                return new NotNullViolationException(message, {
+                    ...(err.table !== undefined ? { table: err.table } : {}),
+                    ...(err.column !== undefined ? { column: err.column } : {}),
+                    cause: err,
+                });
+            case PostgresErrorUtils.SQLSTATE_DEADLOCK_DETECTED:
+                return new DeadlockException(message, { cause: err });
+            default:
+                return err;
+        }
+    }
+    static isErrorLike(err) {
+        return typeof err === 'object' && err !== null;
+    }
+    static isTransportCode(code) {
+        if (code === undefined)
+            return false;
+        return (code === 'ECONNREFUSED' ||
+            code === 'ENOTFOUND' ||
+            code === 'ETIMEDOUT' ||
+            code === 'ECONNRESET' ||
+            code === 'EHOSTUNREACH' ||
+            code === 'EAI_AGAIN');
+    }
+}
+//# sourceMappingURL=PostgresErrorUtils.js.map

package/dist/src/repository/utils/PostgresErrorUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresErrorUtils.js","sourceRoot":"","sources":["../../../../src/repository/utils/PostgresErrorUtils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@xfcfam/xf-sql-postgres",
+  "version": "0.1.0",
+  "description": "PostgreSQL dialect adapter for @xfcfam/xf-sql. Encapsulates kysely's PostgresDialect and the `pg` driver. Translates Postgres SQLSTATE codes into the typed Exceptions of @xfcfam/xf-sql.",
+  "author": "XF Contributors",
+  "license": "MIT",
+  "homepage": "https://xfcfam.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xfcfam/lib-npm",
+    "directory": "packages/xf-sql-postgres"
+  },
+  "keywords": [
+    "xf",
+    "cfam",
+    "sql",
+    "postgres",
+    "postgresql",
+    "kysely",
+    "pg"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@xfcfam/xf-sql": "^0.1.0",
+    "@xfcfam/xf": "^0.2.0"
+  },
+  "dependencies": {
+    "pg": "^8.11.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0",
+    "kysely": "^0.27.0",
+    "@types/pg": "^8.11.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}