easy-ping 0.4.0 → 0.6.0

package/dist/adapters/mysql.cjs

@@ -0,0 +1,605 @@
+'use strict';
+
+// src/core/base64url.ts
+function encodeBase64Url(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64UrlBytes(value) {
+  try {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  } catch {
+    return null;
+  }
+}
+function decodeBase64Url(value) {
+  const bytes = decodeBase64UrlBytes(value);
+  return bytes ? new TextDecoder().decode(bytes) : null;
+}
+
+// src/schema/declaration.ts
+var toSnakeCase = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+var coreSchema = {
+  notification: {
+    tableName: "notification",
+    fields: {
+      id: { type: "string", required: true },
+      userId: { type: "string", required: true },
+      type: { type: "string", required: true },
+      payload: { type: "json", required: true },
+      actorId: { type: "string" },
+      groupKey: { type: "string" },
+      dedupeKey: { type: "string" },
+      seenAt: { type: "date" },
+      readAt: { type: "date" },
+      archivedAt: { type: "date" },
+      createdAt: { type: "date", required: true, defaultNow: true }
+    },
+    primaryKey: ["id"],
+    indexes: [
+      { on: ["userId", "createdAt"], name: "notification_feed_idx" },
+      { on: ["userId", "groupKey"], name: "notification_group_idx" },
+      { on: ["userId", "dedupeKey"], unique: true, name: "notification_dedupe_idx" }
+    ]
+  },
+  notificationDelivery: {
+    tableName: "notification_delivery",
+    fields: {
+      id: { type: "string", required: true },
+      notificationId: { type: "string", required: true },
+      channel: { type: "string", required: true },
+      status: { type: "string", required: true, default: "pending" },
+      attempts: { type: "number", required: true, default: 0 },
+      maxAttempts: { type: "number", required: true, default: 5 },
+      notBefore: { type: "date", required: true, defaultNow: true },
+      claimedAt: { type: "date" },
+      claimedBy: { type: "string" },
+      lastError: { type: "string" },
+      updatedAt: { type: "date", required: true, defaultNow: true }
+    },
+    primaryKey: ["id"],
+    indexes: [
+      { on: ["status", "notBefore"], name: "delivery_claim_idx" },
+      { on: ["notificationId"], name: "delivery_notification_idx" }
+    ]
+  },
+  notificationPreference: {
+    tableName: "notification_preference",
+    fields: {
+      userId: { type: "string", required: true },
+      type: { type: "string", required: true },
+      channel: { type: "string", required: true },
+      enabled: { type: "boolean", required: true, default: true },
+      frequency: { type: "string", required: true, default: "instant" },
+      updatedAt: { type: "date", required: true, defaultNow: true }
+    },
+    primaryKey: ["userId", "type", "channel"]
+  }
+};
+
+// src/core/store.ts
+var OPERATORS = ["in", "lt", "lte", "gt", "gte", "not"];
+var isOperator = (value) => typeof value === "object" && value !== null && !(value instanceof Date) && OPERATORS.some((op) => Object.hasOwn(value, op));
+
+// src/adapters/sql/statement.ts
+var defaultBind = (value) => value instanceof Date ? value.toISOString() : value;
+var Statement = class {
+  #text = "";
+  params = [];
+  #placeholder;
+  #bind;
+  constructor(options = {}) {
+    this.#placeholder = options.placeholder ?? "dollar";
+    this.#bind = options.bind ?? defaultBind;
+  }
+  /** Raw SQL. Never user input; use `value`. */
+  raw(fragment) {
+    this.#text += fragment;
+    return this;
+  }
+  value(value) {
+    this.params.push(this.#bind(value));
+    this.#text += this.#placeholder === "dollar" ? `$${this.params.length}` : "?";
+    return this;
+  }
+  list(values, separator = ", ") {
+    values.forEach((value, index) => {
+      if (index > 0) this.raw(separator);
+      this.value(value);
+    });
+    return this;
+  }
+  /** `($1::text, $2::timestamptz)`. Casts are Postgres-only and dropped elsewhere. */
+  tuple(cells) {
+    this.raw("(");
+    cells.forEach(([value, cast], index) => {
+      if (index > 0) this.raw(", ");
+      this.value(value);
+      if (this.#placeholder === "dollar") this.raw(`::${cast}`);
+    });
+    return this.raw(")");
+  }
+  get text() {
+    return this.#text;
+  }
+};
+var quoteWith = (quoteChar) => (identifier) => `${quoteChar}${identifier.split(quoteChar).join(quoteChar + quoteChar)}${quoteChar}`;
+
+// src/adapters/sql/adapter.ts
+var str = (value) => String(value);
+var nullableStr = (value) => value == null ? null : String(value);
+var num = (value) => Number(value);
+var encodeCursor = (createdAt, id) => encodeBase64Url(`${createdAt.toISOString()}|${id}`);
+function decodeCursor(cursor) {
+  const decoded = decodeBase64Url(cursor);
+  if (!decoded) return null;
+  const [iso, id] = decoded.split("|");
+  if (!iso || !id) return null;
+  const createdAt = new Date(iso);
+  return Number.isNaN(createdAt.getTime()) ? null : { createdAt, id };
+}
+var NONE = { rows: [], affectedRows: 0 };
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function retryingLocks(dialect, attempt) {
+  for (let tries = 0; ; tries += 1) {
+    try {
+      return await attempt();
+    } catch (error) {
+      if (tries >= 5 || !dialect.isRetryableLock(error)) throw error;
+      await sleep(5 + Math.random() * 20 * (tries + 1));
+    }
+  }
+}
+function createSqlAdapter(dialect, exec, options = {}) {
+  const prefix = options.prefix ?? "";
+  const q = dialect.quote;
+  const NOTIFICATION = q(`${prefix}notification`);
+  const DELIVERY = q(`${prefix}notification_delivery`);
+  const stmt = () => new Statement({ placeholder: dialect.placeholder, bind: dialect.bind });
+  const run = (statement, on = exec) => on(statement.text, statement.params);
+  const atomically = (fn) => options.transaction ? options.transaction(fn) : fn(exec);
+  const toNotification = (row) => ({
+    id: str(row.id),
+    userId: str(row.user_id),
+    type: str(row.type),
+    payload: dialect.readJson(row.payload),
+    actorId: nullableStr(row.actor_id),
+    groupKey: nullableStr(row.group_key),
+    dedupeKey: nullableStr(row.dedupe_key),
+    seenAt: dialect.readNullableDate(row.seen_at),
+    readAt: dialect.readNullableDate(row.read_at),
+    archivedAt: dialect.readNullableDate(row.archived_at),
+    createdAt: dialect.readDate(row.created_at)
+  });
+  const toDelivery = (row) => ({
+    id: str(row.id),
+    notificationId: str(row.notification_id),
+    channel: str(row.channel),
+    status: str(row.status),
+    attempts: num(row.attempts),
+    maxAttempts: num(row.max_attempts),
+    notBefore: dialect.readDate(row.not_before),
+    claimedAt: dialect.readNullableDate(row.claimed_at),
+    claimedBy: nullableStr(row.claimed_by),
+    lastError: nullableStr(row.last_error),
+    updatedAt: dialect.readDate(row.updated_at)
+  });
+  function appendWhere(statement, where) {
+    const entries = Object.entries(where);
+    if (entries.length === 0) return;
+    statement.raw(" WHERE ");
+    entries.forEach(([field, condition], index) => {
+      if (index > 0) statement.raw(" AND ");
+      const column = q(toSnakeCase(field));
+      if (condition === null) {
+        statement.raw(`${column} IS NULL`);
+        return;
+      }
+      if (!isOperator(condition)) {
+        statement.raw(`${column} = `).value(condition);
+        return;
+      }
+      const operator = condition;
+      if ("in" in operator) {
+        const list = operator.in;
+        if (list.length === 0) statement.raw("1 = 0");
+        else statement.raw(`${column} IN (`).list(list).raw(")");
+        return;
+      }
+      if ("lt" in operator) statement.raw(`${column} < `).value(operator.lt);
+      else if ("lte" in operator) statement.raw(`${column} <= `).value(operator.lte);
+      else if ("gt" in operator) statement.raw(`${column} > `).value(operator.gt);
+      else if ("gte" in operator) statement.raw(`${column} >= `).value(operator.gte);
+      else if ("not" in operator) {
+        if (operator.not === null) statement.raw(`${column} IS NOT NULL`);
+        else dialect.distinctFrom(statement, column, operator.not);
+      } else statement.raw("1 = 1");
+    });
+  }
+  function eligible(statement, args, now, staleBefore) {
+    statement.raw("(status = 'pending' OR (status = 'claimed' AND claimed_at < ").value(staleBefore).raw(")) AND not_before <= ").value(now).raw(" AND attempts < max_attempts");
+    if (args.channels && args.channels.length > 0) {
+      statement.raw(" AND channel IN (").list(args.channels).raw(")");
+    }
+    if (args.ids && args.ids.length > 0) {
+      statement.raw(" AND id IN (").list(args.ids).raw(")");
+    }
+  }
+  const readClaimed = (token, on) => run(
+    stmt().raw(
+      `SELECT c.id, c.notification_id, c.channel, c.attempts, c.max_attempts, n.user_id, n.type, n.payload, n.actor_id FROM ${DELIVERY} c JOIN ${NOTIFICATION} n ON n.id = c.notification_id WHERE c.claimed_by = `
+    ).value(token).raw(" AND c.status = 'claimed' ORDER BY c.not_before ASC, c.id ASC"),
+    on
+  );
+  return {
+    name: dialect.name,
+    naming: "snake_case",
+    serializesJson: true,
+    async createNotifications(input) {
+      if (input.length === 0) return { created: [], deduped: [] };
+      const now = /* @__PURE__ */ new Date();
+      return atomically(async (on) => {
+        const created = [];
+        const deduped = [];
+        for (const row of input) {
+          if (row.dedupeKey) {
+            const existing = await run(
+              stmt().raw(`SELECT id FROM ${NOTIFICATION} WHERE user_id = `).value(row.userId).raw(" AND dedupe_key = ").value(row.dedupeKey),
+              on
+            );
+            if (existing.rows.length > 0) {
+              deduped.push(row.id);
+              continue;
+            }
+          }
+          try {
+            await run(
+              stmt().raw(
+                `INSERT INTO ${NOTIFICATION} (id, user_id, type, payload, actor_id, group_key, dedupe_key, created_at) VALUES (`
+              ).list([
+                row.id,
+                row.userId,
+                row.type,
+                JSON.stringify(row.payload ?? null),
+                row.actorId ?? null,
+                row.groupKey ?? null,
+                row.dedupeKey ?? null,
+                now
+              ]).raw(")"),
+              on
+            );
+          } catch (error) {
+            if (row.dedupeKey && dialect.isDuplicateKey(error)) {
+              deduped.push(row.id);
+              continue;
+            }
+            throw error;
+          }
+          created.push(row.id);
+        }
+        const createdSet = new Set(created);
+        const deliveries = input.filter((row) => createdSet.has(row.id)).flatMap((row) => row.deliveries.map((delivery) => ({ row, delivery })));
+        if (deliveries.length > 0) {
+          const insert = stmt().raw(
+            `INSERT INTO ${DELIVERY} (id, notification_id, channel, max_attempts, not_before, updated_at) VALUES `
+          );
+          deliveries.forEach(({ row, delivery }, index) => {
+            if (index > 0) insert.raw(", ");
+            insert.raw("(").list([
+              delivery.id,
+              row.id,
+              delivery.channel,
+              delivery.maxAttempts,
+              delivery.notBefore,
+              now
+            ]).raw(")");
+          });
+          await run(insert, on);
+        }
+        return { created, deduped };
+      });
+    },
+    async claimPendingDeliveries(args) {
+      const now = args.now ?? /* @__PURE__ */ new Date();
+      const staleBefore = new Date(now.getTime() - args.leaseMs);
+      const strategy = options.transaction ? dialect.claim.withTransaction : dialect.claim.withoutTransaction;
+      const claimSet = (statement) => statement.raw("status = 'claimed', claimed_at = ").value(now).raw(", claimed_by = ").value(args.claimToken);
+      let result;
+      if (strategy === "skip-locked") {
+        result = await atomically(async (on) => {
+          const pick = stmt().raw(`SELECT id FROM ${DELIVERY} WHERE `);
+          eligible(pick, args, now, staleBefore);
+          pick.raw(" ORDER BY not_before ASC, id ASC LIMIT ").value(args.limit).raw(" FOR UPDATE SKIP LOCKED");
+          const ids = (await run(pick, on)).rows.map((row) => str(row.id));
+          if (ids.length === 0) return NONE;
+          const update = stmt().raw(`UPDATE ${DELIVERY} SET `);
+          claimSet(update).raw(" WHERE id IN (").list(ids).raw(")");
+          await run(update, on);
+          return readClaimed(args.claimToken, on);
+        });
+      } else {
+        const update = stmt();
+        if (strategy === "derived-update") {
+          update.raw(`UPDATE ${DELIVERY} d JOIN (SELECT id FROM ${DELIVERY} WHERE `);
+          eligible(update, args, now, staleBefore);
+          update.raw(" ORDER BY not_before ASC, id ASC LIMIT ").value(args.limit).raw(") s ON s.id = d.id SET d.status = 'claimed', d.claimed_at = ").value(now).raw(", d.claimed_by = ").value(args.claimToken).raw(" WHERE d.status = 'pending' OR (d.status = 'claimed' AND d.claimed_at < ").value(staleBefore).raw(")");
+        } else {
+          update.raw(`UPDATE ${DELIVERY} SET `);
+          claimSet(update).raw(` WHERE id IN (SELECT id FROM ${DELIVERY} WHERE `);
+          eligible(update, args, now, staleBefore);
+          update.raw(" ORDER BY not_before ASC, id ASC LIMIT ").value(args.limit).raw(")");
+        }
+        const updated = await retryingLocks(dialect, () => run(update));
+        result = updated.affectedRows > 0 ? await readClaimed(args.claimToken, exec) : NONE;
+      }
+      return result.rows.map((row) => ({
+        id: str(row.id),
+        notificationId: str(row.notification_id),
+        channel: str(row.channel),
+        attempts: num(row.attempts),
+        maxAttempts: num(row.max_attempts),
+        notification: {
+          userId: str(row.user_id),
+          type: str(row.type),
+          payload: dialect.readJson(row.payload),
+          actorId: nullableStr(row.actor_id)
+        }
+      }));
+    },
+    async releaseDeliveries(releases) {
+      if (releases.length === 0) return;
+      const now = /* @__PURE__ */ new Date();
+      await atomically(async (on) => {
+        for (const { id, outcome, nextAttemptAt } of releases) {
+          const result = outcome.result;
+          const retryable = outcome.result === "failed" && outcome.retryable;
+          const error = outcome.result === "failed" ? outcome.error.slice(0, 2e3) : outcome.result === "skipped" ? outcome.reason.slice(0, 2e3) : null;
+          await run(
+            stmt().raw(`UPDATE ${DELIVERY} SET status = CASE WHEN `).value(result).raw(" = 'sent' THEN 'sent' WHEN ").value(result).raw(" = 'skipped' THEN 'skipped' WHEN ").value(retryable).raw(" = 1 AND attempts + 1 < max_attempts THEN 'pending' ELSE 'failed' END").raw(", attempts = CASE WHEN ").value(result).raw(" IN ('sent', 'skipped') THEN attempts ELSE attempts + 1 END").raw(", last_error = ").value(error).raw(", not_before = COALESCE(").value(nextAttemptAt ?? null).raw(", not_before), claimed_at = NULL, claimed_by = NULL, updated_at = ").value(now).raw(" WHERE id = ").value(id),
+            on
+          );
+        }
+      });
+    },
+    async listNotifications(feed) {
+      const cursor = feed.cursor ? decodeCursor(feed.cursor) : null;
+      const statement = stmt().raw(`SELECT * FROM ${NOTIFICATION} WHERE user_id = `).value(feed.userId).raw(" AND archived_at IS NULL");
+      if (feed.unreadOnly) statement.raw(" AND read_at IS NULL");
+      if (cursor) {
+        statement.raw(" AND (created_at, id) < (").value(cursor.createdAt).raw(", ").value(cursor.id).raw(")");
+      }
+      statement.raw(" ORDER BY created_at DESC, id DESC LIMIT ").value(feed.limit + 1);
+      const { rows } = await run(statement);
+      const page = rows.slice(0, feed.limit).map(toNotification);
+      const last = page.at(-1);
+      return {
+        notifications: page,
+        nextCursor: rows.length > feed.limit && last ? encodeCursor(last.createdAt, last.id) : null
+      };
+    },
+    async countUnseen(userId) {
+      const { rows } = await run(
+        stmt().raw(`SELECT COUNT(*) AS count FROM ${NOTIFICATION} WHERE user_id = `).value(userId).raw(" AND seen_at IS NULL AND archived_at IS NULL")
+      );
+      return num(rows[0]?.count ?? 0);
+    },
+    async markSeen(userId, before) {
+      await run(
+        stmt().raw(`UPDATE ${NOTIFICATION} SET seen_at = `).value(/* @__PURE__ */ new Date()).raw(" WHERE user_id = ").value(userId).raw(" AND seen_at IS NULL AND created_at <= ").value(before)
+      );
+    },
+    async markRead(userId, notificationIds) {
+      if (notificationIds.length === 0) return 0;
+      await run(
+        stmt().raw(`UPDATE ${NOTIFICATION} SET read_at = COALESCE(read_at, `).value(/* @__PURE__ */ new Date()).raw(") WHERE user_id = ").value(userId).raw(" AND id IN (").list(notificationIds).raw(")")
+      );
+      const { rows } = await run(
+        stmt().raw(`SELECT COUNT(*) AS count FROM ${NOTIFICATION} WHERE user_id = `).value(userId).raw(" AND id IN (").list(notificationIds).raw(")")
+      );
+      return num(rows[0]?.count ?? 0);
+    },
+    async markAllRead(userId) {
+      const { affectedRows } = await run(
+        stmt().raw(`UPDATE ${NOTIFICATION} SET read_at = `).value(/* @__PURE__ */ new Date()).raw(" WHERE user_id = ").value(userId).raw(" AND read_at IS NULL")
+      );
+      return affectedRows;
+    },
+    async getFailedDeliveries(args) {
+      const { rows } = await run(
+        stmt().raw(`SELECT * FROM ${DELIVERY} WHERE status = 'failed' AND updated_at >= `).value(args.since).raw(" ORDER BY updated_at DESC LIMIT ").value(args.limit)
+      );
+      return rows.map(toDelivery);
+    },
+    async queryTable(table, where, queryOptions) {
+      const statement = stmt().raw(`SELECT * FROM ${q(table)}`);
+      appendWhere(statement, where);
+      if (queryOptions.orderBy) {
+        const direction = queryOptions.orderBy.direction === "desc" ? "DESC" : "ASC";
+        statement.raw(` ORDER BY ${q(toSnakeCase(queryOptions.orderBy.field))} ${direction}`);
+      }
+      if (queryOptions.limit) statement.raw(" LIMIT ").value(queryOptions.limit);
+      return [...(await run(statement)).rows];
+    },
+    async insertRows(table, rows, onConflict) {
+      if (rows.length === 0) return 0;
+      const columns = Object.keys(rows[0] ?? {});
+      if (columns.length === 0) return 0;
+      const statement = stmt().raw(
+        `INSERT INTO ${q(table)} (${columns.map((c) => q(toSnakeCase(c))).join(", ")}) VALUES `
+      );
+      rows.forEach((row, index) => {
+        if (index > 0) statement.raw(", ");
+        statement.raw("(").list(columns.map((column) => row[column])).raw(")");
+      });
+      if (onConflict && onConflict.length > 0) {
+        statement.raw(
+          dialect.upsertClause(
+            onConflict.map((f) => q(toSnakeCase(f))),
+            columns.filter((c) => !onConflict.includes(c)).map((c) => q(toSnakeCase(c)))
+          )
+        );
+        await run(statement);
+        return rows.length;
+      }
+      return (await run(statement)).affectedRows;
+    },
+    async updateRows(table, where, set) {
+      const assignments = Object.entries(set);
+      if (assignments.length === 0) return 0;
+      const statement = stmt().raw(`UPDATE ${q(table)} SET `);
+      assignments.forEach(([field, value], index) => {
+        if (index > 0) statement.raw(", ");
+        statement.raw(`${q(toSnakeCase(field))} = `).value(value);
+      });
+      appendWhere(statement, where);
+      return (await run(statement)).affectedRows;
+    },
+    async deleteRows(table, where) {
+      const statement = stmt().raw(`DELETE FROM ${q(table)}`);
+      appendWhere(statement, where);
+      return (await run(statement)).affectedRows;
+    }
+  };
+}
+
+// src/adapters/sql/dialect.ts
+var parseUtc = (value) => {
+  if (value instanceof Date) return value;
+  const text = String(value).trim();
+  return new Date(/^\d{4}-\d{2}-\d{2} /.test(text) ? `${text.replace(" ", "T")}Z` : text);
+};
+var readJson = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var bindCommon = (value) => {
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value === void 0) return null;
+  return value;
+};
+var code = (error) => error?.code;
+var errno = (error) => error?.errno;
+var mysqlDialect = {
+  name: "mysql",
+  placeholder: "question",
+  quote: quoteWith("`"),
+  bind: (value) => value instanceof Date ? value.toISOString().slice(0, 23).replace("T", " ") : bindCommon(value),
+  readDate: parseUtc,
+  readNullableDate: (value) => value == null ? null : parseUtc(value),
+  readJson,
+  distinctFrom: (statement, column, value) => {
+    statement.raw(`NOT (${column} <=> `).value(value).raw(")");
+  },
+  // VALUES() rather than the 8.0.19 `AS new` alias: it also works on MariaDB.
+  upsertClause: (conflict, update) => ` ON DUPLICATE KEY UPDATE ${(update.length === 0 ? [`${conflict[0]} = ${conflict[0]}`] : update.map((column) => `${column} = VALUES(${column})`)).join(", ")}`,
+  isDuplicateKey: (error) => code(error) === "ER_DUP_ENTRY" || errno(error) === 1062,
+  isRetryableLock: (error) => code(error) === "ER_LOCK_DEADLOCK" || errno(error) === 1213 || code(error) === "ER_LOCK_WAIT_TIMEOUT" || errno(error) === 1205,
+  claim: { withTransaction: "skip-locked", withoutTransaction: "derived-update" }
+};
+
+// src/adapters/mysql/adapter.ts
+function mysqlAdapter(query, options = {}) {
+  return createSqlAdapter(mysqlDialect, query, options);
+}
+
+// src/schema/render-mysql.ts
+var quote2 = (value) => `\`${value.split("`").join("``")}\``;
+function stringType(field, table, spec) {
+  const keys = [
+    ...table.primaryKey ? [table.primaryKey] : [],
+    ...(table.indexes ?? []).map((index) => index.on)
+  ].filter((columns) => columns.includes(field));
+  if (keys.some((columns) => columns.length > 1)) return "VARCHAR(255)";
+  if (keys.length > 0) return "VARCHAR(768)";
+  if (spec.default !== void 0) return "VARCHAR(255)";
+  return "TEXT";
+}
+function columnType(field, table, spec) {
+  switch (spec.type) {
+    case "string":
+      return stringType(field, table, spec);
+    case "number":
+      return "INT";
+    case "boolean":
+      return "TINYINT(1)";
+    case "date":
+      return "DATETIME(3)";
+    case "json":
+      return "JSON";
+  }
+}
+var defaultClause = (spec) => {
+  if (spec.defaultNow) return " DEFAULT CURRENT_TIMESTAMP(3)";
+  if (spec.default === void 0) return "";
+  if (typeof spec.default === "string") return ` DEFAULT '${spec.default.replace(/'/g, "''")}'`;
+  if (typeof spec.default === "boolean") return ` DEFAULT ${spec.default ? 1 : 0}`;
+  return ` DEFAULT ${spec.default}`;
+};
+function renderMysqlDdl(schema, prefix = "") {
+  const statements = [];
+  for (const table of Object.values(schema)) {
+    const lines = Object.entries(table.fields).map(([field, spec]) => {
+      const nullability = spec.required ? " NOT NULL" : "";
+      return `  ${quote2(toSnakeCase(field))} ${columnType(field, table, spec)}${nullability}${defaultClause(spec)}`;
+    });
+    if (table.primaryKey?.length) {
+      lines.push(
+        `  PRIMARY KEY (${table.primaryKey.map((f) => quote2(toSnakeCase(f))).join(", ")})`
+      );
+    }
+    for (const index of table.indexes ?? []) {
+      const name = quote2(prefix + (index.name ?? `${table.tableName}_${index.on.join("_")}_idx`));
+      const columns = index.on.map((f) => quote2(toSnakeCase(f))).join(", ");
+      lines.push(`  ${index.unique ? "UNIQUE " : ""}INDEX ${name} (${columns})`);
+    }
+    statements.push(
+      `CREATE TABLE IF NOT EXISTS ${quote2(prefix + table.tableName)} (
+${lines.join(",\n")}
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`
+    );
+  }
+  return statements;
+}
+
+// src/adapters/mysql/helpers.ts
+function toResult([result]) {
+  if (Array.isArray(result)) return { rows: result, affectedRows: 0 };
+  const header = result;
+  return { rows: [], affectedRows: Number(header?.affectedRows ?? 0) };
+}
+var mysql2Query = (pool) => async (text, params) => toResult(await pool.query(text, [...params]));
+function mysqlTransaction(pool) {
+  return async (fn) => {
+    const connection = await pool.getConnection();
+    try {
+      await connection.beginTransaction();
+      const result = await fn(
+        async (text, params) => toResult(await connection.query(text, [...params]))
+      );
+      await connection.commit();
+      return result;
+    } catch (error) {
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}
+async function createMysqlTables(query, options = {}) {
+  let count = 0;
+  for (const schema of [coreSchema, ...options.plugins ?? []]) {
+    for (const statement of renderMysqlDdl(schema, options.prefix)) {
+      await query(statement, []);
+      count += 1;
+    }
+  }
+  return count;
+}
+
+exports.createMysqlTables = createMysqlTables;
+exports.mysql2Query = mysql2Query;
+exports.mysqlAdapter = mysqlAdapter;
+exports.mysqlTransaction = mysqlTransaction;
+//# sourceMappingURL=mysql.cjs.map
+//# sourceMappingURL=mysql.cjs.map