@dbmason/mysql 0.1.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,583 @@
+import { createPool as f } from "mysql2/promise";
+import { internalDefineTable as _, resolveColumn as M, internalDefineView as O, internalDefineProcedure as d, internalDefineFunction as L, internalDefineTrigger as h, internalDefineCron as S } from "@dbmason/core";
+import { DbOperation as Re, DbmasonContext as Ie, RoleReference as Ce, TableReference as fe } from "@dbmason/core";
+class I {
+  constructor(e) {
+    this.connection = null, this.pool = f(e);
+  }
+  async connect() {
+    this.connection = await this.pool.getConnection();
+  }
+  async close() {
+    this.connection && (this.connection.release(), this.connection = null), await this.pool.end();
+  }
+  async query(e, n) {
+    if (!this.connection) throw new Error("Driver not connected");
+    const [t] = await this.connection.query(e, n);
+    return t;
+  }
+  async beginTransaction() {
+    if (!this.connection) throw new Error("Driver not connected");
+    await this.connection.beginTransaction();
+  }
+  async commitTransaction() {
+    if (!this.connection) throw new Error("Driver not connected");
+    await this.connection.commit();
+  }
+  async rollbackTransaction() {
+    if (!this.connection) throw new Error("Driver not connected");
+    await this.connection.rollback();
+  }
+}
+class R {
+  static emit(e) {
+    let n = e.type.toUpperCase();
+    n === "BOOLEAN" && (n = "TINYINT(1)"), n === "VARCHAR" && e.length && (n = `VARCHAR(${e.length})`), n === "CHAR" && e.length && (n = `CHAR(${e.length})`), n === "UUID" && (n = "CHAR(36)");
+    let t = `\`${e.name}\` ${n}`;
+    return e.unsigned && (t += " UNSIGNED"), e.notNull && (t += " NOT NULL"), e.default !== void 0 && (t += ` DEFAULT ${e.default}`), e.autoIncrement && (t += " AUTO_INCREMENT"), t;
+  }
+}
+class p {
+  static emit(e, n, t) {
+    switch (e) {
+      case "create":
+        return this.emitCreate(n);
+      case "alter":
+        return this.emitAlter(n, t);
+      case "drop":
+        return `DROP TABLE IF EXISTS \`${n.name}\`;`;
+      default:
+        return "";
+    }
+  }
+  static emitCreate(e) {
+    let t = [...Object.values(e.columns).map((a) => R.emit(a))];
+    const i = Object.values(e.columns).filter((a) => a.primaryKey).map((a) => `\`${a.name}\``);
+    i.length > 0 && t.push(`PRIMARY KEY (${i.join(", ")})`);
+    for (const a of Object.values(e.columns)) {
+      const T = a;
+      if (T.references) {
+        const m = T.references.table, C = T.references.column;
+        let l = `CONSTRAINT \`fk_${e.name}_${a.name}\` FOREIGN KEY (\`${a.name}\`) REFERENCES \`${m}\`(\`${C}\`)`;
+        T.references.onDelete && (l += ` ON DELETE ${T.references.onDelete}`), T.references.onUpdate && (l += ` ON UPDATE ${T.references.onUpdate}`), t.push(l);
+      }
+    }
+    for (const a of e.indexes) {
+      let T = "";
+      a.method === "fulltext" ? T = "FULLTEXT " : a.method === "spatial" ? T = "SPATIAL " : a.unique && (T = "UNIQUE "), t.push(`${T}KEY \`${a.name}\` (${a.columns.map((m) => `\`${m}\``).join(", ")})`);
+    }
+    for (const a of e.constraints)
+      a.type === "check" && t.push(`CONSTRAINT \`${a.name}\` CHECK (${a.definition})`);
+    const o = e.options, s = (o == null ? void 0 : o.engine) || "InnoDB", c = (o == null ? void 0 : o.charset) || "utf8mb4", N = o != null && o.collate ? ` COLLATE=${o.collate}` : "", A = o != null && o.comment ? ` COMMENT='${o.comment}'` : "";
+    return `CREATE TABLE \`${e.name}\` (
+  ${t.join(`,
+  `)}
+) ENGINE=${s} DEFAULT CHARSET=${c}${N}${A};`;
+  }
+  static emitAlter(e, n) {
+    const t = [], i = n == null ? void 0 : n.old;
+    for (const [o, s] of Object.entries(e.columns))
+      i.columns[o] || t.push(`ADD COLUMN ${R.emit(s)}`);
+    return t.length === 0 ? "" : `ALTER TABLE \`${e.name}\`
+  ${t.join(`,
+  `)};`;
+  }
+}
+class w {
+  static emit(e) {
+    return `CREATE OR REPLACE VIEW \`${e.name}\` AS ${e.query};
+`;
+  }
+}
+class D {
+  static emit(e) {
+    const n = Object.entries(e.args).map(([t, i]) => `${t} ${i}`).join(", ");
+    return `DELIMITER //
+CREATE PROCEDURE \`${e.name}\`(${n})
+BEGIN
+${e.body}
+END //
+DELIMITER ;
+`;
+  }
+}
+class y {
+  static emit(e) {
+    const n = Object.entries(e.args).map(([t, i]) => `${t} ${i}`).join(", ");
+    return `DELIMITER //
+CREATE FUNCTION \`${e.name}\`(${n}) RETURNS ${e.returns}
+BEGIN
+${e.body}
+END //
+DELIMITER ;
+`;
+  }
+}
+class U {
+  static emit(e) {
+    const n = e.events.join(" OR ");
+    return `DELIMITER //
+CREATE TRIGGER \`${e.name}\` ${e.when} ${n} ON \`${e.table}\`
+FOR EACH ROW
+BEGIN
+${e.body}
+END //
+DELIMITER ;
+`;
+  }
+}
+class $ {
+  static emit(e) {
+    return `CREATE EVENT \`${e.name}\`
+ON SCHEDULE ${e.schedule}
+DO
+${e.command};
+`;
+  }
+}
+class b {
+  static emit(e) {
+    let n = `-- Generated by @dbmason/mysql
+
+`;
+    for (const t of e)
+      switch (t.node.kind) {
+        case "Table":
+          n += p.emit(t.action, t.node, t.diff) + `
+
+`;
+          break;
+        case "View":
+          n += w.emit(t.node) + `
+
+`;
+          break;
+        case "Procedure":
+          n += D.emit(t.node) + `
+
+`;
+          break;
+        case "Function":
+          n += y.emit(t.node) + `
+
+`;
+          break;
+        case "Trigger":
+          n += U.emit(t.node) + `
+
+`;
+          break;
+        case "Cron":
+          n += $.emit(t.node) + `
+
+`;
+          break;
+        default:
+          console.warn(`Unsupported node kind for MySQL: ${t.node.kind}`);
+      }
+    return n;
+  }
+}
+class g {
+  static async introspect(e) {
+    const n = {}, i = (await e.query("SELECT DATABASE() as db"))[0].db, o = await e.query(`
+            SELECT TABLE_NAME 
+            FROM information_schema.TABLES 
+            WHERE TABLE_SCHEMA = '${i}' 
+            AND TABLE_TYPE = 'BASE TABLE'
+        `);
+    for (const s of o) {
+      const c = s.TABLE_NAME, N = await this.introspectColumns(e, i, c), A = await this.introspectIndexes(e, i, c), a = await this.introspectConstraints(e, i, c);
+      n[c] = {
+        kind: "Table",
+        name: c,
+        module: "global",
+        // MySQL database maps to global scope in Dbmason usually
+        columns: N,
+        indexes: A,
+        constraints: a,
+        policies: [],
+        triggers: []
+      };
+    }
+    return n;
+  }
+  static async introspectColumns(e, n, t) {
+    const i = await e.query(`
+            SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, EXTRA, COLUMN_TYPE
+            FROM information_schema.COLUMNS 
+            WHERE TABLE_SCHEMA = '${n}' AND TABLE_NAME = '${t}'
+            ORDER BY ORDINAL_POSITION
+        `), o = {};
+    for (const c of i)
+      o[c.COLUMN_NAME] = {
+        kind: "Column",
+        name: c.COLUMN_NAME,
+        type: c.DATA_TYPE.toUpperCase(),
+        notNull: c.IS_NULLABLE === "NO",
+        default: c.COLUMN_DEFAULT || void 0,
+        primaryKey: c.COLUMN_KEY === "PRI",
+        // Actually PRI comes from a different column sometimes, better check EXTRA or use another query
+        options: c.EXTRA.includes("auto_increment") ? { identity: !0 } : void 0
+      };
+    const s = await e.query(`
+            SELECT COLUMN_NAME
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE CONSTRAINT_NAME = 'PRIMARY'
+            AND TABLE_SCHEMA = '${n}' AND TABLE_NAME = '${t}'
+        `);
+    for (const c of s)
+      o[c.COLUMN_NAME] && (o[c.COLUMN_NAME].primaryKey = !0);
+    return o;
+  }
+  static async introspectIndexes(e, n, t) {
+    const i = await e.query(`
+            SELECT INDEX_NAME, COLUMN_NAME, NON_UNIQUE
+            FROM information_schema.STATISTICS
+            WHERE TABLE_SCHEMA = '${n}' AND TABLE_NAME = '${t}'
+            ORDER BY INDEX_NAME, SEQ_IN_INDEX
+        `), o = /* @__PURE__ */ new Map();
+    for (const s of i)
+      s.INDEX_NAME !== "PRIMARY" && (o.has(s.INDEX_NAME) || o.set(s.INDEX_NAME, {
+        kind: "Index",
+        name: s.INDEX_NAME,
+        table: t,
+        columns: [],
+        unique: s.NON_UNIQUE === 0
+      }), o.get(s.INDEX_NAME).columns.push(s.COLUMN_NAME));
+    return Array.from(o.values());
+  }
+  static async introspectConstraints(e, n, t) {
+    const i = [], o = await e.query(`
+            SELECT
+                CONSTRAINT_NAME,
+                COLUMN_NAME,
+                REFERENCED_TABLE_NAME,
+                REFERENCED_COLUMN_NAME
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE TABLE_SCHEMA = '${n}' AND TABLE_NAME = '${t}'
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `);
+    for (const N of o) {
+      const A = `FOREIGN KEY (\`${N.COLUMN_NAME}\`) REFERENCES \`${N.REFERENCED_TABLE_NAME}\`(\`${N.REFERENCED_COLUMN_NAME}\`)`;
+      i.push({
+        kind: "Constraint",
+        type: "foreign_key",
+        definition: A,
+        name: N.CONSTRAINT_NAME,
+        table: t
+      });
+    }
+    try {
+      const N = await e.query(`
+                SELECT CONSTRAINT_NAME, CHECK_CLAUSE
+                FROM information_schema.CHECK_CONSTRAINTS
+                WHERE CONSTRAINT_SCHEMA = '${n}'
+                -- Note: CHECK_CONSTRAINTS doesn't always have TABLE_NAME directly in all versions, 
+                -- sometimes joined with TABLE_CONSTRAINTS
+            `), A = 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.TABLE_SCHEMA = '${n}' AND tc.TABLE_NAME = '${t}'
+                AND tc.CONSTRAINT_TYPE = 'CHECK'
+            `);
+      for (const a of A)
+        i.push({
+          kind: "Constraint",
+          type: "check",
+          name: a.CONSTRAINT_NAME,
+          table: t,
+          definition: `CHECK (${a.CHECK_CLAUSE})`
+        });
+    } catch {
+    }
+    const s = await e.query(`
+            SELECT tc.CONSTRAINT_NAME, kcu.COLUMN_NAME
+            FROM information_schema.TABLE_CONSTRAINTS tc
+            JOIN information_schema.KEY_COLUMN_USAGE kcu ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+            WHERE tc.TABLE_SCHEMA = '${n}' AND tc.TABLE_NAME = '${t}'
+            AND tc.CONSTRAINT_TYPE = 'UNIQUE'
+        `), c = /* @__PURE__ */ new Map();
+    for (const N of s)
+      c.has(N.CONSTRAINT_NAME) || c.set(N.CONSTRAINT_NAME, []), c.get(N.CONSTRAINT_NAME).push(N.COLUMN_NAME);
+    for (const [N, A] of c)
+      i.push({
+        kind: "Constraint",
+        type: "unique",
+        name: N,
+        table: t,
+        definition: `UNIQUE (${A.map((a) => `\`${a}\``).join(", ")})`
+      });
+    return i;
+  }
+}
+class k {
+  static async introspect(e) {
+    const n = {}, i = (await e.query("SELECT DATABASE() as db"))[0].db, o = await e.query(`
+            SELECT TABLE_NAME, VIEW_DEFINITION
+            FROM information_schema.VIEWS
+            WHERE TABLE_SCHEMA = '${i}'
+        `);
+    for (const s of o)
+      n[s.TABLE_NAME] = {
+        kind: "View",
+        name: s.TABLE_NAME,
+        query: s.VIEW_DEFINITION
+      };
+    return { views: n, materializedViews: {} };
+  }
+}
+class B {
+  static async introspect(e) {
+    const n = {}, t = {}, o = (await e.query("SELECT DATABASE() as db"))[0].db, s = await e.query(`
+            SELECT ROUTINE_NAME, ROUTINE_TYPE, DTD_IDENTIFIER, ROUTINE_DEFINITION, EXTERNAL_LANGUAGE
+            FROM information_schema.ROUTINES
+            WHERE ROUTINE_SCHEMA = '${o}'
+        `);
+    for (const c of s) {
+      const N = c.ROUTINE_NAME, A = c.ROUTINE_TYPE, a = await e.query(`
+                SELECT PARAMETER_NAME, DATA_TYPE, PARAMETER_MODE
+                FROM information_schema.PARAMETERS
+                WHERE SPECIFIC_SCHEMA = '${o}' AND ROUTINE_NAME = '${N}'
+                ORDER BY ORDINAL_POSITION
+            `), T = {};
+      for (const m of a)
+        m.PARAMETER_NAME && (T[m.PARAMETER_NAME] = m.DATA_TYPE);
+      A === "FUNCTION" ? n[N] = {
+        kind: "Function",
+        name: N,
+        args: T,
+        returns: c.DTD_IDENTIFIER,
+        language: c.EXTERNAL_LANGUAGE || "SQL",
+        body: c.ROUTINE_DEFINITION
+      } : t[N] = {
+        kind: "Procedure",
+        name: N,
+        args: T,
+        returns: "void",
+        language: c.EXTERNAL_LANGUAGE || "SQL",
+        body: c.ROUTINE_DEFINITION
+      };
+    }
+    return { functions: n, procedures: t };
+  }
+}
+class F {
+  static async introspect(e) {
+    const n = {}, i = (await e.query("SELECT DATABASE() as db"))[0].db, o = await e.query(`
+            SELECT TRIGGER_NAME, EVENT_OBJECT_TABLE, ACTION_TIMING, EVENT_MANIPULATION, ACTION_STATEMENT
+            FROM information_schema.TRIGGERS
+            WHERE TRIGGER_SCHEMA = '${i}'
+        `);
+    for (const s of o)
+      n[s.TRIGGER_NAME] = {
+        kind: "Trigger",
+        name: s.TRIGGER_NAME,
+        table: s.EVENT_OBJECT_TABLE,
+        events: [s.EVENT_MANIPULATION.toLowerCase()],
+        functionName: "inline",
+        // MySQL triggers are inline SQL
+        when: s.ACTION_TIMING.toLowerCase(),
+        forEach: "ROW",
+        // MySQL triggers are always FOR EACH ROW
+        body: s.ACTION_STATEMENT
+      };
+    return n;
+  }
+}
+class H {
+  async introspect(e) {
+    const n = new I(e);
+    await n.connect();
+    try {
+      const t = await g.introspect(n), { views: i, materializedViews: o } = await k.introspect(n), { functions: s, procedures: c } = await B.introspect(n), N = await F.introspect(n);
+      return {
+        tables: t,
+        procedures: c,
+        functions: s,
+        views: i,
+        materializedViews: o,
+        types: {},
+        // MySQL ENUMs are column-level
+        crons: {},
+        extensions: {},
+        roles: {},
+        grants: {},
+        policies: {},
+        triggers: N,
+        hashes: {}
+      };
+    } finally {
+      await n.close();
+    }
+  }
+}
+class q {
+  constructor() {
+    this.name = "mysql", this.introspector = new H();
+  }
+  setContext(e) {
+    this.ctx = e;
+  }
+  analyzeTable(e) {
+    return {
+      ...e,
+      indexes: e.indexes,
+      dependencies: [],
+      rls: { enabled: !1, policies: [] }
+    };
+  }
+  emit(e) {
+    return b.emit(e);
+  }
+  getDriver(e) {
+    return new I(e);
+  }
+}
+function u(E) {
+  return E.map((e) => M(e).column);
+}
+const x = (...E) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: u(E),
+  method: "btree"
+}), K = (...E) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: u(E),
+  method: "hash"
+}), V = (...E) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: u(E),
+  method: "fulltext"
+}), W = (...E) => ({
+  kind: "Index",
+  name: "",
+  table: "",
+  columns: u(E),
+  method: "spatial"
+});
+class r {
+  constructor(e) {
+    this.node = e;
+  }
+  primaryKey() {
+    return new r({ ...this.node, primaryKey: !0, notNull: !0 });
+  }
+  notNull() {
+    return new r({ ...this.node, notNull: !0 });
+  }
+  unique() {
+    return new r({ ...this.node, unique: !0 });
+  }
+  default(e) {
+    return new r({ ...this.node, default: e });
+  }
+  autoIncrement() {
+    return new r({ ...this.node, autoIncrement: !0 });
+  }
+  unsigned() {
+    return new r({ ...this.node, unsigned: !0 });
+  }
+  onUpdateCurrentTimestamp() {
+    return new r({ ...this.node, onUpdate: "CURRENT_TIMESTAMP" });
+  }
+  charset(e) {
+    return new r({ ...this.node, charset: e });
+  }
+  collate(e) {
+    return new r({ ...this.node, collate: e });
+  }
+  check(e) {
+    return new r({ ...this.node, check: e });
+  }
+  references(e, n, t) {
+    let i, o, s;
+    return typeof e != "string" ? (i = e.tableName, o = e.columnName, s = n) : (i = e, o = n, s = t), new r({
+      ...this.node,
+      references: {
+        module: e.moduleName,
+        table: i,
+        column: o,
+        onDelete: s == null ? void 0 : s.onDelete,
+        onUpdate: s == null ? void 0 : s.onUpdate
+      }
+    });
+  }
+  build() {
+    return this.node;
+  }
+}
+const P = () => new r({ kind: "Column", name: "", type: "INT" }), j = P, v = () => new r({ kind: "Column", name: "", type: "TINYINT" }), X = () => new r({ kind: "Column", name: "", type: "SMALLINT" }), Q = () => new r({ kind: "Column", name: "", type: "MEDIUMINT" }), J = () => new r({ kind: "Column", name: "", type: "BIGINT" }), z = (E = 255) => new r({ kind: "Column", name: "", type: "VARCHAR", length: E }), Z = () => new r({ kind: "Column", name: "", type: "TEXT" }), ee = (E = 1) => new r({ kind: "Column", name: "", type: "CHAR", length: E }), ne = () => new r({ kind: "Column", name: "", type: "DATE" }), te = () => new r({ kind: "Column", name: "", type: "DATETIME" }), oe = () => new r({ kind: "Column", name: "", type: "TIMESTAMP" }), se = () => new r({ kind: "Column", name: "", type: "TIME" }), Ee = () => new r({ kind: "Column", name: "", type: "YEAR" }), ie = () => new r({ kind: "Column", name: "", type: "BOOLEAN" }), ce = () => new r({ kind: "Column", name: "", type: "JSON" });
+function ae(E, e, n) {
+  return _(E, e, n, (t) => {
+    const i = {};
+    for (const [o, s] of Object.entries(t))
+      if (s instanceof r) {
+        const c = s.build();
+        c.name = o, i[o] = c;
+      } else typeof s == "string" ? i[o] = { kind: "Column", name: o, type: s } : i[o] = { ...s, name: o };
+    return i;
+  });
+}
+function re(E, e, n) {
+  O(E, e, n);
+}
+function Ne(E, e, n, t) {
+  d(E, e, { args: n, body: t, language: "SQL" });
+}
+function Te(E, e, n, t, i) {
+  L(E, e, { args: n, returns: t, body: i, language: "SQL" });
+}
+function Ae(E, e, n) {
+  h(E, n.table, e, {
+    when: n.timing,
+    events: [n.event],
+    body: n.body,
+    forEach: "ROW"
+  });
+}
+function me(E, e, n, t) {
+  S(E, e, n, t);
+}
+export {
+  Re as DbOperation,
+  Ie as DbmasonContext,
+  r as MysqlColumnBuilder,
+  q as MysqlDialect,
+  Ce as RoleReference,
+  fe as TableReference,
+  J as bigint,
+  ie as boolean,
+  x as btree,
+  ee as char,
+  ne as date,
+  te as datetime,
+  me as defineEvent,
+  Te as defineFunction,
+  Ne as defineProcedure,
+  ae as defineTable,
+  Ae as defineTrigger,
+  re as defineView,
+  V as fulltext,
+  K as hash,
+  P as int,
+  j as integer,
+  ce as json,
+  Q as mediumint,
+  X as smallint,
+  W as spatial,
+  Z as text,
+  se as time,
+  oe as timestamp,
+  v as tinyint,
+  z as varchar,
+  Ee as year
+};
+//# sourceMappingURL=index.mjs.map