@dbmason/postgres 0.1.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,793 @@
+import { internalDefinePolicy as N, internalDefineProcedure as h, internalDefineFunction as g, internalDefineMaterializedView as _, internalDefineView as $, internalDefineCompositeType as T, internalDefineEnum as b, resolveRole as R, resolveTable as y, internalDefineTable as O, resolveColumn as A, internalDefineTrigger as I, internalDefineRole as w, internalDefineGrant as C, internalDefineExtension as D, internalDefineCron as k } from "@dbmason/core";
+import { DbOperation as Le, DbmasonContext as xe, FunctionHandle as Me, ProcedureHandle as Ue, RoleReference as Fe, TableReference as qe, TypeHandle as ve } from "@dbmason/core";
+import { Pool as S } from "pg";
+class L {
+  static emit(e, n, a) {
+    if (e === "create")
+      return this.generateCreateTableSQL(n) + this.generateTableIndexes(n) + `
+`;
+    if (e === "alter" && a) {
+      const t = a.old;
+      return this.generateAlterTableSQL(t, n) + this.diffIndexes(t, n) + `
+`;
+    } else if (e === "drop")
+      return `DROP TABLE "${n.name}" CASCADE;
+`;
+    return "";
+  }
+  static generateCreateTableSQL(e) {
+    const n = Object.values(e.columns).map((c) => this.formatColumn(c)).join(`,
+  `), a = e.constraints.map((c) => `  CONSTRAINT "${c.name}" ${c.definition}`).join(`,
+`), t = e.module && e.module !== "global", o = t ? `"${e.module}"."${e.name}"` : `"${e.name}"`;
+    let i = `-- Table: ${t ? e.module + "." : ""}${e.name}
+`;
+    return i += `CREATE TABLE ${o} (
+  ${n}${a ? `,
+` + a : ""}
+);
+`, e.options?.unlogged && (i = i.replace("CREATE TABLE", "CREATE UNLOGGED TABLE")), i;
+  }
+  static generateAlterTableSQL(e, n) {
+    const a = [];
+    for (const [i, c] of Object.entries(n.columns))
+      e.columns[i] || a.push(`ADD COLUMN "${i}" ${c.type}${c.notNull ? " NOT NULL" : ""}`);
+    return a.length === 0 ? "" : `ALTER TABLE ${n.module && n.module !== "global" ? `"${n.module}"."${n.name}"` : `"${n.name}"`}
+  ${a.join(`,
+  `)};
+`;
+  }
+  static formatColumn(e) {
+    let n = [`"${e.name}" ${e.type}`];
+    if (e.primaryKey ? n.push("PRIMARY KEY") : e.notNull && n.push("NOT NULL"), e.unique && n.push("UNIQUE"), e.default && n.push(`DEFAULT ${e.default}`), e.references) {
+      const t = e.references.module && e.references.module !== "global" ? `"${e.references.module}"."${e.references.table}"` : `"${e.references.table}"`;
+      n.push(`REFERENCES ${t}("${e.references.column}")`), e.references.onDelete && n.push(`ON DELETE ${e.references.onDelete}`);
+    }
+    return n.join(" ");
+  }
+  static generateTableIndexes(e) {
+    return e.indexes.map((n) => this.emitIndex({ ...n, table: e.name, module: e.module })).join("");
+  }
+  static emitIndex(e) {
+    const n = e.columns.join(", "), a = e.method ? ` USING ${e.method.toUpperCase()}` : "", t = e.unique ? "UNIQUE " : "", o = e.where ? ` WHERE ${e.where}` : "", i = e.expression ? `(${e.expression})` : `(${n})`, l = e.module && e.module !== "global" ? `"${e.module}"."${e.table}"` : `"${e.table}"`;
+    return `CREATE ${t}INDEX IF NOT EXISTS "${e.name}" ON ${l}${a} ${i}${o};
+`;
+  }
+  static diffIndexes(e, n) {
+    let a = "";
+    const t = new Map(e.indexes.map((o) => [o.name, o]));
+    for (const o of n.indexes)
+      t.has(o.name) || (a += this.emitIndex({ ...o, table: n.name }));
+    return a;
+  }
+}
+class x {
+  static emit(e) {
+    const n = Object.entries(e.args).map(([o, i]) => `"${o}" ${i}`).join(", ");
+    return `CREATE OR REPLACE PROCEDURE ${e.module && e.module !== "global" ? `"${e.module}"."${e.name}"` : `"${e.name}"`}(${n})
+AS $$
+${e.body}
+$$ LANGUAGE ${e.language};
+
+`;
+  }
+}
+class M {
+  static emit(e) {
+    const n = Object.entries(e.args).map(([o, i]) => `"${o}" ${i}`).join(", ");
+    return `CREATE OR REPLACE FUNCTION ${e.module && e.module !== "global" ? `"${e.module}"."${e.name}"` : `"${e.name}"`}(${n})
+RETURNS ${e.returns} AS $$
+${e.body}
+$$ LANGUAGE ${e.language};
+
+`;
+  }
+}
+class U {
+  static emit(e) {
+    const a = e.module && e.module !== "global" ? `"${e.module}"."${e.name}"` : `"${e.name}"`;
+    return `CREATE OR REPLACE ${e.kind === "MaterializedView" ? "MATERIALIZED VIEW" : "VIEW"} ${a} AS
+${e.query};
+
+`;
+  }
+}
+class F {
+  static emit(e) {
+    let n = `CREATE EXTENSION IF NOT EXISTS "${e.name}"`;
+    return e.schema && (n += ` SCHEMA "${e.schema}"`), e.version && (n += ` VERSION '${e.version}'`), n + `;
+
+`;
+  }
+}
+class q {
+  static emit(e) {
+    return `SELECT cron.schedule('${e.name}', '${e.schedule}', $$ ${e.command} $$);
+`;
+  }
+}
+class v {
+  static emit(e) {
+    let n = "";
+    if (e.type === "enum") {
+      const a = (e.values || []).map((t) => `'${t}'`).join(", ");
+      n = `CREATE TYPE "${e.name}" AS ENUM (${a});`;
+    } else {
+      const a = Object.entries(e.fields || {}).map(([t, o]) => `  "${t}" ${o}`).join(`,
+`);
+      n = `CREATE TYPE "${e.name}" AS (
+${a}
+);`;
+    }
+    return `DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = '${e.name}') THEN ${n} END IF; END $$;
+
+`;
+  }
+}
+class j {
+  static emit(e) {
+    let n = "";
+    if (e.options) {
+      const a = e.options;
+      a.superuser !== void 0 && (n += a.superuser ? " SUPERUSER" : " NOSUPERUSER"), a.createdb !== void 0 && (n += a.createdb ? " CREATEDB" : " NOCREATEDB"), a.createrole !== void 0 && (n += a.createrole ? " CREATEROLE" : " NOCREATEROLE"), a.inherit !== void 0 && (n += a.inherit ? " INHERIT" : " NOINHERIT"), a.login !== void 0 && (n += a.login ? " LOGIN" : " NOLOGIN"), a.password && (n += ` PASSWORD '${a.password}'`);
+    }
+    return `DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${e.name}') THEN CREATE ROLE "${e.name}"${n}; END IF; END $$;
+
+`;
+  }
+}
+class P {
+  static emit(e) {
+    return `GRANT ${e.privileges.join(", ")} ON ${e.on} "${e.object}" TO "${e.to}";
+
+`;
+  }
+}
+class H {
+  static emit(e) {
+    return `CREATE TRIGGER "${e.name}"
+  ${e.when} ${e.events.join(" OR ")} ON "${e.table}"
+  FOR EACH ${e.forEach || "ROW"}
+  EXECUTE FUNCTION ${e.functionName}(${(e.functionArgs || []).join(", ")});
+
+`;
+  }
+}
+class G {
+  static emit(e) {
+    let n = `-- Policy: ${e.name} on ${e.table}
+`;
+    if (e.method === "rls")
+      n += `ALTER TABLE "${e.table}" ENABLE ROW LEVEL SECURITY;
+`, n += `CREATE POLICY "${e.name}" ON "${e.table}" FOR ALL USING (${e.sql});
+`;
+    else if (e.method === "rbac" && e.rbac)
+      for (const a of e.rbac)
+        n += `GRANT ${a.operations.join(", ")} ON TABLE "${e.table}" TO ${a.roles.map((t) => `"${t}"`).join(", ")};
+`;
+    return n + `
+`;
+  }
+}
+class W {
+  static emit(e) {
+    let n = `-- Generated by @dbmason/postgres
+
+`;
+    const a = /* @__PURE__ */ new Set();
+    for (const t of e)
+      t.node.module && t.node.module !== "global" && a.add(t.node.module);
+    for (const t of a)
+      n += `CREATE SCHEMA IF NOT EXISTS "${t}";
+`;
+    a.size > 0 && (n += `
+`);
+    for (const t of e)
+      switch (t.node.kind) {
+        case "Table":
+          n += L.emit(t.action, t.node, t.diff);
+          break;
+        case "Procedure":
+          n += x.emit(t.node);
+          break;
+        case "Function":
+          n += M.emit(t.node);
+          break;
+        case "Extension":
+          n += F.emit(t.node);
+          break;
+        case "Type":
+          n += v.emit(t.node);
+          break;
+        case "View":
+        case "MaterializedView":
+          n += U.emit(t.node);
+          break;
+        case "Cron":
+          n += q.emit(t.node);
+          break;
+        case "Trigger":
+          n += H.emit(t.node);
+          break;
+        case "Policy":
+          n += G.emit(t.node);
+          break;
+        case "Role":
+          n += j.emit(t.node);
+          break;
+        case "Grant":
+          n += P.emit(t.node);
+          break;
+      }
+    return n;
+  }
+}
+class d {
+  constructor(e) {
+    this.client = null, this.pool = new S({ connectionString: e });
+  }
+  async connect() {
+    this.client = await this.pool.connect();
+  }
+  async close() {
+    this.client && (this.client.release(), this.client = null), await this.pool.end();
+  }
+  async query(e, n) {
+    if (!this.client) throw new Error("Driver not connected");
+    return this.client.query(e, n);
+  }
+  async beginTransaction() {
+    await this.query("BEGIN");
+  }
+  async commitTransaction() {
+    await this.query("COMMIT");
+  }
+  async rollbackTransaction() {
+    await this.query("ROLLBACK");
+  }
+}
+class V {
+  static async introspect(e) {
+    const n = {}, a = await e.query(`
+            SELECT table_schema, table_name 
+            FROM information_schema.tables 
+            WHERE table_schema NOT IN ('information_schema', 'pg_catalog') 
+            AND table_type = 'BASE TABLE'
+        `);
+    for (const t of a.rows) {
+      const o = t.table_schema, i = t.table_name, c = await this.introspectColumns(e, o, i), l = await this.introspectIndexes(e, o, i), r = await this.introspectConstraints(e, o, i);
+      n[i] = {
+        kind: "Table",
+        name: i,
+        module: o === "public" ? "global" : o,
+        columns: c,
+        indexes: l,
+        constraints: r,
+        policies: [],
+        triggers: []
+      };
+    }
+    return n;
+  }
+  static async introspectColumns(e, n, a) {
+    const t = await e.query(`
+            SELECT column_name, data_type, udt_name, is_nullable, column_default, is_identity
+            FROM information_schema.columns 
+            WHERE table_schema = '${n}' AND table_name = '${a}'
+        `), o = await e.query(`
+            SELECT kcu.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+            WHERE tc.constraint_type = 'PRIMARY KEY'
+            AND tc.table_schema = '${n}' AND tc.table_name = '${a}'
+        `), i = new Set(o.rows.map((l) => l.column_name)), c = {};
+    for (const l of t.rows) {
+      let r = l.data_type === "USER-DEFINED" ? l.udt_name : l.data_type, p = l.column_default || void 0;
+      p && p.includes("nextval") && (r.toLowerCase() === "integer" || r.toLowerCase() === "int4" ? (r = "SERIAL", p = void 0) : (r.toLowerCase() === "bigint" || r.toLowerCase() === "int8") && (r = "BIGSERIAL", p = void 0)), c[l.column_name] = {
+        kind: "Column",
+        name: l.column_name,
+        type: r.toUpperCase(),
+        notNull: l.is_nullable === "NO",
+        default: p,
+        primaryKey: i.has(l.column_name),
+        // Map is_identity to options or similar if strict mapping exists, 
+        // but Dbmason defines identity/sequence via options usually.
+        // For now, if we want to represent it, we might need to extend ColumnNode to support 'identity'.
+        // Checking ColumnNode definition in Table.internal.ts:
+        // options?: unknown;
+        // We can put it there.
+        options: l.is_identity === "YES" ? { identity: !0 } : void 0
+      };
+    }
+    return c;
+  }
+  static async introspectIndexes(e, n, a) {
+    const t = await e.query(`
+            SELECT 
+                i.relname as index_name,
+                a.attname as column_name,
+                ix.indisunique as is_unique
+            FROM pg_class t, pg_class i, pg_index ix, pg_attribute a, pg_namespace n
+            WHERE t.oid = ix.indrelid
+            AND i.oid = ix.indexrelid
+            AND a.attrelid = t.oid
+            AND a.attnum = ANY(ix.indkey)
+            AND t.relkind = 'r'
+            AND t.relname = '${a}'
+            AND n.oid = t.relnamespace
+            AND n.nspname = '${n}'
+            ORDER BY i.relname
+        `), o = /* @__PURE__ */ new Map();
+    for (const i of t.rows)
+      o.has(i.index_name) || o.set(i.index_name, {
+        kind: "Index",
+        name: i.index_name,
+        table: a,
+        columns: [],
+        unique: i.is_unique
+      }), o.get(i.index_name).columns.push(i.column_name);
+    return Array.from(o.values()).filter((i) => !i.name.endsWith("_pkey"));
+  }
+  static async introspectConstraints(e, n, a) {
+    const t = [], o = await e.query(`
+            SELECT
+                tc.constraint_name,
+                kcu.column_name,
+                ccu.table_schema AS foreign_schema,
+                ccu.table_name AS foreign_table,
+                ccu.column_name AS foreign_column
+            FROM information_schema.table_constraints AS tc
+            JOIN information_schema.key_column_usage AS kcu
+                ON tc.constraint_name = kcu.constraint_name
+                AND tc.table_schema = kcu.table_schema
+            JOIN information_schema.constraint_column_usage AS ccu
+                ON ccu.constraint_name = tc.constraint_name
+                AND ccu.table_schema = tc.table_schema
+            WHERE tc.constraint_type = 'FOREIGN KEY'
+                AND tc.table_schema = '${n}' AND tc.table_name = '${a}'
+        `);
+    for (const r of o.rows) {
+      const u = r.foreign_schema && r.foreign_schema !== "global" && r.foreign_schema !== "public" ? `"${r.foreign_schema}"."${r.foreign_table}"` : `"${r.foreign_table}"`, f = `FOREIGN KEY ("${r.column_name}") REFERENCES ${u}("${r.foreign_column}")`;
+      t.push({
+        kind: "Constraint",
+        type: "foreign_key",
+        definition: f,
+        name: r.constraint_name,
+        table: a
+      });
+    }
+    const i = await e.query(`
+            SELECT
+                tc.constraint_name,
+                cc.check_clause
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.check_constraints cc
+                ON tc.constraint_name = cc.constraint_name
+            WHERE tc.constraint_type = 'CHECK'
+                AND tc.table_schema = '${n}' AND tc.table_name = '${a}'
+                AND NOT (tc.constraint_name LIKE '%_not_null') -- Exclude internal NOT NULL checks
+        `);
+    for (const r of i.rows)
+      t.push({
+        kind: "Constraint",
+        type: "check",
+        name: r.constraint_name,
+        table: a,
+        definition: `CHECK (${r.check_clause})`
+      });
+    const c = await e.query(`
+             SELECT
+                tc.constraint_name,
+                kcu.column_name
+            FROM information_schema.table_constraints AS tc
+            JOIN information_schema.key_column_usage AS kcu
+                ON tc.constraint_name = kcu.constraint_name
+                AND tc.table_schema = kcu.table_schema
+            WHERE tc.constraint_type = 'UNIQUE'
+                AND tc.table_schema = '${n}' AND tc.table_name = '${a}'
+        `), l = /* @__PURE__ */ new Map();
+    for (const r of c.rows)
+      l.has(r.constraint_name) || l.set(r.constraint_name, []), l.get(r.constraint_name).push(r.column_name);
+    for (const [r, p] of l)
+      t.push({
+        kind: "Constraint",
+        type: "unique",
+        name: r,
+        table: a,
+        definition: `UNIQUE (${p.map((u) => `"${u}"`).join(", ")})`
+      });
+    return t;
+  }
+}
+class B {
+  static async introspect(e) {
+    const n = await e.query(`
+            SELECT
+                n.nspname as schema,
+                c.relname as name,
+                pg_get_viewdef(c.oid, true) as definition,
+                c.relkind as kind
+            FROM pg_class c
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('v', 'm')
+            AND n.nspname NOT IN ('information_schema', 'pg_catalog')
+        `), a = {}, t = {};
+    for (const o of n.rows) {
+      const i = o.name, c = o.schema === "public" ? "global" : o.schema, l = o.definition.trim();
+      o.kind === "v" ? a[i] = { kind: "View", name: i, module: c, query: l } : t[i] = { kind: "MaterializedView", name: i, module: c, query: l };
+    }
+    return { views: a, materializedViews: t };
+  }
+}
+class J {
+  static async introspect(e) {
+    const n = await e.query(`
+            SELECT 
+                n.nspname as schema,
+                t.typname as name,
+                e.enumlabel as value
+            FROM pg_type t
+            JOIN pg_enum e ON t.oid = e.enumtypid
+            JOIN pg_namespace n ON n.oid = t.typnamespace
+            WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+            ORDER BY t.typname, e.enumsortorder
+        `), a = {};
+    for (const t of n.rows) {
+      const o = t.name, i = t.schema === "public" ? "global" : t.schema;
+      a[o] || (a[o] = {
+        kind: "Type",
+        name: o,
+        module: i,
+        type: "enum",
+        values: []
+      }), a[o].values?.push(t.value);
+    }
+    return a;
+  }
+}
+class Y {
+  static async introspect(e) {
+    const n = await e.query(`
+            SELECT
+                n.nspname as schema,
+                p.proname as name,
+                p.prosrc as body,
+                l.lanname as language,
+                pg_get_function_arguments(p.oid) as args,
+                pg_get_function_result(p.oid) as returns
+            FROM pg_proc p
+            JOIN pg_namespace n ON n.oid = p.pronamespace
+            JOIN pg_language l ON l.oid = p.prolang
+            WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+            AND p.prokind = 'f'
+        `), a = {};
+    for (const t of n.rows) {
+      const o = t.name, i = t.schema === "public" ? "global" : t.schema, c = {};
+      if (t.args) {
+        const r = t.args.split(",").map((p) => p.trim());
+        for (const p of r) {
+          const u = p.split(" ").map((f) => f.trim()).filter(Boolean);
+          u.length >= 2 && (["IN", "OUT", "INOUT", "VARIADIC"].includes(u[0].toUpperCase()) ? u.length >= 3 && (c[u[1]] = u.slice(2).join(" ")) : c[u[0]] = u.slice(1).join(" "));
+        }
+      }
+      const l = t.body;
+      a[o] = {
+        kind: "Function",
+        name: o,
+        module: i,
+        args: c,
+        returns: t.returns,
+        language: t.language,
+        body: l
+      };
+    }
+    return a;
+  }
+}
+class K {
+  static async introspect(e) {
+    const n = await e.query(`
+            SELECT
+                n.nspname as schema,
+                p.proname as name,
+                p.prosrc as body,
+                l.lanname as language,
+                pg_get_function_arguments(p.oid) as args,
+                pg_get_function_result(p.oid) as returns
+            FROM pg_proc p
+            JOIN pg_namespace n ON n.oid = p.pronamespace
+            JOIN pg_language l ON l.oid = p.prolang
+            WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+            AND p.prokind = 'p'
+        `), a = {};
+    for (const t of n.rows) {
+      const o = t.name, i = t.schema === "public" ? "global" : t.schema, c = {};
+      if (t.args) {
+        const r = t.args.split(",").map((p) => p.trim());
+        for (const p of r) {
+          const u = p.split(" ").map((f) => f.trim()).filter(Boolean);
+          u.length >= 2 && (["IN", "OUT", "INOUT", "VARIADIC"].includes(u[0].toUpperCase()) ? u.length >= 3 && (c[u[1]] = u.slice(2).join(" ")) : c[u[0]] = u.slice(1).join(" "));
+        }
+      }
+      const l = t.body;
+      a[o] = {
+        kind: "Procedure",
+        name: o,
+        module: i,
+        args: c,
+        returns: t.returns,
+        language: t.language,
+        body: l
+      };
+    }
+    return a;
+  }
+}
+class z {
+  static async introspect(e) {
+    const n = await e.query(`
+            SELECT
+                n.nspname as schema,
+                t.tgname as name,
+                c.relname as table_name,
+                p.proname as function_name,
+                t.tgtype as type,
+                pg_get_triggerdef(t.oid) as definition
+            FROM pg_trigger t
+            JOIN pg_class c ON c.oid = t.tgrelid
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            JOIN pg_proc p ON p.oid = t.tgfoid
+            WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+            AND NOT t.tgisinternal
+        `), a = {};
+    for (const t of n.rows) {
+      const o = t.name, i = t.schema === "public" ? "global" : t.schema, c = t.definition.toUpperCase();
+      let l = "BEFORE";
+      c.includes("AFTER") ? l = "AFTER" : c.includes("INSTEAD OF") && (l = "INSTEAD OF");
+      const r = [];
+      c.includes("INSERT") && r.push("INSERT"), c.includes("UPDATE") && r.push("UPDATE"), c.includes("DELETE") && r.push("DELETE"), c.includes("TRUNCATE") && r.push("TRUNCATE");
+      const p = c.includes("FOR EACH ROW") ? "ROW" : "STATEMENT";
+      a[o] = {
+        kind: "Trigger",
+        name: o,
+        table: t.table_name,
+        module: i,
+        functionName: t.function_name,
+        when: l,
+        events: r,
+        forEach: p
+      };
+    }
+    return a;
+  }
+}
+class X {
+  async introspect(e) {
+    const n = new d(e);
+    await n.connect();
+    try {
+      const a = await V.introspect(n), { views: t, materializedViews: o } = await B.introspect(n), i = await J.introspect(n), c = await Y.introspect(n), l = await K.introspect(n), r = await z.introspect(n);
+      return {
+        tables: a,
+        procedures: l,
+        functions: c,
+        views: t,
+        materializedViews: o,
+        types: i,
+        crons: {},
+        extensions: {},
+        roles: {},
+        grants: {},
+        policies: {},
+        triggers: r,
+        hashes: {}
+      };
+    } finally {
+      await n.close();
+    }
+  }
+}
+class te {
+  constructor() {
+    this.name = "postgres", this.introspector = new X();
+  }
+  setContext(e) {
+    this.ctx = e;
+  }
+  analyzeTable(e) {
+    const n = [];
+    for (const i of Object.values(e.columns))
+      i.references && n.push(`table:${i.references.table}`), this.ctx && this.ctx.types.has(i.type) && n.push(`type:${i.type}`);
+    const a = this.ctx ? Array.from(this.ctx.policies.values()).filter((i) => i.table === e.name || i.module === e.module && i.table === e.name) : [], t = a.length > 0, o = e.indexes.map((i) => ({
+      ...i,
+      name: i.name || `idx_${e.name}_${i.columns.join("_")}`
+    }));
+    return {
+      ...e,
+      indexes: o,
+      dependencies: n,
+      rls: {
+        enabled: t,
+        policies: a
+      }
+    };
+  }
+  emit(e) {
+    return W.emit(e);
+  }
+  getDriver(e) {
+    return new d(e);
+  }
+}
+function ae(s, e, n) {
+  return N(s, e, n);
+}
+function se(s, e, n) {
+  return h(s, e, n);
+}
+function ie(s, e, n) {
+  return g(s, e, n);
+}
+function oe(s, e, n) {
+  $(s, e, n);
+}
+function ce(s, e, n) {
+  _(s, e, n);
+}
+function re(s, e, n) {
+  return b(s, e, n);
+}
+function le(s, e, n) {
+  return T(s, e, n);
+}
+function E(s) {
+  return s.map((e) => A(e).column);
+}
+const me = (...s) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: E(s),
+  method: "btree"
+}), ue = (...s) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: E(s),
+  method: "gin"
+}), pe = (...s) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: E(s),
+  method: "gist"
+}), fe = (...s) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: E(s),
+  method: "hash"
+});
+class m {
+  constructor(e) {
+    this.node = e;
+  }
+  primaryKey() {
+    return new m({ ...this.node, primaryKey: !0, notNull: !0 });
+  }
+  notNull() {
+    return new m({ ...this.node, notNull: !0 });
+  }
+  unique() {
+    return new m({ ...this.node, unique: !0 });
+  }
+  default(e) {
+    return new m({ ...this.node, default: e });
+  }
+  defaultNow() {
+    return new m({ ...this.node, default: "NOW()" });
+  }
+  defaultUuid() {
+    return new m({ ...this.node, default: "gen_random_uuid()" });
+  }
+  check(e) {
+    return new m({ ...this.node, check: e });
+  }
+  references(e, n, a) {
+    let t, o, i;
+    return typeof e != "string" ? (t = e.tableName, o = e.columnName, i = n) : (t = e, o = n, i = a), new m({
+      ...this.node,
+      references: {
+        module: e.moduleName,
+        table: t,
+        column: o,
+        onDelete: i?.onDelete,
+        onUpdate: i?.onUpdate
+      }
+    });
+  }
+  build() {
+    return this.node;
+  }
+}
+const Ee = (s = "") => new m({ kind: "Column", name: s, type: "TEXT" }), de = (s = "") => new m({ kind: "Column", name: s, type: "UUID" }), Q = (s = "") => new m({ kind: "Column", name: s, type: "TIMESTAMPTZ" }), Ne = Q, he = (s = "") => new m({ kind: "Column", name: s, type: "JSONB" }), ge = (s = "") => new m({ kind: "Column", name: s, type: "INTEGER" }), _e = (s = "") => new m({ kind: "Column", name: s, type: "BOOLEAN" }), $e = (s = "") => new m({ kind: "Column", name: s, type: "DOUBLE PRECISION" }), Te = (s = "") => new m({ kind: "Column", name: s, type: "DECIMAL" }), be = (s = "") => new m({ kind: "Column", name: s, type: "SERIAL" }), Re = (s = "") => new m({ kind: "Column", name: s, type: "BIGSERIAL" }), Z = (s, e = "") => {
+  const n = typeof s == "string" ? s : s.moduleName && s.moduleName !== "global" ? `"${s.moduleName}"."${s.typeName}"` : s.typeName;
+  return new m({ kind: "Column", name: e, type: n });
+}, ye = Z;
+function Oe(s, e, n) {
+  const a = {
+    ...n,
+    options: n.options ? {
+      ...n.options,
+      inherits: n.options.inherits ? y(n.options.inherits) : void 0,
+      realtime: Array.isArray(n.options.realtime) ? n.options.realtime.map((t) => R(t)) : n.options.realtime
+    } : void 0
+  };
+  return O(s, e, a, (t) => {
+    const o = {};
+    for (const [i, c] of Object.entries(t))
+      if (c instanceof m) {
+        const l = c.build();
+        l.name = i, o[i] = l;
+      } else typeof c == "string" ? o[i] = { kind: "Column", name: i, type: c } : o[i] = { ...c, name: i };
+    return o;
+  });
+}
+function Ae(s, e, n, a) {
+  I(s, e, n, a);
+}
+function Ie(s, e, n) {
+  return w(s, e, n);
+}
+function we(s, e, n, a, t) {
+  return C(s, e, n, a, t);
+}
+function Ce(s, e, n) {
+  return D(s, e, n);
+}
+function De(s, e, n, a) {
+  return k(s, e, n, a);
+}
+export {
+  Le as DbOperation,
+  xe as DbmasonContext,
+  Me as FunctionHandle,
+  m as PostgresColumnBuilder,
+  te as PostgresDialect,
+  Ue as ProcedureHandle,
+  Fe as RoleReference,
+  qe as TableReference,
+  ve as TypeHandle,
+  Re as bigserial,
+  _e as boolean,
+  me as btree,
+  Z as custom,
+  Te as decimal,
+  le as defineCompositeType,
+  De as defineCron,
+  re as defineEnum,
+  Ce as defineExtension,
+  ie as defineFunction,
+  we as defineGrant,
+  ce as defineMaterializedView,
+  ae as definePolicy,
+  se as defineProcedure,
+  Ie as defineRole,
+  Oe as defineTable,
+  Ae as defineTrigger,
+  oe as defineView,
+  $e as doublePrecision,
+  ye as enumType,
+  ue as gin,
+  pe as gist,
+  fe as hash,
+  ge as integer,
+  he as jsonb,
+  be as serial,
+  Ee as text,
+  Ne as timestamp,
+  Q as timestamptz,
+  de as uuid
+};
+//# sourceMappingURL=index.mjs.map