@devbro/neko-sql 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,8 +1,15 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,29 +18,941 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  Blueprint: () => Blueprint,
+  Column: () => Column,
+  Connection: () => Connection,
+  ForeignKeyConstraint: () => ForeignKeyConstraint,
+  Migration: () => Migration,
+  PostgresqlConnection: () => PostgresqlConnection,
+  PostgresqlQueryGrammar: () => PostgresqlQueryGrammar,
+  PostgresqlSchemaGrammar: () => PostgresqlSchemaGrammar,
+  Query: () => Query,
+  QueryGrammar: () => QueryGrammar,
+  Schema: () => Schema,
+  SchemaGrammar: () => SchemaGrammar
+});
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./databases"), module.exports);
-__reExport(index_exports, require("./Blueprint"), module.exports);
-__reExport(index_exports, require("./Connection"), module.exports);
-__reExport(index_exports, require("./Query"), module.exports);
-__reExport(index_exports, require("./QueryGrammar"), module.exports);
-__reExport(index_exports, require("./Schema"), module.exports);
-__reExport(index_exports, require("./SchemaGrammar"), module.exports);
-__reExport(index_exports, require("./types"), module.exports);
-__reExport(index_exports, require("./Migration"), module.exports);
+
+// src/Connection.mts
+var Connection = class {
+  static {
+    __name(this, "Connection");
+  }
+};
+
+// src/databases/postgresql/PostgresqlConnection.mts
+var import_pg = require("pg");
+
+// src/Query.mts
+var Query = class {
+  constructor(connection, grammar) {
+    this.connection = connection;
+    this.grammar = grammar;
+  }
+  static {
+    __name(this, "Query");
+  }
+  allowedOperations = ["=", ">", "<", "!=", "like", "ilike"];
+  parts = {
+    select: ["*"],
+    table: "",
+    join: [],
+    where: [],
+    groupBy: [],
+    having: [],
+    orderBy: [],
+    limit: null,
+    offset: null
+  };
+  table(tableName) {
+    this.parts.table = tableName;
+    return this;
+  }
+  whereOp(column, operation, value, joinCondition = "and", negateCondition = false) {
+    this.parts.where.push({
+      type: "operation",
+      column,
+      operation,
+      value,
+      joinCondition,
+      negateCondition
+    });
+    return this;
+  }
+  whereColumn(column1, operation, column2, joinCondition = "and", negateCondition = false) {
+    this.parts.where.push({
+      type: "operationColumn",
+      column1,
+      operation,
+      column2,
+      joinCondition,
+      negateCondition
+    });
+    return this;
+  }
+  whereNull(column, joinCondition = "and", negateCondition = false) {
+    this.parts.where.push({ type: "null", column, joinCondition, negateCondition });
+    return this;
+  }
+  clearWhere() {
+    this.parts.where = [];
+    return this;
+  }
+  select(selects) {
+    this.parts.select = [...selects];
+    return this;
+  }
+  groupBy(columns) {
+    this.parts.groupBy = [...columns];
+    return this;
+  }
+  havingOp(column, operation, value, joinCondition = "and", negateCondition = false) {
+    this.parts.having.push({
+      type: "operation",
+      column,
+      operation,
+      value,
+      joinCondition,
+      negateCondition
+    });
+    return this;
+  }
+  havingRaw(sql, bindings, joinCondition = "and", negateCondition = false) {
+    this.parts.having.push({ type: "raw", sql, bindings, joinCondition, negateCondition });
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this.parts.orderBy.push(`${column} ${direction}`);
+    return this;
+  }
+  limit(limit) {
+    this.parts.limit = limit;
+    return this;
+  }
+  offset(offset) {
+    this.parts.offset = offset;
+    return this;
+  }
+  toSql() {
+    return this.grammar.toSql(this);
+  }
+  async get() {
+    return await this.connection?.runQuery(this.toSql());
+  }
+  async count() {
+    const csql = this.grammar.compileCount(this);
+    const result = await this.connection?.runQuery(csql);
+    if (result && Array.isArray(result) && result.length > 0) {
+      return parseInt(result[0]["count"], 10);
+    }
+    return 0;
+  }
+  async getCursor() {
+    return await this.connection?.runCursor(this.toSql());
+  }
+  getConnection() {
+    return this.connection;
+  }
+  async insert(data) {
+    const csql = this.grammar.compileInsert(this, data);
+    return await this.connection?.runQuery(csql);
+  }
+  async insertGetId(data, options = { primaryKey: ["id"] }) {
+    const csql = this.grammar.compileInsertGetId(this, data, options);
+    return await this.connection?.runQuery(csql);
+  }
+  async update(data) {
+    const csql = this.grammar.compileUpdate(this, data);
+    return await this.connection?.runQuery(csql);
+  }
+  async upsert(data, uniqueColumns, updateColumns) {
+    const csql = this.grammar.compileUpsert(this, data, uniqueColumns, updateColumns);
+    return await this.connection?.runQuery(csql);
+  }
+  async delete() {
+    const csql = this.grammar.compileDelete(this);
+    return await this.connection?.runQuery(csql);
+  }
+  innerJoin(table, condtions) {
+    this.parts.join.push({ type: "inner", table, conditions: condtions });
+    return this;
+  }
+  leftJoin(table, condtions) {
+    this.parts.join.push({ type: "left", table, conditions: condtions });
+    return this;
+  }
+  rightJoin(table, condtions) {
+    this.parts.join.push({ type: "right", table, conditions: condtions });
+    return this;
+  }
+  fullJoin(table, condtions) {
+    this.parts.join.push({ type: "full", table, conditions: condtions });
+    return this;
+  }
+};
+
+// src/QueryGrammar.mts
+function toUpperFirst(str) {
+  return str.substring(0, 1).toUpperCase() + str.substring(1);
+}
+__name(toUpperFirst, "toUpperFirst");
+var QueryGrammar = class {
+  static {
+    __name(this, "QueryGrammar");
+  }
+  sqlParts = [
+    "select",
+    "table",
+    "join",
+    "where",
+    "groupBy",
+    "having",
+    "orderBy",
+    "limit",
+    "offset"
+  ];
+  toSql(query) {
+    let sql = "";
+    let bindings = [];
+    for (const part of this.sqlParts) {
+      const funcName = "compile" + toUpperFirst(part);
+      const r = this[funcName](query.parts[part]);
+      if (!sql) {
+        sql = r.sql;
+      } else if (r.sql) {
+        sql += " " + r.sql;
+      }
+      bindings = [...bindings, ...r.bindings];
+    }
+    return { sql, bindings };
+  }
+  compileCount(query) {
+    let sql = "";
+    let bindings = [];
+    for (const part of this.sqlParts) {
+      let parts = query.parts[part];
+      if (part === "select") {
+        parts = ["count(*) as count"];
+      }
+      const funcName = "compile" + toUpperFirst(part);
+      const r = this[funcName](parts);
+      if (!sql) {
+        sql = r.sql;
+      } else if (r.sql) {
+        sql += " " + r.sql;
+      }
+      bindings = [...bindings, ...r.bindings];
+    }
+    return { sql, bindings };
+  }
+  compileSelect(selects) {
+    const rc = selects.map((v) => {
+      return v;
+    }).join(", ");
+    return { sql: "select " + rc, bindings: [] };
+  }
+  compileTable(tableName) {
+    let rc = "";
+    if (tableName.length) {
+      rc = "from " + tableName;
+    }
+    return { sql: rc, bindings: [] };
+  }
+  compileJoin(joins) {
+    let sql = "";
+    let bindings = [];
+    for (const j of joins) {
+      sql += " " + j.type + " join " + j.table + " on ";
+      const where = this.compileWhere(j.conditions);
+      if (where.sql.startsWith("where ")) {
+        where.sql = where.sql.substring("where ".length);
+      }
+      sql += "(";
+      sql += where.sql;
+      sql += ")";
+      bindings = [...bindings, ...where.bindings];
+    }
+    return { sql, bindings };
+  }
+  compileWhere(wheres) {
+    let sql = "";
+    let bindings = [];
+    for (const w of wheres) {
+      sql += " " + w.joinCondition + " ";
+      if (w.negateCondition) {
+        sql += "not ";
+      }
+      const funcName = "compileWhere" + toUpperFirst(w.type);
+      const wh = this[funcName](w);
+      sql += wh.sql;
+      bindings = [...bindings, ...wh.bindings];
+    }
+    if (sql.startsWith(" and ")) {
+      sql = "where " + sql.substring(" and ".length);
+    } else if (sql.startsWith(" or ")) {
+      sql = "where " + sql.substring(" or ".length);
+    }
+    return { sql, bindings };
+  }
+  compileWhereOperation(w) {
+    if (w.operation.toLowerCase() === "in" && Array.isArray(w.value)) {
+      return {
+        sql: `${w.column} = ANY(${this.getVariablePlaceholder()})`,
+        bindings: [w.value]
+      };
+    }
+    return {
+      sql: `${w.column} ${w.operation} ${this.getVariablePlaceholder()}`,
+      bindings: [w.value]
+    };
+  }
+  compileWhereOperationColumn(w) {
+    return {
+      sql: `${w.column1} ${w.operation} ${w.column2}`,
+      bindings: []
+    };
+  }
+  compileOrderBy(orderBy) {
+    let rc = "";
+    if (orderBy.length) {
+      rc = "order by " + orderBy.join(", ");
+    }
+    return { sql: rc, bindings: [] };
+  }
+  compileLimit(limit) {
+    let rc = "";
+    if (limit !== null) {
+      rc = "limit " + limit;
+    }
+    return { sql: rc, bindings: [] };
+  }
+  compileOffset(offset) {
+    let rc = "";
+    if (offset !== null) {
+      rc = "offset " + offset;
+    }
+    return { sql: rc, bindings: [] };
+  }
+  compileWhereNull(w) {
+    return {
+      sql: `${w.column} is null`,
+      bindings: []
+    };
+  }
+  compileInsert(query, data) {
+    let sql = "insert into " + query.parts.table + " (";
+    const columns = [];
+    const bindings = [];
+    const values = [];
+    for (const [k, v] of Object.entries(data)) {
+      columns.push(k);
+      bindings.push(v);
+      values.push(this.getVariablePlaceholder());
+    }
+    sql += columns.join(", ") + ") values (" + values + ")";
+    return { sql, bindings };
+  }
+  compileUpdate(query, data) {
+    let sql = "update " + query.parts.table + " set ";
+    const bindings = [];
+    const setParts = [];
+    for (const [k, v] of Object.entries(data)) {
+      setParts.push(`${k} = ${this.getVariablePlaceholder()}`);
+      bindings.push(v);
+    }
+    sql += setParts.join(", ");
+    const where_csql = this.compileWhere(query.parts.where);
+    sql += " " + where_csql.sql;
+    bindings.push(...where_csql.bindings);
+    return { sql, bindings };
+  }
+  compileDelete(query) {
+    let sql = "delete from " + query.parts.table;
+    const where_csql = this.compileWhere(query.parts.where);
+    sql += " " + where_csql.sql;
+    return { sql, bindings: where_csql.bindings };
+  }
+  compileUpsert(query, data, conflictFields, updateFields) {
+    let sql = "insert into " + query.parts.table + " (";
+    const columns = [];
+    const bindings = [];
+    const values = [];
+    for (const [k, v] of Object.entries(data)) {
+      columns.push(k);
+      bindings.push(v);
+      values.push(this.getVariablePlaceholder());
+    }
+    sql += columns.join(", ") + ") values (" + values + ")";
+    sql += " on conflict (" + conflictFields.join(", ") + ") do update set ";
+    const setParts = [];
+    for (const f of updateFields) {
+      setParts.push(`${f} = excluded.${f}`);
+    }
+    sql += setParts.join(", ");
+    const where_csql = this.compileWhere(query.parts.where);
+    sql += " " + where_csql.sql;
+    bindings.push(...where_csql.bindings);
+    return { sql, bindings };
+  }
+  compileGroupBy(groupBy) {
+    let rc = "";
+    if (groupBy.length) {
+      rc = "group by " + groupBy.join(", ");
+    }
+    return { sql: rc, bindings: [] };
+  }
+  compileHaving(having) {
+    let sql = "";
+    let bindings = [];
+    for (const w of having) {
+      sql += " " + w.joinCondition + " ";
+      if (w.negateCondition) {
+        sql += "not ";
+      }
+      const funcName = "compileHaving" + toUpperFirst(w.type);
+      const wh = this[funcName](w);
+      sql += wh.sql;
+      bindings = [...bindings, ...wh.bindings];
+    }
+    if (sql.startsWith(" and ")) {
+      sql = "having " + sql.substring(" and ".length);
+    } else if (sql.startsWith(" or ")) {
+      sql = "having " + sql.substring(" or ".length);
+    }
+    return { sql, bindings };
+  }
+  compileHavingOperation(w) {
+    return {
+      sql: `${w.column} ${w.operation} ${this.getVariablePlaceholder()}`,
+      bindings: [w.value]
+    };
+  }
+  compileHavingRaw(w) {
+    return {
+      sql: w.sql,
+      bindings: w.bindings
+    };
+  }
+};
+
+// src/databases/postgresql/PostgresqlQueryGrammar.mts
+var PostgresqlQueryGrammar = class extends QueryGrammar {
+  static {
+    __name(this, "PostgresqlQueryGrammar");
+  }
+  parameterIndex;
+  constructor() {
+    super();
+    this.parameterIndex = 1;
+  }
+  toSql(query) {
+    this.parameterIndex = 1;
+    return super.toSql(query);
+  }
+  getVariablePlaceholder() {
+    return "$" + this.parameterIndex++;
+  }
+  compileInsert(query, data) {
+    this.parameterIndex = 1;
+    return super.compileInsert(query, data);
+  }
+  compileInsertGetId(query, data, options = { primaryKey: ["id"] }) {
+    this.parameterIndex = 1;
+    const rc = super.compileInsert(query, data);
+    rc.sql += ` RETURNING ${options.primaryKey.join(", ")}`;
+    return rc;
+  }
+  compileUpdate(query, data) {
+    this.parameterIndex = 1;
+    return super.compileUpdate(query, data);
+  }
+  compileDelete(query) {
+    this.parameterIndex = 1;
+    return super.compileDelete(query);
+  }
+  compileUpsert(query, data, conflictFields, updateFields) {
+    this.parameterIndex = 1;
+    return super.compileUpsert(query, data, conflictFields, updateFields);
+  }
+  compileCount(query) {
+    this.parameterIndex = 1;
+    return super.compileCount(query);
+  }
+};
+
+// src/Expression.mts
+var Expression = class {
+  constructor(sql = "", bindings = []) {
+    this.sql = sql;
+    this.bindings = bindings;
+  }
+  static {
+    __name(this, "Expression");
+  }
+  toCompiledSql() {
+    return { sql: this.sql, bindings: this.bindings };
+  }
+};
+
+// src/Blueprint.mts
+var Column = class {
+  static {
+    __name(this, "Column");
+  }
+  columnName = "";
+  properties = {
+    type: "string",
+    length: 255,
+    nullable: false,
+    unique: false,
+    default: null
+  };
+  constructor(columnName, type) {
+    this.columnName = columnName;
+    this.properties.type = type;
+  }
+  length(length) {
+    this.properties.length = length;
+    return this;
+  }
+  nullable(nullable = true) {
+    this.properties.nullable = nullable;
+    return this;
+  }
+  unique(unique = true) {
+    this.properties.unique = unique;
+    return this;
+  }
+  default(value) {
+    this.properties.default = value;
+    return this;
+  }
+};
+var ForeignKeyConstraint = class {
+  static {
+    __name(this, "ForeignKeyConstraint");
+  }
+  column;
+  reference_table;
+  onUpdateAction = "restrict";
+  onDeleteAction = "restrict";
+  constructor(column) {
+    this.column = column;
+    this.reference_table = { table: "", column: "" };
+  }
+  on(table) {
+    this.reference_table.table = table;
+    return this;
+  }
+  references(column) {
+    this.reference_table.column = column;
+    return this;
+  }
+  onDelete(action) {
+    this.onDeleteAction = action;
+    return this;
+  }
+  onUpdate(action) {
+    this.onUpdateAction = action;
+    return this;
+  }
+};
+var Blueprint = class {
+  static {
+    __name(this, "Blueprint");
+  }
+  tableName = "";
+  columns = [];
+  drop_coumns = [];
+  foreignKeys = [];
+  existingTable = false;
+  primaryKeys = [];
+  constructor() {
+  }
+  setTableName(tableName, existingTable = false) {
+    this.tableName = tableName;
+    this.existingTable = existingTable;
+  }
+  Boolean(columnName) {
+    const rc = new Column(columnName, "boolean");
+    this.columns.push(rc);
+    return rc;
+  }
+  char(columnName) {
+    const rc = new Column(columnName, "char");
+    this.columns.push(rc);
+    return rc;
+  }
+  string(columnName, length = 255) {
+    const rc = new Column(columnName, "string");
+    rc.length(length);
+    this.columns.push(rc);
+    return rc;
+  }
+  text(columnName) {
+    const rc = new Column(columnName, "text");
+    this.columns.push(rc);
+    return rc;
+  }
+  integer(columnName) {
+    const rc = new Column(columnName, "integer");
+    this.columns.push(rc);
+    return rc;
+  }
+  float(columnName) {
+    const rc = new Column(columnName, "float");
+    this.columns.push(rc);
+    return rc;
+  }
+  double(columnName) {
+    const rc = new Column(columnName, "double");
+    this.columns.push(rc);
+    return rc;
+  }
+  id() {
+    const rc = new Column("id", "serial");
+    this.columns.push(rc);
+    this.primaryKeys.push("id");
+    return rc;
+  }
+  timestamps() {
+    this.columns.push(
+      new Column("created_at", "timestamp").default(new Expression("CURRENT_TIMESTAMP"))
+    );
+    this.columns.push(
+      new Column("updated_at", "timestamp").default(new Expression("CURRENT_TIMESTAMP"))
+    );
+  }
+  date(columnName) {
+    const rc = new Column(columnName, "date");
+    this.columns.push(rc);
+    return rc;
+  }
+  primary(keys) {
+    this.primaryKeys = keys;
+  }
+  foreign(columnName) {
+    const rc = new ForeignKeyConstraint(columnName);
+    this.foreignKeys.push(rc);
+    return rc;
+  }
+  dropColumn(columnName) {
+    this.drop_coumns.push(columnName);
+  }
+};
+
+// src/SchemaGrammar.mts
+var SchemaGrammar = class {
+  static {
+    __name(this, "SchemaGrammar");
+  }
+  toSql(blueprint) {
+    if (!blueprint.existingTable) {
+      return this.compileCreateTable(blueprint).sql;
+    } else if (blueprint.existingTable) {
+      return this.compileAlterTable(blueprint).sql;
+    }
+    throw new Error("bad blueprint to compile: " + blueprint.tableName);
+  }
+  compileCreateTable(blueprint) {
+    let sql = "create table " + blueprint.tableName + " (";
+    const columns = blueprint.columns.map((v) => {
+      return this.compileColumn(v);
+    }).join(", ");
+    const primaryKeys = this.compilePrimaryKeys(blueprint.primaryKeys);
+    let foreignKeys = [];
+    if (blueprint.foreignKeys.length > 0) {
+      foreignKeys = blueprint.foreignKeys.map((v) => {
+        return this.compileForeignKey(v);
+      });
+    }
+    sql += [columns, primaryKeys, ...foreignKeys].join(",") + ")";
+    return { sql, bindings: [] };
+  }
+  compileAlterTable(blueprint) {
+    let sql = ["alter table " + blueprint.tableName];
+    const add_columns = blueprint.columns.map((v) => {
+      return "add column " + this.compileColumn(v);
+    });
+    const drop_columns = blueprint.drop_coumns.map((v) => {
+      return "drop column " + v;
+    });
+    sql = sql.concat([[...add_columns, ...drop_columns].join(", ")]);
+    return { sql: sql.join(" "), bindings: [] };
+  }
+  compileColumn(column) {
+    const rc = [`${column.columnName}`];
+    if (column.properties.type === "string") {
+      rc.push("varchar(" + column.properties.length + ")");
+    } else if (column.properties.type === "char") {
+      rc.push("char");
+    } else if (column.properties.type === "boolean") {
+      rc.push("boolean");
+    } else if (column.properties.type === "integer") {
+      rc.push("integer");
+    } else if (column.properties.type === "text") {
+      rc.push("text");
+    } else if (column.properties.type === "timestamp") {
+      rc.push("timestamp");
+    } else if (column.properties.type === "serial") {
+      rc.push("serial");
+    } else if (column.properties.type === "float") {
+      rc.push("float");
+    } else if (column.properties.type === "double") {
+      rc.push("double precision");
+    } else if (column.properties.type === "date") {
+      rc.push("date");
+    } else {
+      throw new Error("Unknown column type: " + column.properties.type);
+    }
+    if (column.properties.nullable) {
+      rc.push("null");
+    } else {
+      rc.push("not null");
+    }
+    if (column.properties.unique) {
+      rc.push("unique");
+    }
+    if (column.properties.default !== null) {
+      rc.push("default " + this.escape(column.properties.default));
+    }
+    return rc.join(" ");
+  }
+  escape(value) {
+    if (value === null || value === void 0) {
+      return "null";
+    }
+    if (typeof value === "number") {
+      return value.toString();
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (value instanceof Date) {
+      return "'" + value.toISOString() + "'";
+    }
+    if (value instanceof Expression) {
+      return value.toCompiledSql().sql;
+    }
+    if (Array.isArray(value)) {
+      return "'{" + value.join(",") + "}'";
+    }
+    return "'" + value.replace("'", "\\'") + "'";
+  }
+  compilePrimaryKeys(primaryKeys) {
+    if (!primaryKeys.length) {
+      return "";
+    }
+    return "primary key (" + primaryKeys.join(", ") + ")";
+  }
+  compileTables(schema = void 0) {
+    return {
+      sql: "select c.relname as name, n.nspname as schema, pg_total_relation_size(c.oid) as size, obj_description(c.oid, 'pg_class') as comment from pg_class c, pg_namespace n where c.relkind in ('r', 'p') and n.oid = c.relnamespace and " + this.compileSchemaWhereClause(schema, "n.nspname") + " order by n.nspname, c.relname",
+      bindings: []
+    };
+  }
+  compileTableExists(tableName, schema = "") {
+    return {
+      sql: "select exists (select 1 from pg_class c, pg_namespace n where n.nspname = " + (schema ? this.escape(schema) : "current_schema()") + " and c.relname = $1 and c.relkind in ('r', 'p') and n.oid = c.relnamespace)",
+      bindings: [tableName]
+    };
+  }
+  compileDropTable(tableName) {
+    return { sql: `drop table ${this.doubleQuoteString(tableName)}`, bindings: [] };
+  }
+  compileSchemaWhereClause(schema, column) {
+    if (Array.isArray(schema) && schema.length > 0) {
+      return `${column} in (${this.quoteString(schema)})`;
+    } else if (schema && typeof schema === "string") {
+      return `${column} = ${this.quoteString(schema)}`;
+    } else {
+      return `${column} <> 'information_schema' and ${column} not like 'pg\\_%'`;
+    }
+  }
+  quoteString(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => `'${v.replace(/'/g, "\\'")}'`).join(", ");
+    }
+    return `'${value.replace(/'/g, "\\'")}'`;
+  }
+  doubleQuoteString(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => this.doubleQuoteString(v)).join(", ");
+    }
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  compileForeignKey(foreignKey) {
+    const rc = [`FOREIGN KEY (${foreignKey.column})`];
+    rc.push(`references ${foreignKey.reference_table.table}(${foreignKey.reference_table.column})`);
+    if (foreignKey.onDeleteAction) {
+      rc.push(`on delete ${foreignKey.onDeleteAction}`);
+    }
+    if (foreignKey.onUpdateAction) {
+      rc.push(`on update ${foreignKey.onUpdateAction}`);
+    }
+    return rc.join(" ");
+  }
+};
+
+// src/Schema.mts
+var Schema = class {
+  constructor(connection, grammar) {
+    this.connection = connection;
+    this.grammar = grammar;
+  }
+  static {
+    __name(this, "Schema");
+  }
+  async createTable(tableName, structMethod) {
+    const blueprint = new Blueprint();
+    blueprint.setTableName(tableName, false);
+    structMethod(blueprint);
+    const grammar = new SchemaGrammar();
+    const sql = grammar.toSql(blueprint);
+    await this.connection?.runQuery({ sql, bindings: [] });
+  }
+  async alterTable(tableName, structMethod) {
+    const blueprint = new Blueprint();
+    blueprint.setTableName(tableName, true);
+    structMethod(blueprint);
+    const grammar = new SchemaGrammar();
+    const sql = grammar.toSql(blueprint);
+    await this.connection?.runQuery({ sql, bindings: [] });
+  }
+  async dropTable(tableName) {
+    const grammar = new SchemaGrammar();
+    await this.connection?.runQuery(grammar.compileDropTable(tableName));
+  }
+  async tables() {
+    const grammar = new SchemaGrammar();
+    return await this.connection?.runQuery(grammar.compileTables());
+  }
+  async tableExists(table_name) {
+    const grammar = new SchemaGrammar();
+    return (await this.connection?.runQuery(grammar.compileTableExists(table_name)))[0]["exists"];
+  }
+  async dropTableIfExists(tableName) {
+    if (await this.tableExists(tableName)) {
+      await this.dropTable(tableName);
+    }
+    return;
+  }
+};
+
+// src/databases/postgresql/PostgresqlSchemaGrammar.mts
+var PostgresqlSchemaGrammar = class extends SchemaGrammar {
+  static {
+    __name(this, "PostgresqlSchemaGrammar");
+  }
+};
+
+// src/databases/postgresql/PostgresqlConnection.mts
+var import_pg_cursor = __toESM(require("pg-cursor"), 1);
+var PostgresqlConnection = class _PostgresqlConnection extends Connection {
+  static {
+    __name(this, "PostgresqlConnection");
+  }
+  connection;
+  static pool;
+  static defaults = {
+    port: 5432,
+    ssl: false,
+    max: 20,
+    idleTimeoutMillis: 1,
+    // wait X milli seconds before closing an idle/released connection
+    connectionTimeoutMillis: 3e4,
+    // wait up to 30 seconds to obtain a new connection
+    maxUses: 7500
+  };
+  constructor(params) {
+    super();
+    if (!_PostgresqlConnection.pool) {
+      _PostgresqlConnection.pool = new import_pg.Pool({ ..._PostgresqlConnection.defaults, ...params });
+    }
+  }
+  async connect() {
+    this.connection = await _PostgresqlConnection.pool.connect();
+    return true;
+  }
+  async runQuery(sql) {
+    const result = await this.connection?.query(sql.sql, sql.bindings);
+    return result?.rows;
+  }
+  async runCursor(sql) {
+    return this.connection?.query(new import_pg_cursor.default(sql.sql, sql.bindings));
+  }
+  async disconnect() {
+    await this.connection?.release();
+    return true;
+  }
+  getQuery() {
+    return new Query(this, new PostgresqlQueryGrammar());
+  }
+  getSchema() {
+    return new Schema(this, new PostgresqlSchemaGrammar());
+  }
+  getQueryGrammar() {
+    return new PostgresqlQueryGrammar();
+  }
+  getSchemaGrammar() {
+    return new PostgresqlSchemaGrammar();
+  }
+  async beginTransaction() {
+    if (!this.connection) {
+      throw new Error("No active connection to begin a transaction.");
+    }
+    await this.connection.query("BEGIN");
+  }
+  async commit() {
+    if (!this.connection) {
+      throw new Error("No active connection to commit a transaction.");
+    }
+    await this.connection.query("COMMIT");
+  }
+  async rollback() {
+    if (!this.connection) {
+      throw new Error("No active connection to rollback a transaction.");
+    }
+    await this.connection.query("ROLLBACK");
+  }
+  static async destroy() {
+    _PostgresqlConnection.pool.end();
+    return;
+  }
+};
+
+// src/Migration.mts
+var Migration = class {
+  static {
+    __name(this, "Migration");
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./databases"),
-  ...require("./Blueprint"),
-  ...require("./Connection"),
-  ...require("./Query"),
-  ...require("./QueryGrammar"),
-  ...require("./Schema"),
-  ...require("./SchemaGrammar"),
-  ...require("./types"),
-  ...require("./Migration")
+  Blueprint,
+  Column,
+  Connection,
+  ForeignKeyConstraint,
+  Migration,
+  PostgresqlConnection,
+  PostgresqlQueryGrammar,
+  PostgresqlSchemaGrammar,
+  Query,
+  QueryGrammar,
+  Schema,
+  SchemaGrammar
 });
 //# sourceMappingURL=index.js.map