@dbmason/core 0.1.0-alpha.1

package/dist/cli/index.mjs

@@ -0,0 +1,929 @@
+#!/usr/bin/env node
+import { Command as I } from "commander";
+import * as p from "fs";
+import * as d from "path";
+import { execSync as H } from "child_process";
+import { D as P } from "../DbmasonContext-Baf-v6-B.mjs";
+import * as U from "crypto";
+function W(i, e) {
+  const o = d.resolve(process.cwd(), i);
+  p.existsSync(o) && (console.error(`Directory ${i} already exists.`), process.exit(1)), p.mkdirSync(o);
+  const t = d.join(o, "src");
+  p.mkdirSync(t), p.mkdirSync(d.join(o, "migrations"));
+  const s = d.join(o, "dbmason");
+  p.mkdirSync(s);
+  const n = d.resolve(__dirname, "../../templates/cli"), r = (e.template || "auth").toLowerCase(), c = r.endsWith(".ts") ? r : `${r}.ts`, a = d.join(n, c);
+  p.existsSync(a) || (console.error(`Template '${r}' not found in ${n}`), process.exit(1));
+  const l = p.readFileSync(a, "utf8");
+  p.writeFileSync(d.join(s, "schema.ts"), l.trim()), p.writeFileSync(d.join(s, "helpers.ts"), `import { DbmasonContext, definePolicy, DbOperation, TableReference } from '@dbmason/postgres';
+
+/**
+ * RLS Helper: Restricts WHICH ROWS a user can see.
+ */
+export function defineRLSPolicy(ctx: DbmasonContext, table: TableReference, name: string) {
+    definePolicy(table, name, {
+        method: 'rls',
+        sql: \\\`(SELECT role FROM users WHERE id = current_setting('app.user_id')::uuid) = 'admin'\\\`
+    });
+}
+
+/**
+ * RBAC Helper: Restricts WHICH ACTIONS (SELECT, INSERT, etc.) a role can perform.
+ */
+export function defineRBACPolicy(ctx: DbmasonContext, table: TableReference, role: string, operations: DbOperation[]) {
+    definePolicy(table, \\\`\\\${role}_rbac\\\`, {
+        method: 'rbac',
+        rbac: [{ roles: [role], operations }]
+    });
+}
+`.trim()), p.writeFileSync(d.join(s, "index.ts"), `import { DbmasonContext } from '@dbmason/core';
+import { PostgresDialect } from '@dbmason/postgres';
+import { setupSchema } from './schema';
+
+const ctx = new DbmasonContext();
+
+// Setup Authentication (Tables, Procedures, Crons)
+setupSchema(ctx);
+
+export const dialect = new PostgresDialect(ctx);
+export default ctx;
+`.trim()), p.writeFileSync(d.join(o, "docker-compose.yml"), `
+services:
+  db:
+    image: postgres:latest
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+volumes:
+  pgdata:
+`.trim()), p.writeFileSync(d.join(o, ".env"), "DATABASE_URL=postgres://postgres:postgres@localhost:5432/postgres".trim());
+  const T = {
+    compilerOptions: {
+      target: "ES2020",
+      module: "CommonJS",
+      moduleResolution: "node",
+      esModuleInterop: !0,
+      resolveJsonModule: !0,
+      skipLibCheck: !0,
+      strict: !0,
+      outDir: "./dist",
+      rootDir: "./"
+    }
+  };
+  p.writeFileSync(d.join(o, "tsconfig.json"), JSON.stringify(T, null, 2));
+  const y = {
+    name: i,
+    version: "1.0.0",
+    scripts: {
+      generate: "dbmason generate",
+      migrate: "dbmason migrate",
+      "db:up": "docker compose up -d",
+      "db:down": "docker compose down"
+    },
+    dependencies: {
+      "@dbmason/core": "file:../packages/core",
+      "@dbmason/postgres": "file:../packages/postgres",
+      pg: "^8.11.0",
+      dotenv: "^16.3.1"
+    },
+    devDependencies: {
+      typescript: "^5.0.0",
+      "ts-node": "^10.9.1"
+    }
+  };
+  p.writeFileSync(d.join(o, "package.json"), JSON.stringify(y, null, 2)), console.log(`Dbmason project ${i} initialized with default Auth template.`);
+  try {
+    console.log("Installing dependencies..."), H("npm install", { cwd: o, stdio: "inherit" }), console.log("Dependencies installed successfully.");
+  } catch (w) {
+    console.error("Failed to install dependencies:", w);
+  }
+}
+class B {
+  constructor(e) {
+    this.ctx = e;
+  }
+  resolveOrder() {
+    const e = [], o = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+    for (const r of this.ctx.extensions.keys()) e.push(`extension:${r}`);
+    for (const r of this.ctx.roles.keys()) e.push(`role:${r}`);
+    const s = Array.from(this.ctx.types.keys());
+    for (const r of s)
+      this.visit(`type:${r}`, o, t, e);
+    const n = Array.from(this.ctx.tables.keys());
+    for (const r of n)
+      this.visit(`table:${r}`, o, t, e);
+    for (const r of this.ctx.views.keys()) e.push(`view:${r}`);
+    for (const r of this.ctx.procedures.keys()) e.push(`procedure:${r}`);
+    for (const r of this.ctx.functions.keys()) e.push(`function:${r}`);
+    for (const r of this.ctx.crons.keys()) e.push(`cron:${r}`);
+    for (const r of this.ctx.policies.keys()) e.push(`policy:${r}`);
+    for (const r of this.ctx.triggers.keys()) e.push(`trigger:${r}`);
+    for (const r of this.ctx.grants.keys()) e.push(`grant:${r}`);
+    return e;
+  }
+  visit(e, o, t, s) {
+    if (o.has(e)) return;
+    if (t.has(e)) throw new Error(`Circular dependency detected: ${e}`);
+    t.add(e);
+    const [n, r] = e.split(":");
+    if (n === "table") {
+      const c = this.ctx.tables.get(r);
+      if (c)
+        for (const a of Object.values(c.columns))
+          a.references && this.visit(`table:${a.references.table}`, o, t, s), this.ctx.types.has(a.type) && this.visit(`type:${a.type}`, o, t, s);
+    }
+    t.delete(e), o.add(e), s.push(e);
+  }
+}
+class C {
+  constructor(e, o) {
+    this.ctx = e, this.dialect = o, this.dependencyResolver = new B(e);
+  }
+  analyze() {
+    const e = /* @__PURE__ */ new Map();
+    for (const [s, n] of this.ctx.tables.entries())
+      e.set(s, this.dialect.analyzeTable(n));
+    const o = this.dependencyResolver.resolveOrder();
+    return {
+      tables: e,
+      types: new Map(this.ctx.types),
+      views: new Map(this.ctx.views),
+      materializedViews: new Map(this.ctx.materializedViews),
+      procedures: new Map(this.ctx.procedures),
+      functions: new Map(this.ctx.functions),
+      extensions: new Map(this.ctx.extensions),
+      roles: new Map(this.ctx.roles),
+      grants: new Map(this.ctx.grants),
+      crons: new Map(this.ctx.crons),
+      policies: new Map(this.ctx.policies),
+      triggers: new Map(this.ctx.triggers),
+      order: o
+    };
+  }
+}
+class V {
+  constructor(e, o) {
+    this.analyzedSchema = e, this.oldSnapshot = o;
+  }
+  plan() {
+    const e = [];
+    for (const o of this.analyzedSchema.order) {
+      const [t, s] = o.split(":");
+      switch (t) {
+        case "extension":
+          this.planExtension(s, e);
+          break;
+        case "type":
+          this.planType(s, e);
+          break;
+        case "table":
+          this.planTable(s, e);
+          break;
+        case "view":
+          this.planView(s, e);
+          break;
+        case "procedure":
+          this.planProcedure(s, e);
+          break;
+        case "function":
+          this.planFunction(s, e);
+          break;
+        case "cron":
+          this.planCron(s, e);
+          break;
+        case "policy":
+          this.planPolicy(s, e);
+          break;
+        case "trigger":
+          this.planTrigger(s, e);
+          break;
+        case "role":
+          this.planRole(s, e);
+          break;
+        case "grant":
+          this.planGrant(s, e);
+          break;
+      }
+    }
+    return this.oldSnapshot && this.planDeletions(e), e;
+  }
+  planExtension(e, o) {
+    const t = this.analyzedSchema.extensions.get(e), s = this.oldSnapshot?.extensions[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planType(e, o) {
+    const t = this.analyzedSchema.types.get(e), s = this.oldSnapshot?.types[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planTable(e, o) {
+    const t = this.analyzedSchema.tables.get(e);
+    if (!t) return;
+    const s = this.oldSnapshot?.tables[e];
+    s ? JSON.stringify(t) !== JSON.stringify(s) && o.push({ action: "alter", node: t, diff: { old: s } }) : o.push({ action: "create", node: t });
+  }
+  planView(e, o) {
+    const t = this.analyzedSchema.views.get(e);
+    if (!t) return;
+    const s = this.oldSnapshot?.views[e];
+    (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "replace", node: t });
+  }
+  planProcedure(e, o) {
+    const t = this.analyzedSchema.procedures.get(e);
+    if (!t) return;
+    const s = this.oldSnapshot?.hashes?.[e], n = require("crypto").createHash("md5").update(t.body).digest("hex");
+    (!s || s !== n) && o.push({ action: "replace", node: t });
+  }
+  planFunction(e, o) {
+    const t = this.analyzedSchema.functions.get(e);
+    if (!t) return;
+    const s = this.oldSnapshot?.hashes?.[e], n = require("crypto").createHash("md5").update(t.body).digest("hex");
+    (!s || s !== n) && o.push({ action: "replace", node: t });
+  }
+  planCron(e, o) {
+    const t = this.analyzedSchema.crons.get(e), s = this.oldSnapshot?.crons[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planPolicy(e, o) {
+    const t = this.analyzedSchema.policies.get(e), s = this.oldSnapshot?.policies?.[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planTrigger(e, o) {
+    const t = this.analyzedSchema.triggers.get(e), s = this.oldSnapshot?.triggers?.[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planRole(e, o) {
+    const t = this.analyzedSchema.roles.get(e), s = this.oldSnapshot?.roles?.[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planGrant(e, o) {
+    const t = this.analyzedSchema.grants.get(e), s = this.oldSnapshot?.grants?.[e];
+    t && (!s || JSON.stringify(t) !== JSON.stringify(s)) && o.push({ action: "create", node: t });
+  }
+  planDeletions(e) {
+    for (const o of Object.keys(this.oldSnapshot.tables))
+      this.analyzedSchema.tables.has(o) || e.push({ action: "drop", node: this.oldSnapshot.tables[o] });
+    for (const o of Object.keys(this.oldSnapshot.roles || {}))
+      this.analyzedSchema.roles.has(o) || e.push({ action: "drop", node: this.oldSnapshot.roles[o] });
+  }
+}
+class D {
+  constructor(e, o) {
+    this.ctx = e, this.dialect = o;
+  }
+  /**
+   * compile
+   */
+  compile(e) {
+    const t = new C(this.ctx, this.dialect).analyze(), n = new V(t, e).plan();
+    return this.dialect.emit(n);
+  }
+}
+function G(i, e) {
+  const o = {
+    tables: {},
+    procedures: {},
+    functions: {},
+    views: {},
+    types: {},
+    modules: {}
+  };
+  function t(r) {
+    if (!r || r === "global") return o;
+    const c = r.split(".");
+    let a = o;
+    for (const l of c)
+      a.modules[l] || (a.modules[l] = {
+        tables: {},
+        procedures: {},
+        functions: {},
+        views: {},
+        types: {},
+        modules: {}
+      }), a = a.modules[l];
+    return a;
+  }
+  function s(r) {
+    if (!r) return "any";
+    let c = r.replace(/\\"/g, "").replace(/"/g, "");
+    return c.toUpperCase().startsWith("SETOF ") ? `SETOF '${c.substring(6).trim()}'` : c;
+  }
+  for (const r of i.tables.values()) {
+    const c = t(r.module);
+    c.tables[r.name] = {
+      name: r.name,
+      module: r.module,
+      columns: Object.fromEntries(
+        Object.entries(r.columns).map(([a, l]) => [a, {
+          type: s(l.type),
+          primaryKey: !!l.primaryKey,
+          notNull: !!l.notNull
+        }])
+      )
+    };
+  }
+  for (const r of i.procedures.values()) {
+    const c = t(r.module);
+    c.procedures[r.name] = {
+      kind: r.kind,
+      name: r.name,
+      module: r.module,
+      args: Object.fromEntries(
+        Object.entries(r.args).map(([a, l]) => [a, s(l)])
+      ),
+      returns: s(r.returns)
+    };
+  }
+  for (const r of i.functions.values()) {
+    const c = t(r.module);
+    c.functions[r.name] = {
+      kind: r.kind,
+      name: r.name,
+      module: r.module,
+      args: Object.fromEntries(
+        Object.entries(r.args).map(([a, l]) => [a, s(l)])
+      ),
+      returns: s(r.returns)
+    };
+  }
+  for (const r of i.views.values()) {
+    const c = t(r.module);
+    c.views[r.name] = {
+      name: r.name,
+      module: r.module,
+      columns: {}
+      // Views might not have analyzed columns yet in all paths
+    };
+  }
+  for (const r of i.types.values()) {
+    const c = t(r.module);
+    c.types[r.name] = {
+      name: r.name,
+      kind: r.type,
+      module: r.module,
+      values: r.values,
+      fields: r.fields ? Object.fromEntries(
+        Object.entries(r.fields).map(([a, l]) => [a, s(l)])
+      ) : void 0
+    };
+  }
+  const n = d.join(e, "dbmason.metadata.json");
+  return p.existsSync(e) || p.mkdirSync(e, { recursive: !0 }), p.writeFileSync(n, JSON.stringify(o, null, 2)), { configPath: n };
+}
+class k {
+  static build(e) {
+    const o = {}, t = new Map([...e.procedures, ...e.functions]);
+    for (const [s, n] of t.entries()) {
+      const r = n.body || "";
+      o[s] = U.createHash("md5").update(r).digest("hex");
+    }
+    return {
+      tables: Object.fromEntries(e.tables),
+      procedures: Object.fromEntries(e.procedures),
+      functions: Object.fromEntries(e.functions),
+      views: Object.fromEntries(e.views),
+      materializedViews: Object.fromEntries(e.materializedViews),
+      types: Object.fromEntries(e.types),
+      crons: Object.fromEntries(e.crons),
+      extensions: Object.fromEntries(e.extensions),
+      roles: Object.fromEntries(e.roles),
+      grants: Object.fromEntries(e.grants),
+      policies: Object.fromEntries(e.policies),
+      triggers: Object.fromEntries(e.triggers),
+      hashes: o
+    };
+  }
+}
+async function K(i, e = {}) {
+  const o = d.resolve(process.cwd(), "dbmason/index.ts");
+  p.existsSync(o) || (console.error("dbmason/index.ts not found."), process.exit(1));
+  try {
+    require("ts-node").register({ transpileOnly: !0 });
+    const t = require(o), s = t.default || t.ctx;
+    let n = t.dialect;
+    if (!(s instanceof P) && s?.constructor?.name !== "DbmasonContext")
+      throw new Error("dbmason/index.ts must export a DbmasonContext.");
+    if (!n && s.config?.dialect && (n = s.config.dialect), !n)
+      throw new Error('dbmason/index.ts must export a "dialect" or pass it to DbmasonContext constructor.');
+    const c = new C(s, n).analyze(), a = d.resolve(process.cwd(), "node_modules/@dbmason/core"), l = d.join(a, ".dbmason-snapshot.json");
+    let h;
+    p.existsSync(l) && (h = JSON.parse(p.readFileSync(l, "utf8")));
+    const f = new D(s, n).compile(h), g = f.split(`
+`).filter((y) => !y.trim().startsWith("--")).join(`
+`).trim();
+    if (g) {
+      if ((g.toLowerCase().includes("drop table") || g.toLowerCase().includes("drop column")) && (e.allowDestructive || (console.error("Destructive changes detected! Use --allow-destructive to confirm."), process.exit(1))), e.dry) {
+        console.log("-- Dry Run Output (No files written) --"), console.log(f);
+        return;
+      }
+      const y = d.resolve(process.cwd(), s.config.paths?.migrations || "migrations");
+      p.existsSync(y) || p.mkdirSync(y, { recursive: !0 });
+      const w = `${Date.now()}_${i || "migration"}.sql`;
+      p.writeFileSync(d.join(y, w), f);
+      const b = k.build(c);
+      p.existsSync(a) || p.mkdirSync(a, { recursive: !0 }), p.writeFileSync(l, JSON.stringify(b, null, 2)), console.log(`Generated migration: ${d.relative(process.cwd(), d.join(y, w))}`);
+    } else
+      console.log("No changes detected.");
+    const T = s.config.paths?.client ? d.resolve(process.cwd(), s.config.paths.client) : process.cwd();
+    G(c, T);
+  } catch (t) {
+    console.error("Generation failed:", t.message), process.exit(1);
+  }
+}
+class Q {
+  constructor(e, o = "migrations") {
+    this.driver = e, this.migrationDir = d.resolve(process.cwd(), o);
+  }
+  async runMigrations() {
+    await this.driver.connect();
+    try {
+      await this.driver.query(`
+                CREATE TABLE IF NOT EXISTS dbmason_migrations (
+                    id SERIAL PRIMARY KEY,
+                    name TEXT NOT NULL UNIQUE,
+                    applied_at TIMESTAMPTZ DEFAULT NOW()
+                );
+            `);
+      const e = await this.driver.query("SELECT name FROM dbmason_migrations"), o = new Set(e.rows.map((s) => s.name));
+      if (!p.existsSync(this.migrationDir)) return;
+      const t = p.readdirSync(this.migrationDir).sort();
+      for (const s of t)
+        if (s.endsWith(".sql") && !o.has(s)) {
+          const n = p.readFileSync(d.join(this.migrationDir, s), "utf-8");
+          console.log(`Running migration: ${s}`), await this.driver.beginTransaction();
+          try {
+            await this.driver.query(n), await this.driver.query("INSERT INTO dbmason_migrations (name) VALUES ($1)", [s]), await this.driver.commitTransaction();
+          } catch (r) {
+            throw await this.driver.rollbackTransaction(), console.error(`Error in migration ${s}:`, r), r;
+          }
+        } else s.endsWith(".sql");
+    } finally {
+      await this.driver.close();
+    }
+  }
+}
+async function Y(i = {}) {
+  const e = d.resolve(process.cwd(), "dbmason/index.ts"), o = d.resolve(process.cwd(), ".env");
+  if (p.existsSync(o)) {
+    const t = p.readFileSync(o, "utf8");
+    for (const s of t.split(`
+`)) {
+      const [n, ...r] = s.split("=");
+      n && r.length > 0 && (process.env[n.trim()] = r.join("=").trim().replace(/^['"]|['"]$/g, ""));
+    }
+  }
+  p.existsSync(e) || (console.error("dbmason/index.ts not found."), process.exit(1));
+  try {
+    require("ts-node").register({ transpileOnly: !0 });
+    const t = require(e), s = t.default || t.ctx;
+    let n = t.dialect;
+    if (!n && s.config?.dialect && (n = s.config.dialect), !n)
+      throw new Error('dbmason/index.ts must export a "dialect" or pass it to DbmasonContext constructor.');
+    const r = s.config?.connectionString || process.env.DATABASE_URL;
+    if (!r)
+      throw new Error("Connection string not found. Please configure it in DbmasonContext or set DATABASE_URL.");
+    const c = n.getDriver(r);
+    console.log("Applying migrations to database...");
+    const a = s.config?.paths?.migrations;
+    await new Q(c, a).runMigrations(), console.log("Migration completed successfully.");
+  } catch (t) {
+    console.error("Migration failed:", t.message), process.exit(1);
+  }
+}
+function X(i, e) {
+  const o = {
+    types: /* @__PURE__ */ new Map()
+  };
+  R(i, o);
+  const t = [
+    "// Generated by @dbmason/core - DO NOT EDIT DIRECTLY",
+    'import { Pool, PoolConfig, QueryResult, QueryResultRow } from "pg";',
+    "",
+    `/**
+ * Base Client Logic (Bundled)
+ */`,
+    te.join(`
+`),
+    "",
+    "/**",
+    " * Internal Helper Types",
+    " */",
+    "export type Trigger = void; // Type alias for procedure returns",
+    "",
+    "/**",
+    " * Database Schema Types & Enums",
+    " */"
+  ];
+  return A(i, t, o), t.push(""), t.push("/**"), t.push(" * Database Table & View Interfaces", " */"), _(i, t, o, ""), t.push(""), t.push("/**"), t.push(" * Typed DbmasonClient", " */"), t.push("export class DbmasonClient extends StandaloneDbmasonClient {"), t.push("    constructor(options?: StandaloneDbmasonClientOptions) {"), t.push("        super(options);"), t.push("    }"), t.push(""), Z(i, t, 1, o), t.push("}"), t.push(""), t.join(`
+`);
+}
+function S(i, e) {
+  const o = i.replace(/['"]/g, ""), t = o.split(".");
+  if (t.length > 1)
+    return O(t.join("_"));
+  const s = e.endsWith("_") ? e : e ? e + "_" : "", n = ee(o);
+  return s && (n.startsWith(s) || o.startsWith(s)) ? O(o) : O(s + o);
+}
+function R(i, e, o = "") {
+  if (i.types)
+    for (const [t, s] of Object.entries(i.types)) {
+      const n = S(t, o);
+      if (e.types.set(t, n), o) {
+        const r = o.replace(/_$/, "").replace(/_/g, ".");
+        e.types.set(`${r}.${t}`, n);
+      }
+    }
+  if (i.modules)
+    for (const [t, s] of Object.entries(i.modules))
+      R(s, e, o + t + "_");
+}
+function A(i, e, o, t = "") {
+  if (i.types)
+    for (const [s, n] of Object.entries(i.types)) {
+      const r = o.types.get(s) || S(s, t);
+      if (n.kind === "enum" && n.values) {
+        const c = n.values.map((a) => `'${a}'`).join(" | ");
+        e.push(`export type ${r} = ${c};`);
+      } else if (n.kind === "composite" && n.fields) {
+        e.push(`export interface ${r} {`);
+        for (const [c, a] of Object.entries(n.fields))
+          e.push(`    ${c}: ${x(a, o, t)};`);
+        e.push("}");
+      }
+    }
+  if (i.modules)
+    for (const [s, n] of Object.entries(i.modules))
+      A(n, e, o, t + s + "_");
+}
+function _(i, e, o, t = "") {
+  const s = { ...i.tables || {}, ...i.views || {} };
+  for (const [n, r] of Object.entries(s)) {
+    const c = r, a = S(n, t);
+    if (e.push(`export interface ${a} {`), c.columns && Object.keys(c.columns).length > 0)
+      for (const [l, h] of Object.entries(c.columns)) {
+        const u = x(h.type, o, t);
+        e.push(`    ${l}${h.notNull ? "" : "?"}: ${u};`);
+      }
+    else
+      e.push("    [key: string]: any;");
+    e.push("}"), e.push("");
+  }
+  if (i.modules)
+    for (const [n, r] of Object.entries(i.modules))
+      _(r, e, o, t + n + "_");
+}
+function Z(i, e, o, t, s = "") {
+  const n = "    ".repeat(o);
+  if (i.tables)
+    for (const [c] of Object.entries(i.tables)) {
+      const a = S(c, s);
+      e.push(`${n}get ${c}() {`), e.push(`${n}    return this.getTableHandler<${a}>("${s ? s.replace(/_/g, ".") + "." + c : c}");`), e.push(`${n}}`), e.push("");
+    }
+  if (i.views)
+    for (const [c] of Object.entries(i.views)) {
+      const a = S(c, s);
+      e.push(`${n}get ${c}() {`), e.push(`${n}    return this.getTableHandler<${a}>("${s ? s.replace(/_/g, ".") + "." + c : c}");`), e.push(`${n}}`), e.push("");
+    }
+  const r = { ...i.procedures || {}, ...i.functions || {} };
+  for (const [c, a] of Object.entries(r)) {
+    const l = L(a, t, s), h = M(a, t, s), u = l === "void" ? "undefined" : "params", f = JSON.stringify(a.args), g = a.kind === "Procedure" && a.returns.toLowerCase() === "void";
+    e.push(`${n}async ${c}(params?: ${l}): Promise<${h}> {`), e.push(`${n}    return this.rpc("${s ? s.replace(/_/g, ".") + "." + c : c}", ${u}, ${f}, ${g}) as any;`), e.push(`${n}}`), e.push("");
+  }
+  if (i.modules)
+    for (const [c, a] of Object.entries(i.modules))
+      e.push(`${n}get ${c}() {`), e.push(`${n}    const self = this;`), e.push(`${n}    return {`), q(a, e, o + 2, t, s ? `${s}.${c}` : c), e.push(`${n}    };`), e.push(`${n}}`), e.push("");
+}
+function q(i, e, o, t, s) {
+  const n = "    ".repeat(o), r = s.replace(/\./g, "_") + "_";
+  if (i.tables)
+    for (const [a] of Object.entries(i.tables)) {
+      const l = S(a, r);
+      e.push(`${n}get ${a}() { return self.getTableHandler<${l}>("${s}.${a}"); },`);
+    }
+  if (i.views)
+    for (const [a] of Object.entries(i.views)) {
+      const l = S(a, r);
+      e.push(`${n}get ${a}() { return self.getTableHandler<${l}>("${s}.${a}"); },`);
+    }
+  const c = { ...i.procedures || {}, ...i.functions || {} };
+  for (const [a, l] of Object.entries(c)) {
+    const h = L(l, t, r), u = M(l, t, r), f = JSON.stringify(l.args), g = l.kind === "Procedure" && l.returns.toLowerCase() === "void";
+    e.push(`${n}${a}(params?: ${h}): Promise<${u}> { return self.rpc("${s}.${a}", params, ${f}, ${g}) as any; },`);
+  }
+  if (i.modules)
+    for (const [a, l] of Object.entries(i.modules))
+      e.push(`${n}get ${a}() {`), e.push(`${n}    return {`), q(l, e, o + 2, t, `${s}.${a}`), e.push(`${n}    };`), e.push(`${n}},`);
+}
+function L(i, e, o) {
+  if (!i.args || Object.keys(i.args).length === 0) return "void";
+  const t = [];
+  for (const [s, n] of Object.entries(i.args)) {
+    const r = n, c = r.toLowerCase().includes("default"), a = r.split(" ")[0];
+    t.push(`${s}${c ? "?" : ""}: ${x(a, e, o)}`);
+  }
+  return `{ ${t.join(", ")} }`;
+}
+function M(i, e, o) {
+  const t = i.returns || "any", s = t.toLowerCase().includes("setof"), n = t.replace(/setof/i, "").replace(/'/g, "").trim(), r = x(n, e, o);
+  return r.toLowerCase() === "trigger" ? "Trigger" : s ? `${r}[]` : r;
+}
+function x(i, e, o = "") {
+  const t = i.toLowerCase().replace(/['"]/g, "").trim();
+  return e.types.has(t) ? e.types.get(t) : t.includes("serial") || t.includes("int") || t.includes("float") || t.includes("double") || t.includes("numeric") || t.includes("decimal") || t.includes("real") || t.includes("money") ? "number" : t.includes("bool") ? "boolean" : t.includes("json") ? "any" : t.includes("date") || t.includes("timestamp") ? "Date | string" : t === "void" ? "void" : ["text", "varchar", "char", "uuid", "bytea", "interval", "xml", "point", "line", "lseg", "box", "path", "polygon", "circle", "cidr", "inet", "macaddr"].some((n) => t.includes(n)) ? "string" : S(t, o);
+}
+function O(i) {
+  return i ? i.replace(/['"]/g, "").split(/[\._-]/).filter(Boolean).map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join("") : "Any";
+}
+function ee(i) {
+  return i.replace(/[A-Z]/g, (e) => `_${e.toLowerCase()}`).replace(/^_/, "");
+}
+const te = [
+  "export interface StandaloneDbmasonClientOptions {",
+  "    returnCase?: 'camel' | 'pascal' | 'snake';",
+  "    poolConfig?: PoolConfig;",
+  "}",
+  "",
+  "export type TableMethods<T> = {",
+  "    create: (data: Partial<T>) => Promise<T[]>;",
+  "    read: (filter?: Partial<T>) => Promise<T[]>;",
+  "    update: (data: Partial<T>, filter: Partial<T>) => Promise<T[]>;",
+  "    delete: (filter: Partial<T>) => Promise<T[]>;",
+  "    list: (options?: { where?: Partial<T>; limit?: number; orderBy?: string }) => Promise<T[]>;",
+  "};",
+  "",
+  "export class StandaloneDbmasonClient {",
+  "    private pool: Pool;",
+  "    private returnCase: 'camel' | 'pascal' | 'snake';",
+  "",
+  "    constructor(options?: StandaloneDbmasonClientOptions) {",
+  "        this.returnCase = options?.returnCase || 'camel';",
+  "        this.pool = new Pool(options?.poolConfig || {",
+  "            connectionString: process.env.DATABASE_URL",
+  "        });",
+  "    }",
+  "",
+  "    protected getTableHandler<T>(tableName: string): TableMethods<T> {",
+  "        return {",
+  "            create: (data: Partial<T>) => this.create<T>(tableName, data),",
+  "            read: (filter?: Partial<T>) => this.read<T>(tableName, filter),",
+  "            update: (data: Partial<T>, filter: Partial<T>) => this.update<T>(tableName, data, filter),",
+  "            delete: (filter: Partial<T>) => this.delete<T>(tableName, filter),",
+  "            list: (options?: { where?: Partial<T> }) => this.read<T>(tableName, options?.where),",
+  "        };",
+  "    }",
+  "",
+  "    async query<T extends QueryResultRow = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {",
+  "        return this.pool.query<T>(sql, params);",
+  "    }",
+  "",
+  "    async sql<T extends QueryResultRow = any>(text: string, params?: any[]): Promise<T[]> {",
+  "        const result = await this.pool.query<T>(text, params);",
+  "        return this.formatReturn(result.rows);",
+  "    }",
+  "",
+  "    async rpc<T = any>(procName: string, params?: Record<string, any>, types?: Record<string, string>, isProcedure?: boolean): Promise<T[]> {",
+  "        const argNames = Object.keys(params || {});",
+  "        const argValues = Object.values(params || {});",
+  "",
+  "        if (argNames.length === 0) {",
+  "            const sql = isProcedure ? `CALL ${procName}()` : `SELECT * FROM ${procName}()`;",
+  "            const result = await this.pool.query(sql);",
+  "            return this.formatReturn(result.rows as T[]);",
+  "        }",
+  "",
+  "        const placeholders = argNames.map((_, i) => {",
+  "            const cast = types && argNames[i] && types[argNames[i]] ? `::${types[argNames[i]]}` : '';",
+  "            return `$${i + 1}${cast}`;",
+  "        }).join(', ');",
+  "        ",
+  "        const sql = isProcedure ? `CALL ${procName}(${placeholders})` : `SELECT * FROM ${procName}(${placeholders})`;",
+  "        const result = await this.pool.query(sql, argValues);",
+  "        return this.formatReturn(result.rows as T[]);",
+  "    }",
+  "",
+  "    async create<T = any>(table: string, data: Partial<T>): Promise<T[]> {",
+  "        return this.rpc<T>(`${table}_create`, { p_input: data });",
+  "    }",
+  "",
+  "    async read<T = any>(table: string, filter: Partial<T> = {}): Promise<T[]> {",
+  "        return this.rpc<T>(`${table}_read`, { p_filter: filter });",
+  "    }",
+  "",
+  "    async update<T = any>(table: string, data: Partial<T>, filter: Partial<T>): Promise<T[]> {",
+  "        return this.rpc<T>(`${table}_update`, { p_input: data, p_filter: filter });",
+  "    }",
+  "",
+  "    async delete<T = any>(table: string, filter: Partial<T>): Promise<T[]> {",
+  "        return this.rpc<T>(`${table}_delete`, { p_filter: filter });",
+  "    }",
+  "",
+  "    private formatReturn<T>(data: T): T {",
+  "        if (this.returnCase === 'snake') return data;",
+  "        return convertKeysDeep(data, this.returnCase) as T;",
+  "    }",
+  "",
+  "    async connect() { return Promise.resolve(); }",
+  "    async disconnect() { return this.close(); }",
+  "",
+  "    async close() {",
+  "        await this.pool.end();",
+  "    }",
+  "}",
+  "",
+  "function convertKeysDeep(obj: any, targetCase: 'camel' | 'pascal' | 'snake'): any {",
+  "    if (Array.isArray(obj)) return obj.map(v => convertKeysDeep(v, targetCase));",
+  "    if (obj !== null && typeof obj === 'object' && !(obj instanceof Date)) {",
+  "        return Object.fromEntries(",
+  "            Object.entries(obj).map(([key, value]) => [",
+  "                convertCase(key, targetCase),",
+  "                convertKeysDeep(value, targetCase)",
+  "            ])",
+  "        );",
+  "    }",
+  "    return obj;",
+  "}",
+  "",
+  "function convertCase(str: string, targetCase: 'camel' | 'pascal' | 'snake'): string {",
+  "    const parts = str.split('_');",
+  "    if (targetCase === 'snake') return parts.join('_');",
+  "    if (targetCase === 'camel') return parts[0] + parts.slice(1).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');",
+  "    if (targetCase === 'pascal') return parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');",
+  "    return str;",
+  "}"
+];
+async function se(i) {
+  const e = d.resolve(process.cwd(), i.config || "src/generated/dbmason.config.json"), o = d.resolve(process.cwd(), i.output || "src/generated-client.ts");
+  p.existsSync(e) || (console.error(`Metadata file not found: ${e}`), console.info('Run "dbmason generate" first to produce the metadata file.'), process.exit(1));
+  try {
+    const t = JSON.parse(p.readFileSync(e, "utf8"));
+    console.log(`Generating ${i.lang || "typescript"} client...`);
+    const s = X(t, {
+      lang: i.lang || "typescript"
+    }), n = d.dirname(o);
+    p.existsSync(n) || p.mkdirSync(n, { recursive: !0 }), p.writeFileSync(o, s), console.log(`Client generated successfully: ${o}`);
+  } catch (t) {
+    console.error("Client generation failed:", t.message), process.exit(1);
+  }
+}
+async function ne(i = {}) {
+  console.log("Starting introspection...");
+  const e = d.resolve(process.cwd(), "dbmason/index.ts");
+  p.existsSync(e) || (console.error("dbmason/index.ts not found."), process.exit(1));
+  const o = d.resolve(process.cwd(), "dbmason/schema.ts");
+  p.existsSync(o) || p.writeFileSync(o, `// Initial empty schema
+`);
+  try {
+    require("ts-node").register({ transpileOnly: !0 });
+    const t = require(e), s = t.default || t.ctx;
+    let n = t.dialect;
+    if (!(s instanceof P) && s?.constructor?.name !== "DbmasonContext")
+      throw new Error("dbmason/index.ts must export a DbmasonContext.");
+    if (!n && s.config?.dialect && (n = s.config.dialect), !n)
+      throw new Error('dbmason/index.ts must export a "dialect" or pass it to DbmasonContext constructor.');
+    if (!n.introspector)
+      throw new Error(`Dialect ${n.name} does not support introspection.`);
+    const r = s.config?.connectionString;
+    if (!r)
+      throw new Error('DbmasonContext must have a "connectionString" configured for introspection.');
+    const c = await n.introspector.introspect(r), a = d.resolve(process.cwd(), "node_modules/@dbmason/core"), l = d.join(a, ".dbmason-snapshot.json");
+    p.existsSync(a) || p.mkdirSync(a, { recursive: !0 }), p.writeFileSync(l, JSON.stringify(c, null, 2)), console.log(`Snapshot saved to ${d.relative(process.cwd(), l)}`);
+    const h = oe(c), u = d.resolve(process.cwd(), "dbmason/schema.ts");
+    p.writeFileSync(u, h), console.log(`Schema written to ${d.relative(process.cwd(), u)}`), delete require.cache[require.resolve(u)], delete require.cache[require.resolve(e)];
+    const f = require(e), g = f.default || f.ctx, y = new C(g, n).analyze(), w = k.build(y);
+    if (p.writeFileSync(l, JSON.stringify(w, null, 2)), i.init) {
+      console.log("Baselining existing schema...");
+      const b = d.resolve(process.cwd(), s.config.paths?.migrations || "migrations");
+      if (!p.existsSync(b))
+        p.mkdirSync(b, { recursive: !0 });
+      else {
+        const z = p.readdirSync(b);
+        for (const E of z)
+          E.endsWith(".sql") && p.unlinkSync(d.join(b, E));
+        console.log("Cleared existing migrations.");
+      }
+      delete require.cache[require.resolve(u)], delete require.cache[require.resolve(e)];
+      const j = require(e), F = j.default || j.ctx, J = new D(F, n).compile(void 0), N = `${Date.now()}_init.sql`;
+      p.writeFileSync(d.join(b, N), J), console.log(`Created baseline migration: ${d.relative(process.cwd(), d.join(b, N))}`);
+      const v = n.getDriver(r);
+      await v.connect();
+      try {
+        await v.query(`
+                    CREATE TABLE IF NOT EXISTS dbmason_migrations (
+                        id SERIAL PRIMARY KEY,
+                        name TEXT NOT NULL UNIQUE,
+                        applied_at TIMESTAMPTZ DEFAULT NOW()
+                    );
+                `), await v.query("INSERT INTO dbmason_migrations (name) VALUES ($1)", [N]), console.log("Marked baseline migration as applied in database.");
+      } finally {
+        await v.close();
+      }
+    }
+  } catch (t) {
+    console.error("Pull failed:", t.message), process.exit(1);
+  }
+}
+const m = (i) => "    ".repeat(i);
+function oe(i) {
+  const e = [], o = /* @__PURE__ */ new Set([
+    "defineTable",
+    "defineView",
+    "defineEnum",
+    "defineFunction",
+    "defineProcedure",
+    "defineTrigger",
+    "text",
+    "integer",
+    "boolean",
+    "timestamp",
+    "jsonb",
+    "uuid",
+    "custom"
+  ]);
+  if (e.push(`import { 
+${m(1)}${Array.from(o).join(`,
+${m(1)}`)}
+} from '@dbmason/postgres';`), e.push(`import ctx from './index';
+`), i.types)
+    for (const [t, s] of Object.entries(i.types)) {
+      const n = s;
+      n.type === "enum" && e.push(`export const ${t} = defineEnum(ctx, '${t}', [${n.values?.map((r) => `'${r}'`).join(", ")}]);
+`);
+    }
+  for (const [t, s] of Object.entries(i.tables)) {
+    if (t === "dbmason_migrations") continue;
+    const n = s;
+    e.push(`export const ${t} = defineTable(ctx, '${t}', {`), e.push(`${m(1)}columns: {`);
+    for (const [a, l] of Object.entries(n.columns || {})) {
+      const h = l;
+      let u = `${m(2)}${a}: `;
+      const f = h.type.toLowerCase();
+      if (f === "text" || f === "varchar" ? u += "text()" : f === "integer" || f === "int4" ? u += "integer()" : f === "boolean" || f === "bool" ? u += "boolean()" : f === "uuid" ? u += "uuid()" : f === "jsonb" ? u += "jsonb()" : f.includes("timestamp") ? u += "timestamp()" : u += `custom('${h.type}')`, h.notNull && (u += ".notNull()"), h.default) {
+        const g = h.default.replace(/"/g, '\\"');
+        u += `.default("${g}")`;
+      }
+      h.primaryKey && (u += ".primaryKey()"), e.push(`${u},`);
+    }
+    e.push(`${m(1)}},`);
+    const r = n.constraints || [], c = n.indexes || [];
+    if (r.length > 0 || c.length > 0) {
+      if (r.length > 0) {
+        e.push(`${m(1)}constraints: [`);
+        for (const a of r) {
+          const l = a;
+          e.push(`${m(2)}{ kind: 'Constraint', type: '${l.type}', name: '${l.name}', definition: \`${l.definition}\`, table: '${t}' },`);
+        }
+        e.push(`${m(1)}],`);
+      }
+      if (c.length > 0) {
+        e.push(`${m(1)}indexes: [`);
+        for (const a of c) {
+          const l = a;
+          e.push(`${m(2)}{ kind: 'Index', name: '${l.name}', table: '${t}', columns: ${JSON.stringify(l.columns)}, unique: ${l.unique} },`);
+        }
+        e.push(`${m(1)}],`);
+      }
+    }
+    e.push(`});
+`);
+  }
+  if (i.views)
+    for (const [t, s] of Object.entries(i.views)) {
+      const n = s;
+      e.push(`export const ${t} = defineView(ctx, '${t}', \`${n.query.replace(/`/g, "\\`")}\`);
+`);
+    }
+  if (i.procedures)
+    for (const [t, s] of Object.entries(i.procedures)) {
+      const n = s;
+      e.push(`export const ${t} = defineProcedure(ctx, '${t}', {`), e.push(`${m(1)}args: ${JSON.stringify(n.args)},`), e.push(`${m(1)}returns: '${n.returns}',`), e.push(`${m(1)}language: '${n.language}',`), e.push(`${m(1)}body: \`${n.body.replace(/`/g, "\\`")}\``), e.push(`});
+`);
+    }
+  if (i.functions)
+    for (const [t, s] of Object.entries(i.functions)) {
+      const n = s;
+      e.push(`export const ${t} = defineFunction(ctx, '${t}', {`), e.push(`${m(1)}args: ${JSON.stringify(n.args)},`), e.push(`${m(1)}returns: '${n.returns}',`), e.push(`${m(1)}language: '${n.language}',`), e.push(`${m(1)}body: \`${n.body.replace(/`/g, "\\`")}\``), e.push(`});
+`);
+    }
+  if (i.triggers)
+    for (const [t, s] of Object.entries(i.triggers)) {
+      const n = s;
+      e.push(`export const ${t} = defineTrigger(ctx, '${n.table}', '${t}', {`), e.push(`${m(1)}events: ${JSON.stringify(n.events)},`), e.push(`${m(1)}procedure: '${n.functionName}',`), e.push(`${m(1)}when: '${n.when}',`), e.push(`${m(1)}forEach: '${n.forEach}'`), e.push(`});
+`);
+    }
+  return e.join(`
+`);
+}
+const $ = new I();
+$.command("pull").description("Introspect database and generate schema").option("--init", "Initialize migration history and create a baseline migration").action((i) => ne(i));
+$.name("dbmason").description("Dbmason Database Management CLI").version("0.2.0");
+$.command("init <projectName>").description("Initialize a new PDK project").option("-t, --template <name>", "Project template to use", "auth.cli.template").action((i, e) => W(i, e));
+$.command("generate [name]").description("Generate migration files").option("--allow-destructive", "Allow generated migrations to include destructive operations").option("-d, --dry", "Dry run (log SQL but do not write files)").action((i, e) => K(i, e));
+$.command("migrate").description("Apply migrations to the database").action((i) => Y(i));
+$.command("client").description("Generate a type-safe database client").option("-c, --config <path>", "Path to dbmason.metadata.json", "dbmason.metadata.json").option("-l, --lang <language>", "Target language (typescript)", "typescript").option("-o, --output <path>", "Output file path", "src/generated-client.ts").action((i) => se(i));
+$.parse(process.argv);
+//# sourceMappingURL=index.mjs.map