@mountsqli/pg 0.1.0

package/dist/chunk-MU3FLR2D.js

@@ -0,0 +1,326 @@
+// src/pg-core/dialect.ts
+import { Dialect, SQL } from "@mountsqli/core";
+var PgDialect = class extends Dialect {
+  dialect = "pg";
+  escapeName(name) {
+    return `"${name}"`;
+  }
+  escapeParam(index) {
+    return `$${index}`;
+  }
+  // ---- SELECT ------------------------------------------------------------
+  buildSelectQuery(config) {
+    const parts = ["SELECT"];
+    if (config.distinct) parts.push("DISTINCT");
+    if (config.columns.length > 0) {
+      const colSqls = config.columns.map((col) => {
+        const tableName2 = col._.tableName || config.table?.[/* @__PURE__ */ Symbol.for("name")];
+        if (tableName2) {
+          return `${this.escapeName(tableName2)}.${this.escapeName(col.name)}`;
+        }
+        return this.escapeName(col.name);
+      });
+      parts.push(colSqls.join(", "));
+    } else {
+      parts.push("*");
+    }
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    if (schema) {
+      parts.push(`FROM ${this.escapeName(schema)}.${this.escapeName(tableName)}`);
+    } else {
+      parts.push(`FROM ${this.escapeName(tableName)}`);
+    }
+    if (config.joins && config.joins.length > 0) {
+      for (const join of config.joins) {
+        const joinTableName = join.table?.[/* @__PURE__ */ Symbol.for("name")];
+        const joinSchema = join.table?.[/* @__PURE__ */ Symbol.for("schema")];
+        const joinFullName = joinSchema ? `${this.escapeName(joinSchema)}.${this.escapeName(joinTableName)}` : this.escapeName(joinTableName);
+        const joinType = join.type.toUpperCase();
+        const onSql = join.on.toQuery(this.getBuildQueryConfig()).sql;
+        parts.push(`${joinType} JOIN ${joinFullName} ON ${onSql}`);
+      }
+    }
+    if (config.where) {
+      const whereSql = config.where.toQuery(this.getBuildQueryConfig()).sql;
+      parts.push(`WHERE ${whereSql}`);
+    }
+    if (config.groupBy && config.groupBy.length > 0) {
+      const groupSqls = config.groupBy.map((g) => g.toQuery(this.getBuildQueryConfig()).sql);
+      parts.push(`GROUP BY ${groupSqls.join(", ")}`);
+    }
+    if (config.having) {
+      const havingSql = config.having.toQuery(this.getBuildQueryConfig()).sql;
+      parts.push(`HAVING ${havingSql}`);
+    }
+    if (config.orderBy && config.orderBy.length > 0) {
+      const orderSqls = config.orderBy.map((o) => o.toQuery(this.getBuildQueryConfig()).sql);
+      parts.push(`ORDER BY ${orderSqls.join(", ")}`);
+    }
+    if (config.limit !== void 0) {
+      parts.push(`LIMIT ${config.limit}`);
+    }
+    if (config.offset !== void 0) {
+      parts.push(`OFFSET ${config.offset}`);
+    }
+    return new SQL([parts.join(" ")]);
+  }
+  // ---- INSERT ------------------------------------------------------------
+  buildInsertQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    const columns = Object.keys(config.values[0] ?? {});
+    const validColumns = Object.keys(config.table.columns ?? {});
+    if (validColumns.length > 0) {
+      const invalidColumns = columns.filter((c) => !validColumns.includes(c));
+      if (invalidColumns.length > 0) {
+        throw new Error(`Invalid column(s): ${invalidColumns.join(", ")}`);
+      }
+    }
+    const escapedCols = columns.map((c) => this.escapeName(c));
+    const valueSets = [];
+    let paramIdx = 1;
+    for (const _row of config.values) {
+      const placeholders = columns.map(() => `$${paramIdx++}`);
+      valueSets.push(`(${placeholders.join(", ")})`);
+    }
+    const params = [];
+    for (const row of config.values) {
+      for (const col of columns) {
+        params.push(row[col]);
+      }
+    }
+    let sql = `INSERT INTO ${tableRef} (${escapedCols.join(", ")}) VALUES ${valueSets.join(", ")}`;
+    if (config.onConflict) {
+      const conflictSql = config.onConflict.toQuery(this.getBuildQueryConfig()).sql;
+      sql += ` ${conflictSql}`;
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => {
+        const tn = c._.tableName || tableName;
+        return `${this.escapeName(tn)}.${this.escapeName(c.name)}`;
+      });
+      sql += ` RETURNING ${retCols.join(", ")}`;
+    } else {
+      sql += ` RETURNING *`;
+    }
+    return new SQL([sql]);
+  }
+  // ---- UPDATE ------------------------------------------------------------
+  buildUpdateQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    const setEntries = Object.entries(config.set);
+    let paramIdx = 1;
+    const setClauses = [];
+    const params = [];
+    for (const [col, value] of setEntries) {
+      setClauses.push(`${this.escapeName(col)} = $${paramIdx++}`);
+      params.push(value);
+    }
+    let sql = `UPDATE ${tableRef} SET ${setClauses.join(", ")}`;
+    if (config.where) {
+      const whereQuery = config.where.toQuery({
+        ...this.getBuildQueryConfig(),
+        paramStartIndex: { value: paramIdx }
+      });
+      sql += ` WHERE ${whereQuery.sql}`;
+      params.push(...whereQuery.params);
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => {
+        const tn = c._.tableName || tableName;
+        return `${this.escapeName(tn)}.${this.escapeName(c.name)}`;
+      });
+      sql += ` RETURNING ${retCols.join(", ")}`;
+    } else {
+      sql += ` RETURNING *`;
+    }
+    return new SQL([sql]);
+  }
+  // ---- DELETE ------------------------------------------------------------
+  buildDeleteQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    let sql = `DELETE FROM ${tableRef}`;
+    let params = [];
+    if (config.where) {
+      const whereQuery = config.where.toQuery(this.getBuildQueryConfig());
+      sql += ` WHERE ${whereQuery.sql}`;
+      params = whereQuery.params;
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => {
+        const tn = c._.tableName || tableName;
+        return `${this.escapeName(tn)}.${this.escapeName(c.name)}`;
+      });
+      sql += ` RETURNING ${retCols.join(", ")}`;
+    }
+    return new SQL([sql]);
+  }
+  // ---- DDL ---------------------------------------------------------------
+  buildCreateTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    const ifNotExists = config.ifNotExists ? " IF NOT EXISTS" : "";
+    const columns = config.table.getSQLColumns();
+    const colDefs = Object.values(columns).map(
+      (col) => `  ${this.escapeName(col.name)} ${col.sqlType}`
+    );
+    const pkCols = [];
+    for (const [key, col] of Object.entries(config.table.columns)) {
+      if (col.isPrimaryKey) {
+        pkCols.push(this.escapeName(col.name));
+      }
+    }
+    if (pkCols.length > 0) {
+      colDefs.push(`  PRIMARY KEY (${pkCols.join(", ")})`);
+    }
+    const sql = `CREATE TABLE${ifNotExists} ${tableRef} (
+${colDefs.join(",\n")}
+)`;
+    return new SQL([sql]);
+  }
+  buildDropTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    const ifExists = config.ifExists ? " IF EXISTS" : "";
+    return new SQL([`DROP TABLE${ifExists} ${tableRef}`]);
+  }
+  buildCreateIndex(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const schema = config.table?.[/* @__PURE__ */ Symbol.for("schema")];
+    const tableRef = schema ? `${this.escapeName(schema)}.${this.escapeName(tableName)}` : this.escapeName(tableName);
+    const unique = config.unique ? "UNIQUE " : "";
+    const concurrently = config.concurrently ? " CONCURRENTLY " : " ";
+    const colNames = config.columns.map((c) => this.escapeName(c.name)).join(", ");
+    return new SQL([
+      `CREATE${concurrently}INDEX ${this.escapeName(config.name)} ON ${tableRef} (${colNames})`
+    ]);
+  }
+};
+
+// src/pg-core/session.ts
+import { Session } from "@mountsqli/core";
+var PgPreparedQuery = class {
+  _query;
+  _client;
+  _name;
+  constructor(client, query, name) {
+    this._query = query;
+    this._client = client;
+    this._name = name;
+  }
+  async execute(params) {
+    return this._client.query(this._query.sql, this._query.params);
+  }
+  async all(params) {
+    const result = await this._client.query(this._query.sql, this._query.params);
+    return result.rows;
+  }
+  async values(params) {
+    const result = await this._client.query(this._query.sql, this._query.params);
+    return result.rows.map((row) => Object.values(row));
+  }
+  getQuery() {
+    return this._query;
+  }
+};
+var PgTransaction = class _PgTransaction extends Session {
+  _client;
+  _session;
+  constructor(client, session, logger) {
+    super(logger);
+    this._client = client;
+    this._session = session;
+    this.inTransaction = true;
+  }
+  async execute(query) {
+    return this._client.query(query.sql, query.params);
+  }
+  prepare(query, name) {
+    return new PgPreparedQuery(this._client, query, name);
+  }
+  async transaction(fn, config) {
+    const savepointName = `sp_${Date.now()}`;
+    await this._client.query(`SAVEPOINT ${savepointName}`);
+    try {
+      const tx = new _PgTransaction(this._client, this._session, this.logger);
+      const result = await fn(tx);
+      await this._client.query(`RELEASE SAVEPOINT ${savepointName}`);
+      return result;
+    } catch (err) {
+      await this._client.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+      throw err;
+    }
+  }
+  async rollback() {
+    await this._client.query("ROLLBACK");
+    throw new Error("Transaction rolled back");
+  }
+  async commit() {
+    await this._client.query("COMMIT");
+  }
+  async setTransactionIsolation(level) {
+    await this._client.query(`SET TRANSACTION ISOLATION LEVEL ${level.toUpperCase()}`);
+  }
+  async dispose() {
+    this._client.release();
+  }
+};
+var PgSession = class extends Session {
+  _pool;
+  constructor(pool, logger) {
+    super(logger);
+    this._pool = pool;
+  }
+  async execute(query) {
+    return this._pool.query(query.sql, query.params);
+  }
+  prepare(query, name) {
+    return new PgPreparedQuery(this._pool, query, name);
+  }
+  async transaction(fn, config) {
+    const client = await this._pool.connect();
+    try {
+      if (config?.isolationLevel) {
+        await client.query(`BEGIN ISOLATION LEVEL ${config.isolationLevel.toUpperCase()}`);
+      } else {
+        await client.query("BEGIN");
+      }
+      this.inTransaction = true;
+      const tx = new PgTransaction(client, this, this.logger);
+      const result = await fn(tx);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async dispose() {
+    await this._pool.end();
+  }
+  /** Get pool stats */
+  getPoolStats() {
+    return {
+      totalCount: this._pool.totalCount,
+      idleCount: this._pool.idleCount,
+      waitingCount: this._pool.waitingCount
+    };
+  }
+};
+
+export {
+  PgDialect,
+  PgPreparedQuery,
+  PgTransaction,
+  PgSession
+};

package/dist/chunk-NLTVBDSL.js

@@ -0,0 +1,72 @@
+import {
+  PgSession
+} from "./chunk-MU3FLR2D.js";
+
+// src/drivers/node-postgres/driver.ts
+import { createLogger } from "@mountsqli/core";
+var NodePostgresDriver = class {
+  dialect = "pg";
+  _config;
+  _pool = null;
+  _logger;
+  constructor(config) {
+    this._config = config;
+    this._logger = typeof config.logger === "boolean" ? createLogger({ enabled: config.logger }) : config.logger ?? createLogger({ enabled: false });
+  }
+  getPool() {
+    if (this._pool) return this._pool;
+    throw new Error("Driver not connected. Call driver.connect() first.");
+  }
+  createSession() {
+    return new PgSession(this.getPool(), this._logger);
+  }
+  async connect() {
+    const pg = await import("pg");
+    const { Pool } = pg;
+    if (typeof this._config.connection === "string") {
+      this._pool = new Pool({
+        connectionString: this._config.connection,
+        max: this._config.max ?? 20,
+        idleTimeoutMillis: this._config.idleTimeoutMillis ?? 3e4
+      });
+    } else {
+      this._pool = new Pool({
+        ...this._config.connection,
+        max: this._config.max ?? this._config.connection.max ?? 20,
+        idleTimeoutMillis: this._config.idleTimeoutMillis ?? this._config.connection.idleTimeoutMillis ?? 3e4
+      });
+    }
+  }
+  async disconnect() {
+    if (this._pool) {
+      await this._pool.end();
+      this._pool = null;
+    }
+  }
+  async ping() {
+    try {
+      const pool = this.getPool();
+      await pool.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Get pool stats */
+  getPoolStats() {
+    const pool = this.getPool();
+    return {
+      totalCount: pool.totalCount,
+      idleCount: pool.idleCount,
+      waitingCount: pool.waitingCount
+    };
+  }
+};
+function createNodePostgresDriver(config) {
+  return new NodePostgresDriver(config);
+}
+
+export {
+  NodePostgresDriver,
+  createNodePostgresDriver
+};

package/dist/chunk-ZXWSBMW5.js

@@ -0,0 +1,64 @@
+import {
+  PgSession
+} from "./chunk-MU3FLR2D.js";
+
+// src/drivers/postgres-js/driver.ts
+import { createLogger } from "@mountsqli/core";
+var PostgresJsDriver = class {
+  dialect = "pg";
+  _config;
+  _client = null;
+  _logger;
+  constructor(config) {
+    this._config = config;
+    this._logger = typeof config.logger === "boolean" ? createLogger({ enabled: config.logger }) : config.logger ?? createLogger({ enabled: false });
+  }
+  getClient() {
+    if (this._client) return this._client;
+    throw new Error("Driver not connected. Call driver.connect() first.");
+  }
+  createSession() {
+    const client = this.getClient();
+    const pool = {
+      query: async (text, params) => {
+        const result = await client.unsafe(text, params ?? []);
+        return { rows: result, rowCount: result.length };
+      },
+      connect: async () => client,
+      end: async () => client.end(),
+      totalCount: 1,
+      idleCount: 1,
+      waitingCount: 0
+    };
+    return new PgSession(pool, this._logger);
+  }
+  async connect() {
+    const postgres = await import("postgres");
+    this._client = postgres.default(this._config.connection, {
+      max: this._config.max ?? 20
+    });
+  }
+  async disconnect() {
+    if (this._client) {
+      await this._client.end();
+      this._client = null;
+    }
+  }
+  async ping() {
+    try {
+      const client = this.getClient();
+      await client.unsafe("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createPostgresJsDriver(config) {
+  return new PostgresJsDriver(config);
+}
+
+export {
+  PostgresJsDriver,
+  createPostgresJsDriver
+};

package/dist/driver-BkwJwjPG.d.ts

@@ -0,0 +1,30 @@
+import { Driver, Logger } from '@mountsqli/core';
+import { P as PgSession } from './session-cHNTeFK8.js';
+
+/**
+ * postgres.js driver — wraps the `postgres` package.
+ */
+
+interface PostgresJsDriverConfig {
+    /** Connection string */
+    connection: string;
+    /** Logger */
+    logger?: Logger | boolean;
+    /** Max connections */
+    max?: number;
+}
+declare class PostgresJsDriver implements Driver {
+    readonly dialect: "pg";
+    private _config;
+    private _client;
+    private _logger;
+    constructor(config: PostgresJsDriverConfig);
+    private getClient;
+    createSession(): PgSession;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ping(): Promise<boolean>;
+}
+declare function createPostgresJsDriver(config: PostgresJsDriverConfig): PostgresJsDriver;
+
+export { type PostgresJsDriverConfig as P, PostgresJsDriver as a, createPostgresJsDriver as c };

package/dist/driver-CmcFDC6F.d.ts

@@ -0,0 +1,51 @@
+import { Driver, Logger } from '@mountsqli/core';
+import { P as PgSession } from './session-cHNTeFK8.js';
+
+/**
+ * node-postgres driver — wraps `pg` Pool/Client.
+ */
+
+interface NodePostgresDriverConfig {
+    /** Connection string or pool config */
+    connection: string | PgPoolConfig;
+    /** Logger */
+    logger?: Logger | boolean;
+    /** Pool size (default 20) */
+    max?: number;
+    /** Idle timeout in ms */
+    idleTimeoutMillis?: number;
+}
+interface PgPoolConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionString?: string;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean;
+    };
+}
+declare class NodePostgresDriver implements Driver {
+    readonly dialect: "pg";
+    private _config;
+    private _pool;
+    private _logger;
+    constructor(config: NodePostgresDriverConfig);
+    private getPool;
+    createSession(): PgSession;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ping(): Promise<boolean>;
+    /** Get pool stats */
+    getPoolStats(): {
+        totalCount: number;
+        idleCount: number;
+        waitingCount: number;
+    };
+}
+declare function createNodePostgresDriver(config: NodePostgresDriverConfig): NodePostgresDriver;
+
+export { type NodePostgresDriverConfig as N, NodePostgresDriver as a, createNodePostgresDriver as c };

package/dist/drivers/node-postgres/index.d.ts

@@ -0,0 +1,16 @@
+import { DatabaseConfig, Database } from '@mountsqli/core';
+import { N as NodePostgresDriverConfig } from '../../driver-CmcFDC6F.js';
+export { a as NodePostgresDriver } from '../../driver-CmcFDC6F.js';
+export { P as PgSession, a as PgTransaction } from '../../session-cHNTeFK8.js';
+
+/**
+ * node-postgres driver entry point.
+ *
+ * Usage:
+ *   import { mountsqli } from '@mountsqli/pg/node-postgres';
+ *   const db = mountsqli('postgresql://user:pass@localhost:5432/mydb');
+ */
+
+declare function mountsqli(connectionOrConfig: string | NodePostgresDriverConfig, options?: DatabaseConfig): Database;
+
+export { NodePostgresDriverConfig, mountsqli };

package/dist/drivers/node-postgres/index.js

@@ -0,0 +1,28 @@
+import {
+  NodePostgresDriver
+} from "../../chunk-NLTVBDSL.js";
+import {
+  PgDialect,
+  PgSession,
+  PgTransaction
+} from "../../chunk-MU3FLR2D.js";
+
+// src/drivers/node-postgres/index.ts
+import { Database, createLogger } from "@mountsqli/core";
+function mountsqli(connectionOrConfig, options) {
+  const logger = typeof options?.logger === "boolean" ? createLogger({ enabled: options.logger }) : options?.logger ?? createLogger({ enabled: false });
+  const driverConfig = typeof connectionOrConfig === "string" ? { connection: connectionOrConfig, logger } : { ...connectionOrConfig, logger };
+  const driver = new NodePostgresDriver(driverConfig);
+  const dialect = new PgDialect();
+  const session = driver.createSession();
+  return new Database(session, dialect, {
+    ...options,
+    logger
+  });
+}
+export {
+  NodePostgresDriver,
+  PgSession,
+  PgTransaction,
+  mountsqli
+};

package/dist/drivers/postgres-js/index.d.ts

@@ -0,0 +1,12 @@
+import { DatabaseConfig, Database } from '@mountsqli/core';
+import { P as PostgresJsDriverConfig } from '../../driver-BkwJwjPG.js';
+export { a as PostgresJsDriver } from '../../driver-BkwJwjPG.js';
+import '../../session-cHNTeFK8.js';
+
+/**
+ * postgres.js driver entry point.
+ */
+
+declare function mountsqli(connectionOrConfig: string | PostgresJsDriverConfig, options?: DatabaseConfig): Database;
+
+export { PostgresJsDriverConfig, mountsqli };

package/dist/drivers/postgres-js/index.js

@@ -0,0 +1,21 @@
+import {
+  PostgresJsDriver
+} from "../../chunk-ZXWSBMW5.js";
+import {
+  PgDialect
+} from "../../chunk-MU3FLR2D.js";
+
+// src/drivers/postgres-js/index.ts
+import { Database, createLogger } from "@mountsqli/core";
+function mountsqli(connectionOrConfig, options) {
+  const logger = typeof options?.logger === "boolean" ? createLogger({ enabled: options.logger }) : options?.logger ?? createLogger({ enabled: false });
+  const driverConfig = typeof connectionOrConfig === "string" ? { connection: connectionOrConfig, logger } : { ...connectionOrConfig, logger };
+  const driver = new PostgresJsDriver(driverConfig);
+  const dialect = new PgDialect();
+  const session = driver.createSession();
+  return new Database(session, dialect, { ...options, logger });
+}
+export {
+  PostgresJsDriver,
+  mountsqli
+};

package/dist/index.d.ts

@@ -0,0 +1,174 @@
+import { Table, TableConfig, Column, boolean, doublePrecision, integer, json, numeric, real, serial, text, timestamp, uuid, AnyColumn, SQL, Dialect } from '@mountsqli/core';
+export { Many, ManyConfig, One, OneConfig, TimestampConfig, bigSerial, boolean, doublePrecision, integer, json, numeric, real, relations, serial, text, timestamp, uuid } from '@mountsqli/core';
+export { b as PgPreparedQuery, P as PgSession, a as PgTransaction } from './session-cHNTeFK8.js';
+export { a as NodePostgresDriver, N as NodePostgresDriverConfig, c as createNodePostgresDriver } from './driver-CmcFDC6F.js';
+export { a as PostgresJsDriver, P as PostgresJsDriverConfig, c as createPostgresJsDriver } from './driver-BkwJwjPG.js';
+
+/**
+ * pgTable — factory function for defining PostgreSQL tables.
+ */
+
+declare class PgTable extends Table<TableConfig & {
+    dialect: 'pg';
+}> {
+}
+type PgTableColumns = Record<string, Column>;
+declare function pgTable<TColumns extends PgTableColumns>(name: string, columns: TColumns, config?: {
+    schema?: string;
+}): PgTable & {
+    columns: TColumns;
+};
+
+/**
+ * PostgreSQL-specific column types.
+ * Re-exports core columns and adds PG-only types.
+ */
+
+declare const pgInteger: typeof integer;
+declare const pgText: typeof text;
+declare const pgBoolean: typeof boolean;
+declare const pgUuid: typeof uuid;
+declare const pgTimestamp: typeof timestamp;
+declare const pgJson: typeof json;
+declare const pgSerial: typeof serial;
+declare const pgReal: typeof real;
+declare const pgDoublePrecision: typeof doublePrecision;
+declare const pgNumeric: typeof numeric;
+
+/**
+ * Index builder — define indexes on PG tables.
+ */
+
+interface PgIndexConfig {
+    name: string;
+    table: Table;
+    columns: AnyColumn[];
+    unique?: boolean;
+    concurrently?: boolean;
+    where?: string;
+}
+declare function pgIndex(name: string): {
+    on(table: Table): {
+        columns(...columns: AnyColumn[]): {
+            unique(): PgIndexConfig;
+            concurrently(): PgIndexConfig;
+            where(condition: string): PgIndexConfig;
+            build(): PgIndexConfig;
+        };
+    };
+};
+declare function pgUniqueIndex(name: string): {
+    on(table: Table): {
+        columns(...columns: AnyColumn[]): {
+            unique(): PgIndexConfig;
+            concurrently(): PgIndexConfig;
+            where(condition: string): PgIndexConfig;
+            build(): PgIndexConfig;
+        };
+    };
+};
+
+/**
+ * Foreign key builder — define FK constraints on PG tables.
+ */
+
+interface PgForeignKeyConfig {
+    name?: string;
+    table: Table;
+    foreignColumns: AnyColumn[];
+    refTable: Table;
+    refColumns: AnyColumn[];
+    onDelete?: 'cascade' | 'restrict' | 'set null' | 'set default' | 'no action';
+    onUpdate?: 'cascade' | 'restrict' | 'set null' | 'set default' | 'no action';
+}
+declare function pgForeignKey(config: PgForeignKeyConfig): PgForeignKeyConfig;
+
+/**
+ * CHECK constraint builder for PG tables.
+ */
+
+interface PgCheckConfig {
+    name?: string;
+    table: Table;
+    expression: SQL;
+}
+declare function pgCheck(config: PgCheckConfig): PgCheckConfig;
+
+/**
+ * View / Materialized View support for PostgreSQL.
+ */
+
+declare class PgView extends Table<TableConfig & {
+    dialect: 'pg';
+}> {
+    readonly query: SQL;
+    constructor(name: string, query: SQL, schema?: string);
+}
+declare function pgView(name: string, query: SQL, config?: {
+    schema?: string;
+}): PgView;
+declare class PgMaterializedView extends PgView {
+}
+declare function pgMaterializedView(name: string, query: SQL, config?: {
+    schema?: string;
+}): PgMaterializedView;
+
+/**
+ * PgDialect — SQL generation for PostgreSQL.
+ */
+
+declare class PgDialect extends Dialect {
+    readonly dialect: "pg";
+    escapeName(name: string): string;
+    escapeParam(index: number): string;
+    buildSelectQuery(config: {
+        table: Table;
+        columns: AnyColumn[];
+        where?: SQL;
+        orderBy?: SQL[];
+        groupBy?: SQL[];
+        having?: SQL;
+        limit?: number;
+        offset?: number;
+        joins?: Array<{
+            table: Table;
+            on: SQL;
+            type: 'inner' | 'left' | 'right' | 'full';
+        }>;
+        distinct?: boolean;
+    }): SQL;
+    buildInsertQuery(config: {
+        table: Table;
+        values: Record<string, unknown>[];
+        onConflict?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildUpdateQuery(config: {
+        table: Table;
+        set: Record<string, unknown>;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildDeleteQuery(config: {
+        table: Table;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildCreateTable(config: {
+        table: Table;
+        ifNotExists?: boolean;
+    }): SQL;
+    buildDropTable(config: {
+        table: Table;
+        ifExists?: boolean;
+    }): SQL;
+    buildCreateIndex(config: {
+        name: string;
+        table: Table;
+        columns: AnyColumn[];
+        unique?: boolean;
+        concurrently?: boolean;
+    }): SQL;
+}
+
+export { type PgCheckConfig, PgDialect, type PgForeignKeyConfig, type PgIndexConfig, PgMaterializedView, PgTable, type PgTableColumns, PgView, pgBoolean, pgCheck, pgDoublePrecision, pgForeignKey, pgIndex, pgInteger, pgJson, pgMaterializedView, pgNumeric, pgReal, pgSerial, pgTable, pgText, pgTimestamp, pgUniqueIndex, pgUuid, pgView };

package/dist/index.js

@@ -0,0 +1,159 @@
+import {
+  NodePostgresDriver,
+  createNodePostgresDriver
+} from "./chunk-NLTVBDSL.js";
+import {
+  PostgresJsDriver,
+  createPostgresJsDriver
+} from "./chunk-ZXWSBMW5.js";
+import {
+  PgDialect,
+  PgPreparedQuery,
+  PgSession,
+  PgTransaction
+} from "./chunk-MU3FLR2D.js";
+
+// src/pg-core/table.ts
+import { Table } from "@mountsqli/core";
+var PgTable = class extends Table {
+};
+function pgTable(name, columns, config) {
+  const table = new PgTable(
+    name,
+    config?.schema,
+    name
+  );
+  for (const [key, col] of Object.entries(columns)) {
+    table.columns[key] = col;
+    col.tableName = name;
+  }
+  const result = table;
+  result.columns = columns;
+  return result;
+}
+
+// src/pg-core/columns/index.ts
+import {
+  integer as coreInteger,
+  text as coreText,
+  boolean as coreBoolean,
+  uuid as coreUuid,
+  timestamp as coreTimestamp,
+  json as coreJson,
+  serial as coreSerial,
+  real as coreReal,
+  doublePrecision as coreDoublePrecision,
+  numeric as coreNumeric
+} from "@mountsqli/core";
+import { bigSerial } from "@mountsqli/core";
+var pgInteger = coreInteger;
+var pgText = coreText;
+var pgBoolean = coreBoolean;
+var pgUuid = coreUuid;
+var pgTimestamp = coreTimestamp;
+var pgJson = coreJson;
+var pgSerial = coreSerial;
+var pgReal = coreReal;
+var pgDoublePrecision = coreDoublePrecision;
+var pgNumeric = coreNumeric;
+
+// src/pg-core/relations.ts
+import { relations } from "@mountsqli/core";
+
+// src/pg-core/indexes.ts
+function pgIndex(name) {
+  return {
+    on(table) {
+      return {
+        columns(...columns) {
+          return {
+            unique() {
+              return { name, table, columns, unique: true };
+            },
+            concurrently() {
+              return { name, table, columns, concurrently: true };
+            },
+            where(condition) {
+              return { name, table, columns, where: condition };
+            },
+            build() {
+              return { name, table, columns };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function pgUniqueIndex(name) {
+  return pgIndex(name);
+}
+
+// src/pg-core/foreign-keys.ts
+function pgForeignKey(config) {
+  return config;
+}
+
+// src/pg-core/checks.ts
+function pgCheck(config) {
+  return config;
+}
+
+// src/pg-core/views.ts
+import { Table as Table2 } from "@mountsqli/core";
+var PgView = class extends Table2 {
+  query;
+  constructor(name, query, schema) {
+    super(name, schema, name);
+    this.query = query;
+  }
+};
+function pgView(name, query, config) {
+  return new PgView(name, query, config?.schema);
+}
+var PgMaterializedView = class extends PgView {
+};
+function pgMaterializedView(name, query, config) {
+  return new PgMaterializedView(name, query, config?.schema);
+}
+export {
+  NodePostgresDriver,
+  PgDialect,
+  PgMaterializedView,
+  PgPreparedQuery,
+  PgSession,
+  PgTransaction,
+  PgView,
+  PostgresJsDriver,
+  bigSerial,
+  coreBoolean as boolean,
+  createNodePostgresDriver,
+  createPostgresJsDriver,
+  coreDoublePrecision as doublePrecision,
+  coreInteger as integer,
+  coreJson as json,
+  coreNumeric as numeric,
+  pgBoolean,
+  pgCheck,
+  pgDoublePrecision,
+  pgForeignKey,
+  pgIndex,
+  pgInteger,
+  pgJson,
+  pgMaterializedView,
+  pgNumeric,
+  pgReal,
+  pgSerial,
+  pgTable,
+  pgText,
+  pgTimestamp,
+  pgUniqueIndex,
+  pgUuid,
+  pgView,
+  coreReal as real,
+  relations,
+  coreSerial as serial,
+  coreText as text,
+  coreTimestamp as timestamp,
+  coreUuid as uuid
+};

package/dist/session-cHNTeFK8.d.ts

@@ -0,0 +1,63 @@
+import { Session, Logger, QueryWithTypings, PreparedQuery, TransactionConfig } from '@mountsqli/core';
+
+/**
+ * PgSession — PostgreSQL session implementation.
+ * Wraps a native pg Pool or Client and implements the Session interface.
+ */
+
+interface PgPool {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: any[];
+        rowCount: number;
+    }>;
+    connect(): Promise<PgClient>;
+    end(): Promise<void>;
+    totalCount: number;
+    idleCount: number;
+    waitingCount: number;
+}
+interface PgClient {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: any[];
+        rowCount: number;
+    }>;
+    release(): void;
+}
+declare class PgPreparedQuery<T = any> implements PreparedQuery<T> {
+    private _query;
+    private _client;
+    private _name?;
+    constructor(client: PgPool | PgClient, query: QueryWithTypings, name?: string);
+    execute(params?: Record<string, unknown>): Promise<T>;
+    all(params?: Record<string, unknown>): Promise<T[]>;
+    values(params?: Record<string, unknown>): Promise<unknown[][]>;
+    getQuery(): QueryWithTypings;
+}
+declare class PgTransaction extends Session {
+    private _client;
+    private _session;
+    constructor(client: PgClient, session: PgSession, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings, name?: string): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>, config?: TransactionConfig): Promise<T>;
+    rollback(): Promise<never>;
+    commit(): Promise<void>;
+    setTransactionIsolation(level: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class PgSession extends Session {
+    private _pool;
+    constructor(pool: PgPool, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings, name?: string): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>, config?: TransactionConfig): Promise<T>;
+    dispose(): Promise<void>;
+    /** Get pool stats */
+    getPoolStats(): {
+        totalCount: number;
+        idleCount: number;
+        waitingCount: number;
+    };
+}
+
+export { PgSession as P, PgTransaction as a, PgPreparedQuery as b };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@mountsqli/pg",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./node-postgres": {
+      "import": "./dist/drivers/node-postgres/index.js",
+      "types": "./dist/drivers/node-postgres/index.d.ts"
+    },
+    "./postgres-js": {
+      "import": "./dist/drivers/postgres-js/index.js",
+      "types": "./dist/drivers/postgres-js/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "files": ["dist", "LICENSE", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts src/drivers/node-postgres/index.ts src/drivers/postgres-js/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@mountsqli/core": "workspace:*",
+    "@mountsqli/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "pg": "^8.0.0",
+    "postgres": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": { "optional": true },
+    "postgres": { "optional": true }
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "tsup": "^8.0.0",
+    "vitest": "^3.0.0"
+  }
+}