opacacms 0.3.18 → 0.3.19

package/dist/db/d1.js

@@ -1,33 +1,2325 @@
-import {
-  buildKyselyWhere,
-  flattenPayload,
-  pushSchema,
-  unflattenRow
-} from "../chunk-re459gm9.js";
-import {
-  requestContext
-} from "../chunk-q5sb5dcr.js";
-import {
-  flattenFields,
-  getRelationalFields,
-  toSnakeCase
-} from "../chunk-5xpf5jxd.js";
-import {
-  logger
-} from "../chunk-jq1drsen.js";
-import"../chunk-h8v093av.js";
-import {
-  BaseDatabaseAdapter
-} from "../chunk-s8mqwnm1.js";
-import {
-  __require
-} from "../chunk-8sqjbsgt.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/db/kysely/field-mapper.ts
+function toSnakeCase(str) {
+  const res = str.replace(/([A-Z])/g, "_$1").toLowerCase();
+  if (res.startsWith("_") && !str.startsWith("_")) {
+    return res.slice(1);
+  }
+  return res;
+}
+function mapFieldToPostgresType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+      return "text";
+    case "number":
+      return "double precision";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "timestamptz";
+    case "json":
+    case "file":
+      return "jsonb";
+    default:
+      return "text";
+  }
+}
+function mapFieldToSQLiteType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+    case "date":
+    case "json":
+    case "file":
+      return "text";
+    case "number":
+      return "numeric";
+    case "boolean":
+      return "integer";
+    default:
+      return "text";
+  }
+}
+function flattenFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "join" || field.type === "virtual" || field.type === "ui")
+      continue;
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "group") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = currentName ? `${currentName}__` : "";
+        result.push(...flattenFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "blocks") {
+      continue;
+    }
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+      continue;
+    }
+    if (currentName) {
+      result.push({ ...field, name: currentName });
+    }
+    if (field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        result.push(...flattenFields(field.fields, prefix));
+      }
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...flattenFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+function getRelationalFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany || field.type === "blocks") {
+      if (currentName) {
+        result.push({ ...field, name: currentName });
+      }
+      continue;
+    }
+    if (field.type === "group" || field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = field.type === "group" && field.name ? `${currentName}__` : prefix;
+        result.push(...getRelationalFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...getRelationalFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/utils/context.ts
+var {AsyncLocalStorage} = (() => ({}));
+function getUserIdFromContext() {
+  return requestContext.getStore()?.userId || null;
+}
+function getPreviousDataFromContext() {
+  return requestContext.getStore()?.previousData || null;
+}
+var GLOBAL_CONTEXT_KEY, requestContext;
+var init_context = __esm(() => {
+  GLOBAL_CONTEXT_KEY = Symbol.for("opacacms.requestContext");
+  if (!globalThis[GLOBAL_CONTEXT_KEY]) {
+    globalThis[GLOBAL_CONTEXT_KEY] = new AsyncLocalStorage;
+  }
+  requestContext = globalThis[GLOBAL_CONTEXT_KEY];
+});
+
+// src/db/kysely/plugins/audit-logging.ts
+class AuditLoggingPlugin {
+  auditTable;
+  getUserId;
+  db;
+  queryNodes = new WeakMap;
+  constructor(config = {}) {
+    this.auditTable = config.auditTable || "_audit_logs";
+    this.getUserId = config.getUserId;
+  }
+  setDb(db) {
+    this.db = db;
+  }
+  transformQuery(args) {
+    this.queryNodes.set(args.queryId, args.node);
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result, queryId } = args;
+    const queryNode = this.queryNodes.get(queryId);
+    this.queryNodes.delete(queryId);
+    if (!queryNode || queryNode.kind === "SelectQueryNode")
+      return result;
+    let tableName = "";
+    let operation = "other";
+    if (queryNode.kind === "InsertQueryNode") {
+      tableName = this.getTableName(queryNode.into);
+      operation = "create";
+    } else if (queryNode.kind === "UpdateQueryNode") {
+      tableName = this.getTableName(queryNode.table);
+      operation = "update";
+    } else if (queryNode.kind === "DeleteQueryNode") {
+      tableName = this.getTableName(queryNode.table || queryNode.from?.froms?.[0]);
+      operation = "delete";
+    }
+    if (!tableName || tableName === this.auditTable)
+      return result;
+    const stashedPrevious = getPreviousDataFromContext();
+    this.logOperation(operation, tableName, queryNode, result, stashedPrevious).catch((err) => {
+      console.error("[OpacaCMS] Audit logging failed:", err);
+    });
+    return result;
+  }
+  getTableName(node) {
+    if (!node)
+      return "";
+    if (node.kind === "TableNode") {
+      return node.table?.identifier?.name || node.table?.name || "";
+    }
+    if (node.table?.kind === "TableNode") {
+      return node.table.table?.identifier?.name || node.table.table?.name || "";
+    }
+    return node.table?.name || node.table?.identifier?.name || node.name || "";
+  }
+  async logOperation(operation, collection, queryNode, result, stashedPrevious = null) {
+    if (!this.db) {
+      console.warn("[OpacaCMS] AuditLoggingPlugin: No database instance set, skipping log.");
+      return;
+    }
+    try {
+      let entityId = "unknown";
+      let newData = null;
+      let previousData = null;
+      if (queryNode.kind === "InsertQueryNode") {
+        entityId = result.insertId?.toString() || "new";
+        const columns = queryNode.columns;
+        const valuesNode = queryNode.values;
+        if (Array.isArray(columns) && valuesNode?.kind === "ValuesNode") {
+          const row = valuesNode.values?.[0]?.values;
+          if (Array.isArray(row)) {
+            newData = {};
+            for (let i = 0;i < columns.length; i++) {
+              const col = columns[i]?.column?.name || columns[i]?.name;
+              if (col) {
+                const node = row[i];
+                newData[col] = node?.value !== undefined ? node.value : node?.name || node?.identifier?.name || null;
+              }
+            }
+          }
+        }
+        if ((entityId === "new" || entityId === "unknown") && stashedPrevious?.id) {
+          entityId = stashedPrevious.id.toString();
+        }
+      } else if (queryNode.kind === "UpdateQueryNode") {
+        entityId = "updated";
+        const where = queryNode.where;
+        const filter = where?.where;
+        if (filter?.kind === "BinaryOperationNode") {
+          const op = filter;
+          const leftNode = op.left;
+          const leftName = leftNode?.column?.name || leftNode?.name || leftNode?.identifier?.name;
+          if (op.operator?.operator === "=" && leftName === "id") {
+            const right = op.right;
+            entityId = (right?.value !== undefined ? right.value : right?.name || right?.identifier?.name)?.toString() || "updated";
+          }
+        }
+        if (entityId === "updated" && stashedPrevious?.id) {
+          entityId = stashedPrevious.id.toString();
+        }
+        const updates = queryNode.updates;
+        if (Array.isArray(updates)) {
+          newData = {};
+          for (const upd of updates) {
+            const col = upd.column?.column?.name || upd.column?.name;
+            if (col) {
+              const valNode = upd.value;
+              newData[col] = valNode?.value !== undefined ? valNode.value : valNode?.name || valNode?.identifier?.name || null;
+            }
+          }
+        }
+        if (entityId !== "updated" && entityId !== "unknown") {
+          previousData = stashedPrevious;
+          if (previousData) {
+            console.debug(`[AuditLoggingPlugin] Used stashed previous data for ${entityId}`);
+          }
+          if (!previousData) {
+            previousData = getPreviousDataFromContext();
+          }
+          if (!previousData) {
+            try {
+              previousData = await this.db.selectFrom(collection).selectAll().where("id", "=", entityId).executeTakeFirst();
+              if (previousData) {
+                console.debug(`[AuditLoggingPlugin] Fallback SELECT fetched data for ${entityId}`);
+              }
+            } catch (e) {}
+          }
+        }
+      } else if (queryNode.kind === "DeleteQueryNode") {
+        entityId = "deleted";
+      }
+      await this.db.insertInto(this.auditTable).values({
+        id: crypto.randomUUID(),
+        operation,
+        collection,
+        entity_id: entityId,
+        user_id: (this.getUserId ? this.getUserId() : null) || getUserIdFromContext(),
+        previous_data: previousData ? JSON.stringify(previousData) : null,
+        new_data: newData ? JSON.stringify(newData) : "{}",
+        timestamp: new Date().toISOString(),
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString()
+      }).execute();
+    } catch (err) {
+      console.error("[OpacaCMS] Failed to write audit log:", err);
+    }
+  }
+}
+var init_audit_logging = __esm(() => {
+  init_context();
+});
+
+// src/db/kysely/plugins/auto-timestamps.ts
+class AutoTimestampsPlugin {
+  createdAtColumn;
+  updatedAtColumn;
+  constructor(config = {}) {
+    this.createdAtColumn = config.createdAtColumn || "created_at";
+    this.updatedAtColumn = config.updatedAtColumn || "updated_at";
+  }
+  transformQuery(args) {
+    const { node } = args;
+    const now = new Date().toISOString();
+    if (node.kind === "InsertQueryNode") {} else if (node.kind === "UpdateQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+}
+
+// src/db/kysely/plugins/cursor-pagination.ts
+class CursorPaginationPlugin {
+  after;
+  cursorColumn;
+  constructor(config) {
+    this.after = config.after;
+    this.cursorColumn = config.cursorColumn || "id";
+  }
+  transformQuery(args) {
+    if (this.after === undefined)
+      return args.node;
+    const { node } = args;
+    if (node.kind === "SelectQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+}
+
+// src/db/kysely/plugins/deadlock-handler.ts
+class DeadlockRetryPlugin {
+  maxRetries;
+  initialDelay;
+  constructor(config) {
+    this.maxRetries = config.maxRetries ?? 3;
+    this.initialDelay = config.initialDelay ?? 50;
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+  async retry(fn) {
+    let lastError;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        const isLockError = error?.message?.includes("SQLITE_BUSY") || error?.message?.includes("database is locked") || error?.code === "SQLITE_BUSY";
+        if (!isLockError || attempt >= this.maxRetries) {
+          throw error;
+        }
+        const delay = this.initialDelay * 2 ** attempt;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+}
+
+// src/db/kysely/plugins/draft-swapper.ts
+class DraftSwapperPlugin {
+  draftMode;
+  tables;
+  constructor(config) {
+    this.draftMode = config.draftMode ?? false;
+    const allSlugs = [
+      ...config.collections?.map((c) => c.slug) || [],
+      ...config.globals?.map((g) => g.slug) || []
+    ];
+    this.tables = new Set(allSlugs.map((s) => toSnakeCase(s)));
+  }
+  transformQuery(args) {
+    if (!this.draftMode)
+      return args.node;
+    const { node } = args;
+    if (node.kind === "SelectQueryNode") {
+      if (node.from && node.from.froms) {
+        let shouldSwap = false;
+        let originalTable = "";
+        const newFroms = node.from.froms.map((f) => {
+          if (f.kind === "TableNode" && f.table && f.table.kind === "IdentifierNode") {
+            const tableName = f.table.name;
+            if (this.tables?.has(tableName)) {
+              shouldSwap = true;
+              originalTable = tableName;
+              return {
+                ...f,
+                table: {
+                  ...f.table,
+                  name: "_doc_versions"
+                }
+              };
+            }
+          }
+          return f;
+        });
+        if (shouldSwap) {
+          node.from.froms = newFroms;
+        }
+      }
+    }
+    return node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (!this.draftMode || result.rows.length === 0)
+      return result;
+    if (result.rows[0] && "data" in result.rows[0] && "collection" in result.rows[0]) {
+      const mappedRows = result.rows.map((row) => {
+        try {
+          const parsedData = typeof row.data === "string" ? JSON.parse(row.data) : row.data;
+          return {
+            ...parsedData,
+            _version_id: row.id,
+            _version_status: row.status,
+            _version_createdAt: row.createdAt
+          };
+        } catch {
+          return row;
+        }
+      });
+      return { ...result, rows: mappedRows };
+    }
+    return result;
+  }
+}
+var init_draft_swapper = () => {};
+
+// src/db/kysely/plugins/field-masking.ts
+class FieldMaskingPlugin {
+  maskedFields = new Map;
+  disabled;
+  constructor(config) {
+    this.disabled = config.disabled ?? false;
+    this.parseConfig(config);
+  }
+  parseConfig(config) {
+    const allResources = [...config.collections, ...config.globals || []];
+    for (const res of allResources) {
+      if (res.slug.startsWith("_"))
+        continue;
+      const tableName = toSnakeCase(res.slug);
+      const fields = new Set;
+      const findMaskedFields = (fieldList) => {
+        for (const f of fieldList) {
+          if (f.name && (f.admin?.hidden === true || f.type === "password")) {
+            fields.add(toSnakeCase(f.name));
+          }
+          if ("fields" in f && Array.isArray(f.fields)) {
+            findMaskedFields(f.fields);
+          }
+        }
+      };
+      findMaskedFields(res.fields);
+      if (fields.size > 0) {
+        this.maskedFields.set(tableName, fields);
+      }
+    }
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (this.disabled)
+      return result;
+    return {
+      ...result,
+      rows: result.rows.map((row) => this.maskRow(row))
+    };
+  }
+  maskRow(row) {
+    if (!row)
+      return row;
+    const newRow = { ...row };
+    for (const [_, fields] of this.maskedFields.entries()) {
+      for (const field of fields) {
+        if (field in newRow) {
+          if (field.includes("password") || field.includes("hash")) {
+            newRow[field] = "********";
+          } else {
+            delete newRow[field];
+          }
+        }
+      }
+    }
+    return newRow;
+  }
+}
+var init_field_masking = () => {};
+
+// src/db/kysely/plugins/fts-normalizer.ts
+class FtsNormalizerPlugin {
+  dialect;
+  constructor(config) {
+    this.dialect = config.dialect;
+  }
+  transformQuery(args) {
+    const { node } = args;
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+}
+
+// src/db/kysely/plugins/i18n-fallback.ts
+class AutoTranslationFallbackPlugin {
+  localizedFields = new Map;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.parseConfig(config);
+  }
+  parseConfig(config) {
+    const allResources = [...config.collections, ...config.globals || []];
+    for (const res of allResources) {
+      const tableName = toSnakeCase(res.slug);
+      const fields = new Set;
+      const findLocalizedFields = (fieldList) => {
+        for (const f of fieldList) {
+          if (f.name && f.localized) {
+            fields.add(toSnakeCase(f.name));
+          }
+          if ("fields" in f && Array.isArray(f.fields)) {
+            findLocalizedFields(f.fields);
+          }
+        }
+      };
+      findLocalizedFields(res.fields);
+      if (fields.size > 0) {
+        this.localizedFields.set(tableName, fields);
+      }
+    }
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (this.config.defaultLocale === this.config.currentLocale)
+      return result;
+    return {
+      ...result,
+      rows: result.rows.map((row) => this.fallbackRow(row))
+    };
+  }
+  fallbackRow(row) {
+    if (!row)
+      return row;
+    const newRow = { ...row };
+    const currentLocSuffix = `_${this.config.currentLocale}`;
+    const defaultLocSuffix = `_${this.config.defaultLocale}`;
+    for (const [key, value] of Object.entries(newRow)) {
+      if (key.endsWith(currentLocSuffix)) {
+        const baseName = key.slice(0, -currentLocSuffix.length);
+        const defaultValueKey = `${baseName}${defaultLocSuffix}`;
+        if ((value === null || value === "" || value === undefined) && newRow[defaultValueKey] !== undefined) {
+          newRow[key] = newRow[defaultValueKey];
+        }
+      }
+    }
+    return newRow;
+  }
+}
+var init_i18n_fallback = () => {};
+
+// src/db/kysely/plugins/id-generation.ts
+class IdGenerationPlugin {
+  generateId;
+  idColumn;
+  constructor(config = {}) {
+    this.generateId = config.generateId || (() => crypto.randomUUID());
+    this.idColumn = config.idColumn || "id";
+  }
+  transformQuery(args) {
+    const { node } = args;
+    if (node.kind === "InsertQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+}
+
+// src/db/kysely/plugins/json-flattener.ts
+class JsonFlattenerPlugin {
+  jsonFields = new Map;
+  constructor(config) {
+    this.parseConfig(config);
+  }
+  parseConfig(config) {
+    const allResources = [...config.collections, ...config.globals || []];
+    for (const res of allResources) {
+      const tableName = toSnakeCase(res.slug);
+      const fields = new Set;
+      const findJsonFields = (fieldList) => {
+        for (const f of fieldList) {
+          if (f.name && (["richtext", "json", "file", "blocks"].includes(f.type) || f.localized)) {
+            fields.add(toSnakeCase(f.name));
+          }
+          if ("fields" in f && Array.isArray(f.fields)) {
+            findJsonFields(f.fields);
+          }
+          if ("blocks" in f && Array.isArray(f.blocks)) {
+            for (const b of f.blocks) {
+              if (b.fields)
+                findJsonFields(b.fields);
+            }
+          }
+          if ("tabs" in f && Array.isArray(f.tabs)) {
+            for (const t of f.tabs) {
+              if (t.fields)
+                findJsonFields(t.fields);
+            }
+          }
+        }
+      };
+      findJsonFields(res.fields);
+      if (fields.size > 0) {
+        this.jsonFields.set(tableName, fields);
+      }
+    }
+  }
+  transformQuery(args) {
+    const { node } = args;
+    if (node.kind === "InsertQueryNode" || node.kind === "UpdateQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    return {
+      ...result,
+      rows: result.rows.map((row) => this.mapRow(row))
+    };
+  }
+  mapRow(row) {
+    if (!row)
+      return row;
+    const newRow = { ...row };
+    const isSystemTable = Object.keys(newRow).some((k) => k.startsWith("_"));
+    if (isSystemTable)
+      return newRow;
+    for (const [key, value] of Object.entries(newRow)) {
+      if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+        try {
+          newRow[key] = JSON.parse(value);
+        } catch (_e) {}
+      }
+    }
+    return newRow;
+  }
+}
+var init_json_flattener = () => {};
+
+// src/db/kysely/plugins/relationship-preloading.ts
+class RelationshipPreloadingPlugin {
+  maxDepth;
+  constructor(config = {}) {
+    this.maxDepth = config.maxDepth ?? 2;
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (result.rows.length === 0)
+      return result;
+    return result;
+  }
+}
+
+// src/db/kysely/plugins/slug-generation.ts
+class SlugGenerationPlugin {
+  sourceColumn;
+  slugColumn;
+  constructor(config = {}) {
+    this.sourceColumn = config.sourceColumn || "title";
+    this.slugColumn = config.slugColumn || "slug";
+  }
+  transformQuery(args) {
+    const { node } = args;
+    if (node.kind === "InsertQueryNode" || node.kind === "UpdateQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+  slugify(text) {
+    return text.toString().toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+}
+
+// src/db/kysely/plugins/soft-delete.ts
+class SoftDeletePlugin {
+  deletedAtColumn;
+  tables;
+  constructor(config = {}) {
+    this.deletedAtColumn = config.deletedAtColumn || "deleted_at";
+    this.tables = config.tables ? new Set(config.tables) : null;
+  }
+  transformQuery(args) {
+    const { node } = args;
+    if (node.kind === "DeleteQueryNode") {} else if (node.kind === "SelectQueryNode") {}
+    return node;
+  }
+  async transformResult(args) {
+    return args.result;
+  }
+}
+
+// src/db/kysely/plugins/tree-resolver.ts
+class TreeResolverPlugin {
+  parentColumn;
+  childrenProperty;
+  constructor(config) {
+    this.parentColumn = config.parentColumn || "parent_id";
+    this.childrenProperty = config.childrenProperty || "children";
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (result.rows.length === 0)
+      return result;
+    return {
+      ...result,
+      rows: this.buildTree(result.rows)
+    };
+  }
+  buildTree(rows) {
+    const map = new Map;
+    const roots = [];
+    for (const row of rows) {
+      map.set(row.id, { ...row, [this.childrenProperty]: [] });
+    }
+    for (const row of rows) {
+      const parentId = row[this.parentColumn];
+      const item = map.get(row.id);
+      if (parentId && map.has(parentId)) {
+        map.get(parentId)[this.childrenProperty].push(item);
+      } else {
+        roots.push(item);
+      }
+    }
+    return roots;
+  }
+}
+
+// src/db/kysely/plugins/virtual-field-resolver.ts
+class VirtualFieldResolverPlugin {
+  resolvers = new Map;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.parseConfig(config);
+  }
+  parseConfig(config) {
+    const allResources = [...config.collections, ...config.globals || []];
+    for (const res of allResources) {
+      const tableName = toSnakeCase(res.slug);
+      const resResolvers = new Map;
+      const findResolvers = (fieldList) => {
+        for (const f of fieldList) {
+          if (f.name && f.type === "virtual" && typeof f.resolve === "function") {
+            resResolvers.set(f.name, f.resolve);
+          } else if (f.name && f.resolve && typeof f.resolve === "function") {
+            resResolvers.set(f.name, f.resolve);
+          }
+          if ("fields" in f && Array.isArray(f.fields)) {
+            findResolvers(f.fields);
+          }
+        }
+      };
+      findResolvers(res.fields);
+      if (resResolvers.size > 0) {
+        this.resolvers.set(tableName, resResolvers);
+      }
+    }
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (result.rows.length === 0)
+      return result;
+    const rows = await Promise.all(result.rows.map(async (row) => {
+      const newRow = { ...row };
+      for (const [tableName, tableResolvers] of this.resolvers.entries()) {
+        for (const [fieldName, resolveFn] of tableResolvers.entries()) {
+          try {
+            newRow[fieldName] = await resolveFn({
+              data: row,
+              req: this.config.req,
+              user: this.config.user,
+              session: this.config.session,
+              apiKey: this.config.apiKey
+            });
+          } catch (e) {
+            console.error(`Error resolving virtual field ${fieldName} for table ${tableName}:`, e);
+          }
+        }
+      }
+      return newRow;
+    }));
+    return {
+      ...result,
+      rows
+    };
+  }
+}
+var init_virtual_field_resolver = () => {};
+
+// src/db/kysely/plugins/zod-coercion.ts
+class ZodCoercionPlugin {
+  schemas;
+  constructor(config) {
+    this.schemas = config.schemas;
+  }
+  transformQuery(args) {
+    return args.node;
+  }
+  async transformResult(args) {
+    const { result } = args;
+    if (result.rows.length === 0)
+      return result;
+    const coercedRows = result.rows.map((row) => {
+      return row;
+    });
+    return {
+      ...result,
+      rows: coercedRows
+    };
+  }
+}
+
+// src/db/kysely/plugins/index.ts
+var init_plugins = __esm(() => {
+  init_audit_logging();
+  init_draft_swapper();
+  init_field_masking();
+  init_i18n_fallback();
+  init_json_flattener();
+  init_virtual_field_resolver();
+});
+
+// src/db/kysely/factory.ts
+var exports_factory = {};
+__export(exports_factory, {
+  createOpacaKysely: () => createOpacaKysely
+});
+import { CamelCasePlugin, Kysely } from "kysely";
+function createOpacaKysely(options) {
+  const { dialect, config, isAdmin = false } = options;
+  const plugins = [
+    new JsonFlattenerPlugin({
+      collections: config.collections,
+      globals: config.globals
+    }),
+    new ZodCoercionPlugin({
+      schemas: {}
+    }),
+    new AutoTimestampsPlugin,
+    new IdGenerationPlugin,
+    new SlugGenerationPlugin,
+    new AuditLoggingPlugin({
+      auditTable: "_audit_logs",
+      getUserId: options.getUserId
+    }),
+    new SoftDeletePlugin,
+    new DraftSwapperPlugin({
+      draftMode: false,
+      collections: config.collections,
+      globals: config.globals
+    }),
+    new AutoTranslationFallbackPlugin({
+      collections: config.collections,
+      globals: config.globals,
+      defaultLocale: config.i18n?.defaultLocale || "en",
+      currentLocale: config.i18n?.defaultLocale || "en"
+    }),
+    new CursorPaginationPlugin({}),
+    new FtsNormalizerPlugin({
+      dialect: config.db.name
+    }),
+    new TreeResolverPlugin({}),
+    new VirtualFieldResolverPlugin({
+      collections: config.collections,
+      globals: config.globals
+    }),
+    new RelationshipPreloadingPlugin({}),
+    new DeadlockRetryPlugin({ maxRetries: 5 })
+  ];
+  const db = new Kysely({
+    dialect,
+    plugins: [new CamelCasePlugin, ...plugins]
+  });
+  for (const plugin of plugins) {
+    if (plugin && typeof plugin.setDb === "function") {
+      plugin.setDb(db);
+    }
+  }
+  return db;
+}
+var init_factory = __esm(() => {
+  init_plugins();
+});
+
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
+
+// node:url
+var exports_url = {};
+__export(exports_url, {
+  resolveObject: () => urlResolveObject,
+  resolve: () => urlResolve,
+  parse: () => urlParse,
+  format: () => urlFormat,
+  default: () => url_default,
+  Url: () => Url,
+  URLSearchParams: () => URLSearchParams,
+  URL: () => URL
+});
+function util_isString(arg) {
+  return typeof arg === "string";
+}
+function util_isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+function util_isNull(arg) {
+  return arg === null;
+}
+function util_isNullOrUndefined(arg) {
+  return arg == null;
+}
+function Url() {
+  this.protocol = null, this.slashes = null, this.auth = null, this.host = null, this.port = null, this.hostname = null, this.hash = null, this.search = null, this.query = null, this.pathname = null, this.path = null, this.href = null;
+}
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+  if (url && util_isObject(url) && url instanceof Url)
+    return url;
+  var u = new Url;
+  return u.parse(url, parseQueryString, slashesDenoteHost), u;
+}
+function urlFormat(obj) {
+  if (util_isString(obj))
+    obj = urlParse(obj);
+  if (!(obj instanceof Url))
+    return Url.prototype.format.call(obj);
+  return obj.format();
+}
+function urlResolve(source, relative2) {
+  return urlParse(source, false, true).resolve(relative2);
+}
+function urlResolveObject(source, relative2) {
+  if (!source)
+    return relative2;
+  return urlParse(source, false, true).resolveObject(relative2);
+}
+var URL, URLSearchParams, protocolPattern, portPattern, simplePathPattern, delims, unwise, autoEscape, nonHostChars, hostEndingChars, hostnameMaxLen = 255, hostnamePartPattern, hostnamePartStart, unsafeProtocol, hostlessProtocol, slashedProtocol, querystring, url_default;
+var init_url = __esm(() => {
+  ({ URL, URLSearchParams } = globalThis);
+  protocolPattern = /^([a-z0-9.+-]+:)/i;
+  portPattern = /:[0-9]*$/;
+  simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
+  delims = ["<", ">", '"', "`", " ", "\r", `
+`, "\t"];
+  unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
+  autoEscape = ["'"].concat(unwise);
+  nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
+  hostEndingChars = ["/", "?", "#"];
+  hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
+  hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
+  unsafeProtocol = { javascript: true, "javascript:": true };
+  hostlessProtocol = { javascript: true, "javascript:": true };
+  slashedProtocol = { http: true, https: true, ftp: true, gopher: true, file: true, "http:": true, "https:": true, "ftp:": true, "gopher:": true, "file:": true };
+  querystring = { parse(str) {
+    var decode = decodeURIComponent;
+    return (str + "").replace(/\+/g, " ").split("&").filter(Boolean).reduce(function(obj, item, index) {
+      var ref = item.split("="), key = decode(ref[0] || ""), val = decode(ref[1] || ""), prev = obj[key];
+      return obj[key] = prev === undefined ? val : [].concat(prev, val), obj;
+    }, {});
+  }, stringify(obj) {
+    var encode = encodeURIComponent;
+    return Object.keys(obj || {}).reduce(function(arr, key) {
+      return [].concat(obj[key]).forEach(function(v) {
+        arr.push(encode(key) + "=" + encode(v));
+      }), arr;
+    }, []).join("&").replace(/\s/g, "+");
+  } };
+  Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+    if (!util_isString(url))
+      throw TypeError("Parameter 'url' must be a string, not " + typeof url);
+    var queryIndex = url.indexOf("?"), splitter = queryIndex !== -1 && queryIndex < url.indexOf("#") ? "?" : "#", uSplit = url.split(splitter), slashRegex = /\\/g;
+    uSplit[0] = uSplit[0].replace(slashRegex, "/"), url = uSplit.join(splitter);
+    var rest = url;
+    if (rest = rest.trim(), !slashesDenoteHost && url.split("#").length === 1) {
+      var simplePath = simplePathPattern.exec(rest);
+      if (simplePath) {
+        if (this.path = rest, this.href = rest, this.pathname = simplePath[1], simplePath[2])
+          if (this.search = simplePath[2], parseQueryString)
+            this.query = querystring.parse(this.search.substr(1));
+          else
+            this.query = this.search.substr(1);
+        else if (parseQueryString)
+          this.search = "", this.query = {};
+        return this;
+      }
+    }
+    var proto = protocolPattern.exec(rest);
+    if (proto) {
+      proto = proto[0];
+      var lowerProto = proto.toLowerCase();
+      this.protocol = lowerProto, rest = rest.substr(proto.length);
+    }
+    if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+      var slashes = rest.substr(0, 2) === "//";
+      if (slashes && !(proto && hostlessProtocol[proto]))
+        rest = rest.substr(2), this.slashes = true;
+    }
+    if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
+      var hostEnd = -1;
+      for (var i = 0;i < hostEndingChars.length; i++) {
+        var hec = rest.indexOf(hostEndingChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          hostEnd = hec;
+      }
+      var auth, atSign;
+      if (hostEnd === -1)
+        atSign = rest.lastIndexOf("@");
+      else
+        atSign = rest.lastIndexOf("@", hostEnd);
+      if (atSign !== -1)
+        auth = rest.slice(0, atSign), rest = rest.slice(atSign + 1), this.auth = decodeURIComponent(auth);
+      hostEnd = -1;
+      for (var i = 0;i < nonHostChars.length; i++) {
+        var hec = rest.indexOf(nonHostChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          hostEnd = hec;
+      }
+      if (hostEnd === -1)
+        hostEnd = rest.length;
+      this.host = rest.slice(0, hostEnd), rest = rest.slice(hostEnd), this.parseHost(), this.hostname = this.hostname || "";
+      var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
+      if (!ipv6Hostname) {
+        var hostparts = this.hostname.split(/\./);
+        for (var i = 0, l = hostparts.length;i < l; i++) {
+          var part = hostparts[i];
+          if (!part)
+            continue;
+          if (!part.match(hostnamePartPattern)) {
+            var newpart = "";
+            for (var j = 0, k = part.length;j < k; j++)
+              if (part.charCodeAt(j) > 127)
+                newpart += "x";
+              else
+                newpart += part[j];
+            if (!newpart.match(hostnamePartPattern)) {
+              var validParts = hostparts.slice(0, i), notHost = hostparts.slice(i + 1), bit = part.match(hostnamePartStart);
+              if (bit)
+                validParts.push(bit[1]), notHost.unshift(bit[2]);
+              if (notHost.length)
+                rest = "/" + notHost.join(".") + rest;
+              this.hostname = validParts.join(".");
+              break;
+            }
+          }
+        }
+      }
+      if (this.hostname.length > hostnameMaxLen)
+        this.hostname = "";
+      else
+        this.hostname = this.hostname.toLowerCase();
+      if (!ipv6Hostname)
+        this.hostname = new URL(`https://${this.hostname}`).hostname;
+      var p = this.port ? ":" + this.port : "", h = this.hostname || "";
+      if (this.host = h + p, this.href += this.host, ipv6Hostname) {
+        if (this.hostname = this.hostname.substr(1, this.hostname.length - 2), rest[0] !== "/")
+          rest = "/" + rest;
+      }
+    }
+    if (!unsafeProtocol[lowerProto])
+      for (var i = 0, l = autoEscape.length;i < l; i++) {
+        var ae = autoEscape[i];
+        if (rest.indexOf(ae) === -1)
+          continue;
+        var esc = encodeURIComponent(ae);
+        if (esc === ae)
+          esc = escape(ae);
+        rest = rest.split(ae).join(esc);
+      }
+    var hash = rest.indexOf("#");
+    if (hash !== -1)
+      this.hash = rest.substr(hash), rest = rest.slice(0, hash);
+    var qm = rest.indexOf("?");
+    if (qm !== -1) {
+      if (this.search = rest.substr(qm), this.query = rest.substr(qm + 1), parseQueryString)
+        this.query = querystring.parse(this.query);
+      rest = rest.slice(0, qm);
+    } else if (parseQueryString)
+      this.search = "", this.query = {};
+    if (rest)
+      this.pathname = rest;
+    if (slashedProtocol[lowerProto] && this.hostname && !this.pathname)
+      this.pathname = "/";
+    if (this.pathname || this.search) {
+      var p = this.pathname || "", s = this.search || "";
+      this.path = p + s;
+    }
+    return this.href = this.format(), this;
+  };
+  Url.prototype.format = function() {
+    var auth = this.auth || "";
+    if (auth)
+      auth = encodeURIComponent(auth), auth = auth.replace(/%3A/i, ":"), auth += "@";
+    var protocol = this.protocol || "", pathname = this.pathname || "", hash = this.hash || "", host = false, query = "";
+    if (this.host)
+      host = auth + this.host;
+    else if (this.hostname) {
+      if (host = auth + (this.hostname.indexOf(":") === -1 ? this.hostname : "[" + this.hostname + "]"), this.port)
+        host += ":" + this.port;
+    }
+    if (this.query && util_isObject(this.query) && Object.keys(this.query).length)
+      query = querystring.stringify(this.query);
+    var search = this.search || query && "?" + query || "";
+    if (protocol && protocol.substr(-1) !== ":")
+      protocol += ":";
+    if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
+      if (host = "//" + (host || ""), pathname && pathname.charAt(0) !== "/")
+        pathname = "/" + pathname;
+    } else if (!host)
+      host = "";
+    if (hash && hash.charAt(0) !== "#")
+      hash = "#" + hash;
+    if (search && search.charAt(0) !== "?")
+      search = "?" + search;
+    return pathname = pathname.replace(/[?#]/g, function(match) {
+      return encodeURIComponent(match);
+    }), search = search.replace("#", "%23"), protocol + host + pathname + search + hash;
+  };
+  Url.prototype.resolve = function(relative2) {
+    return this.resolveObject(urlParse(relative2, false, true)).format();
+  };
+  Url.prototype.resolveObject = function(relative2) {
+    if (util_isString(relative2)) {
+      var rel = new Url;
+      rel.parse(relative2, false, true), relative2 = rel;
+    }
+    var result = new Url, tkeys = Object.keys(this);
+    for (var tk = 0;tk < tkeys.length; tk++) {
+      var tkey = tkeys[tk];
+      result[tkey] = this[tkey];
+    }
+    if (result.hash = relative2.hash, relative2.href === "")
+      return result.href = result.format(), result;
+    if (relative2.slashes && !relative2.protocol) {
+      var rkeys = Object.keys(relative2);
+      for (var rk = 0;rk < rkeys.length; rk++) {
+        var rkey = rkeys[rk];
+        if (rkey !== "protocol")
+          result[rkey] = relative2[rkey];
+      }
+      if (slashedProtocol[result.protocol] && result.hostname && !result.pathname)
+        result.path = result.pathname = "/";
+      return result.href = result.format(), result;
+    }
+    if (relative2.protocol && relative2.protocol !== result.protocol) {
+      if (!slashedProtocol[relative2.protocol]) {
+        var keys = Object.keys(relative2);
+        for (var v = 0;v < keys.length; v++) {
+          var k = keys[v];
+          result[k] = relative2[k];
+        }
+        return result.href = result.format(), result;
+      }
+      if (result.protocol = relative2.protocol, !relative2.host && !hostlessProtocol[relative2.protocol]) {
+        var relPath = (relative2.pathname || "").split("/");
+        while (relPath.length && !(relative2.host = relPath.shift()))
+          ;
+        if (!relative2.host)
+          relative2.host = "";
+        if (!relative2.hostname)
+          relative2.hostname = "";
+        if (relPath[0] !== "")
+          relPath.unshift("");
+        if (relPath.length < 2)
+          relPath.unshift("");
+        result.pathname = relPath.join("/");
+      } else
+        result.pathname = relative2.pathname;
+      if (result.search = relative2.search, result.query = relative2.query, result.host = relative2.host || "", result.auth = relative2.auth, result.hostname = relative2.hostname || relative2.host, result.port = relative2.port, result.pathname || result.search) {
+        var p = result.pathname || "", s = result.search || "";
+        result.path = p + s;
+      }
+      return result.slashes = result.slashes || relative2.slashes, result.href = result.format(), result;
+    }
+    var isSourceAbs = result.pathname && result.pathname.charAt(0) === "/", isRelAbs = relative2.host || relative2.pathname && relative2.pathname.charAt(0) === "/", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative2.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split("/") || [], relPath = relative2.pathname && relative2.pathname.split("/") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];
+    if (psychotic) {
+      if (result.hostname = "", result.port = null, result.host)
+        if (srcPath[0] === "")
+          srcPath[0] = result.host;
+        else
+          srcPath.unshift(result.host);
+      if (result.host = "", relative2.protocol) {
+        if (relative2.hostname = null, relative2.port = null, relative2.host)
+          if (relPath[0] === "")
+            relPath[0] = relative2.host;
+          else
+            relPath.unshift(relative2.host);
+        relative2.host = null;
+      }
+      mustEndAbs = mustEndAbs && (relPath[0] === "" || srcPath[0] === "");
+    }
+    if (isRelAbs)
+      result.host = relative2.host || relative2.host === "" ? relative2.host : result.host, result.hostname = relative2.hostname || relative2.hostname === "" ? relative2.hostname : result.hostname, result.search = relative2.search, result.query = relative2.query, srcPath = relPath;
+    else if (relPath.length) {
+      if (!srcPath)
+        srcPath = [];
+      srcPath.pop(), srcPath = srcPath.concat(relPath), result.search = relative2.search, result.query = relative2.query;
+    } else if (!util_isNullOrUndefined(relative2.search)) {
+      if (psychotic) {
+        result.hostname = result.host = srcPath.shift();
+        var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+        if (authInHost)
+          result.auth = authInHost.shift(), result.host = result.hostname = authInHost.shift();
+      }
+      if (result.search = relative2.search, result.query = relative2.query, !util_isNull(result.pathname) || !util_isNull(result.search))
+        result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
+      return result.href = result.format(), result;
+    }
+    if (!srcPath.length) {
+      if (result.pathname = null, result.search)
+        result.path = "/" + result.search;
+      else
+        result.path = null;
+      return result.href = result.format(), result;
+    }
+    var last = srcPath.slice(-1)[0], hasTrailingSlash = (result.host || relative2.host || srcPath.length > 1) && (last === "." || last === "..") || last === "", up = 0;
+    for (var i = srcPath.length;i >= 0; i--)
+      if (last = srcPath[i], last === ".")
+        srcPath.splice(i, 1);
+      else if (last === "..")
+        srcPath.splice(i, 1), up++;
+      else if (up)
+        srcPath.splice(i, 1), up--;
+    if (!mustEndAbs && !removeAllDots)
+      for (;up--; up)
+        srcPath.unshift("..");
+    if (mustEndAbs && srcPath[0] !== "" && (!srcPath[0] || srcPath[0].charAt(0) !== "/"))
+      srcPath.unshift("");
+    if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/")
+      srcPath.push("");
+    var isAbsolute2 = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
+    if (psychotic) {
+      result.hostname = result.host = isAbsolute2 ? "" : srcPath.length ? srcPath.shift() : "";
+      var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+      if (authInHost)
+        result.auth = authInHost.shift(), result.host = result.hostname = authInHost.shift();
+    }
+    if (mustEndAbs = mustEndAbs || result.host && srcPath.length, mustEndAbs && !isAbsolute2)
+      srcPath.unshift("");
+    if (!srcPath.length)
+      result.pathname = null, result.path = null;
+    else
+      result.pathname = srcPath.join("/");
+    if (!util_isNull(result.pathname) || !util_isNull(result.search))
+      result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
+    return result.auth = relative2.auth || result.auth, result.slashes = result.slashes || relative2.slashes, result.href = result.format(), result;
+  };
+  Url.prototype.parseHost = function() {
+    var host = this.host, port = portPattern.exec(host);
+    if (port) {
+      if (port = port[0], port !== ":")
+        this.port = port.substr(1);
+      host = host.substr(0, host.length - port.length);
+    }
+    if (host)
+      this.hostname = host;
+  };
+  url_default = { parse: urlParse, resolve: urlResolve, resolveObject: urlResolveObject, format: urlFormat, Url, URL, URLSearchParams };
+});
 
 // src/db/d1.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
 import { CompiledQuery, FileMigrationProvider, Migrator } from "kysely";
+
+// src/db/adapter.ts
+class BaseDatabaseAdapter {
+  get raw() {
+    return;
+  }
+  get db() {
+    return;
+  }
+  push;
+  pushDestructive;
+  migrationDir;
+}
+
+// src/db/kysely/data-mapper.ts
+function toCamelCase(str) {
+  if (str.startsWith("_"))
+    return str;
+  return str.replace(/_+([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function flattenPayload(payload, prefix = "", excludeKeys = []) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+    return payload;
+  const result = {};
+  for (const key in payload) {
+    if (Object.hasOwn(payload, key)) {
+      const value = payload[key];
+      if (value === undefined)
+        continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !excludeKeys.includes(key)) {
+        if (key.startsWith("_") && prefix === "") {
+          result[key] = value;
+        } else {
+          const flatNested = flattenPayload(value, `${prefix}${key}__`);
+          Object.assign(result, flatNested);
+        }
+      } else {
+        if (value === undefined)
+          continue;
+        const colName = `${prefix}${toSnakeCase(key)}`;
+        if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+          result[colName] = JSON.stringify(value);
+        } else {
+          result[colName] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function unflattenRow(row) {
+  if (typeof row !== "object" || row === null || Array.isArray(row))
+    return row;
+  const result = {};
+  for (const key in row) {
+    if (Object.hasOwn(row, key)) {
+      let value = row[key];
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          try {
+            value = JSON.parse(value);
+          } catch (e) {}
+        }
+      }
+      if (key === "created_at" || key === "updated_at" || key === "createdAt" || key === "updatedAt") {
+        if (typeof value === "string" && !value.includes("T") && value.includes(" ")) {
+          value = `${value.replace(" ", "T")}Z`;
+        }
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+      if (key.startsWith("_")) {
+        result[key] = value;
+        continue;
+      }
+      const parts = key.split("__");
+      if (parts.length === 1) {
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+      let current = result;
+      let collision = false;
+      const path = [];
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = toCamelCase(parts[i]);
+        if (current[part] !== undefined && (typeof current[part] !== "object" || current[part] === null)) {
+          collision = true;
+          break;
+        }
+        path.push({ obj: current, key: part });
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      if (!collision) {
+        const lastPart = toCamelCase(parts[parts.length - 1]);
+        if (current[lastPart] !== undefined && typeof current[lastPart] === "object") {
+          collision = true;
+        } else {
+          current[lastPart] = value;
+        }
+      }
+      if (collision) {
+        result[toCamelCase(key)] = value;
+      }
+    }
+  }
+  return result;
+}
+// src/db/kysely/query-builder.ts
+function buildKyselyWhere(eb, query) {
+  if (!query || Object.keys(query).length === 0)
+    return;
+  const conditions = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined)
+      continue;
+    if (key === "or" && Array.isArray(value)) {
+      const orConditions = value.map((v) => buildKyselyWhere(eb, v)).filter((c) => c !== undefined);
+      if (orConditions.length > 0) {
+        conditions.push(eb.or(orConditions));
+      }
+      continue;
+    }
+    if (key === "and" && Array.isArray(value)) {
+      const andConditions = value.map((v) => buildKyselyWhere(eb, v)).filter((c) => c !== undefined);
+      if (andConditions.length > 0) {
+        conditions.push(eb.and(andConditions));
+      }
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+      for (const [op, val] of Object.entries(value)) {
+        if (val === undefined)
+          continue;
+        switch (op) {
+          case "gt":
+            conditions.push(eb(key, ">", val));
+            break;
+          case "gte":
+            conditions.push(eb(key, ">=", val));
+            break;
+          case "lt":
+            conditions.push(eb(key, "<", val));
+            break;
+          case "lte":
+            conditions.push(eb(key, "<=", val));
+            break;
+          case "like":
+            conditions.push(eb(key, "like", String(val)));
+            break;
+          case "ne":
+            if (val === null)
+              conditions.push(eb(key, "is not", null));
+            else
+              conditions.push(eb(key, "!=", val));
+            break;
+          case "in":
+            if (Array.isArray(val))
+              conditions.push(eb(key, "in", val));
+            break;
+          case "is":
+            if (val === null)
+              conditions.push(eb(key, "is", null));
+            break;
+          default:
+            if (val === null)
+              conditions.push(eb(key, "is", null));
+            else
+              conditions.push(eb(key, "=", val));
+            break;
+        }
+      }
+    } else {
+      if (value === null) {
+        conditions.push(eb(key, "is", null));
+      } else {
+        conditions.push(eb(key, "=", value));
+      }
+    }
+  }
+  if (conditions.length === 0)
+    return;
+  if (conditions.length === 1)
+    return conditions[0];
+  return eb.and(conditions);
+}
+
+// src/db/kysely/schema-builder.ts
+import { sql } from "kysely";
+
+// src/db/kysely/sql-utils.ts
+function assertSafeIdentifier(identifier) {
+  if (typeof identifier !== "string" || !identifier) {
+    throw new Error(`Invalid identifier: must be a non-empty string. Got: ${identifier}`);
+  }
+  const isValid = /^[a-zA-Z0-9_-]+$/.test(identifier);
+  if (!isValid) {
+    throw new Error(`API Error: Unsafe SQL identifier detected: "${identifier}". Identifiers can only contain alphanumeric characters, underscores, and hyphens.`);
+  }
+}
+
+// src/db/system-schema.ts
+var getSystemCollections = () => [
+  {
+    slug: "_assets",
+    label: "Assets",
+    apiPath: "assets",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "key", type: "text", required: true },
+      { name: "filename", type: "text", required: true },
+      { name: "originalFilename", type: "text", required: true },
+      { name: "mimeType", type: "text", required: true },
+      { name: "filesize", type: "number", required: true },
+      { name: "bucket", type: "text", required: true },
+      { name: "folder", type: "text" },
+      { name: "altText", type: "text" },
+      { name: "caption", type: "text" },
+      { name: "uploadedBy", type: "text" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_users",
+    apiPath: "users",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "name", type: "text", required: true },
+      { name: "email", type: "text", required: true, unique: true },
+      { name: "emailVerified", type: "boolean", required: true, defaultValue: false },
+      { name: "image", type: "text" },
+      { name: "role", type: "text" },
+      { name: "banned", type: "boolean" },
+      { name: "banReason", type: "text" },
+      { name: "banExpires", type: "date" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_sessions",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true },
+      { name: "token", type: "text", required: true, unique: true },
+      { name: "ipAddress", type: "text" },
+      { name: "userAgent", type: "text" },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "impersonatedBy", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_accounts",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "accountId", type: "text", required: true },
+      { name: "providerId", type: "text", required: true },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "accessToken", type: "text" },
+      { name: "refreshToken", type: "text" },
+      { name: "idToken", type: "text" },
+      { name: "accessTokenExpiresAt", type: "date" },
+      { name: "refreshTokenExpiresAt", type: "date" },
+      { name: "scope", type: "text" },
+      { name: "password", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_verifications",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "identifier", type: "text", required: true },
+      { name: "value", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_api_keys",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "configId", type: "text", required: true },
+      { name: "name", type: "text" },
+      { name: "start", type: "text" },
+      { name: "prefix", type: "text" },
+      { name: "key", type: "text", required: true },
+      { name: "referenceId", type: "text", required: true },
+      { name: "refillInterval", type: "number" },
+      { name: "refillAmount", type: "number" },
+      { name: "lastRefillAt", type: "date" },
+      { name: "enabled", type: "boolean", required: true },
+      { name: "rateLimitEnabled", type: "boolean", required: true },
+      { name: "rateLimitTimeWindow", type: "number" },
+      { name: "rateLimitMax", type: "number" },
+      { name: "requestCount", type: "number", required: true },
+      { name: "remaining", type: "number" },
+      { name: "lastRequest", type: "date" },
+      { name: "expiresAt", type: "date" },
+      { name: "permissions", type: "text" },
+      { name: "metadata", type: "text" }
+    ],
+    timestamps: { createdAt: "createdAt", updatedAt: "updatedAt" },
+    hidden: true
+  },
+  {
+    slug: "_plugin_settings",
+    label: "Plugin Settings",
+    apiPath: "plugin-settings",
+    fields: [
+      { name: "pluginName", type: "text", required: true, unique: true },
+      { name: "config", type: "json", required: true }
+    ],
+    timestamps: true,
+    hidden: false,
+    admin: {
+      hidden: true,
+      disableAdmin: true
+    }
+  },
+  {
+    slug: "_audit_logs",
+    label: "Audit Logs",
+    apiPath: "audit-logs",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "operation", type: "text", required: true },
+      { name: "collection", type: "text", required: true },
+      { name: "entity_id", type: "text", required: true },
+      { name: "user_id", type: "text" },
+      { name: "previous_data", type: "json" },
+      { name: "new_data", type: "json" },
+      { name: "timestamp", type: "date" }
+    ],
+    timestamps: true,
+    admin: {
+      hidden: true,
+      disableAdmin: true
+    }
+  },
+  {
+    slug: "_doc_versions",
+    label: "Document Versions",
+    apiPath: "doc-versions",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "collection", type: "text", required: true },
+      { name: "entity_id", type: "text", required: true },
+      { name: "data", type: "json", required: true },
+      { name: "status", type: "text" },
+      { name: "autosave", type: "boolean", defaultValue: false },
+      { name: "version_name", type: "text" },
+      { name: "created_by", type: "text" }
+    ],
+    timestamps: true,
+    admin: {
+      hidden: true,
+      disableAdmin: true
+    }
+  }
+];
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var BLUE = "\x1B[34m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var GRAY = "\x1B[90m";
+var PREFIX = `${BLUE}${BOLD}[OpacaCMS]${RESET}`;
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+class OpacaLogger {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  shouldLog(level) {
+    if (this.config.disabled)
+      return false;
+    const configLevel = this.config.level || "info";
+    return LOG_LEVELS[level] >= LOG_LEVELS[configLevel];
+  }
+  info(message, ...args) {
+    if (!this.shouldLog("info"))
+      return;
+    console.log(`${PREFIX} ${message}`, ...args);
+  }
+  success(message, ...args) {
+    if (!this.shouldLog("info"))
+      return;
+    console.log(`${PREFIX} ${GREEN}${message}${RESET}`, ...args);
+  }
+  debug(message, ...args) {
+    if (!this.shouldLog("debug"))
+      return;
+    console.log(`${PREFIX} ${GRAY}${message}${RESET}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog("warn"))
+      return;
+    console.warn(`${PREFIX} ${YELLOW}Warning: ${message}${RESET}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.shouldLog("error"))
+      return;
+    console.error(`${PREFIX} ${RED}Error: ${message}${RESET}`, ...args);
+  }
+  log(message, ...args) {
+    if (this.config.disabled)
+      return;
+    console.log(message, ...args);
+  }
+  bold(msg) {
+    if (this.config.disableColors)
+      return msg;
+    return `${BOLD}${msg}${RESET}`;
+  }
+  format(color, msg) {
+    if (this.config.disableColors)
+      return msg;
+    switch (color) {
+      case "green":
+        return `${GREEN}${msg}${RESET}`;
+      case "red":
+        return `${RED}${msg}${RESET}`;
+      case "yellow":
+        return `${YELLOW}${msg}${RESET}`;
+      case "gray":
+        return `${GRAY}${msg}${RESET}`;
+      default:
+        return msg;
+    }
+  }
+}
+var logger = new OpacaLogger;
+
+// src/db/kysely/schema-builder.ts
+async function pushSchema(db, dialect, collections, globals = [], options = {}) {
+  const rawSchemas = [...getSystemCollections(), ...collections, ...globals];
+  const allSchemas = [];
+  const seenSlugs = new Set;
+  for (const schema of rawSchemas) {
+    if (!seenSlugs.has(schema.slug)) {
+      seenSlugs.add(schema.slug);
+      allSchemas.push(schema);
+    }
+  }
+  const { pushDestructive } = options;
+  logger.debug(`Starting schema push via Kysely (${dialect})...`);
+  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
+  let tablesMetadata = [];
+  try {
+    tablesMetadata = await db.introspection.getTables();
+  } catch (e) {
+    logger.warn("Failed to fetch database introspection. Falling back to empty state.", e);
+  }
+  const existingTableMap = new Map(tablesMetadata.map((t) => [t.name, t]));
+  const existingTables = Array.from(existingTableMap.keys());
+  logger.debug(`Existing tables found: ${existingTables.join(", ")}`);
+  const expectedTableNames = new Set;
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const tableName = toSnakeCase(slug);
+    assertSafeIdentifier(tableName);
+    expectedTableNames.add(tableName);
+    const flattenedFields = flattenFields(collection.fields);
+    const hasTimestamps = true;
+    const versions = collection.versions;
+    const existingTable = existingTableMap.get(tableName);
+    if (!existingTable) {
+      logger.info(`  ${logger.format("green", "✔")} Creating table: ${logger.bold(`"${tableName}"`)}`);
+      let builder = db.schema.createTable(tableName).ifNotExists();
+      builder = builder.addColumn("id", "text", (col) => col.primaryKey());
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        const colType = mapType(field);
+        builder = builder.addColumn(colName, colType, (col) => {
+          let c = col;
+          if (field.unique)
+            c = c.unique();
+          if (field.required)
+            c = c.notNull();
+          if (field.defaultValue !== undefined)
+            c = c.defaultTo(field.defaultValue);
+          return c;
+        });
+      }
+      if (versions?.drafts) {
+        builder = builder.addColumn("_status", "text", (col) => col.defaultTo("draft"));
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamptz" : "text";
+        builder = builder.addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+        builder = builder.addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+      }
+      await builder.execute();
+    } else {
+      const existingColSet = new Set(existingTable.columns.map((c) => c.name));
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        if (!existingColSet.has(colName)) {
+          logger.info(`  ${logger.format("green", "✔")} Adding column: ${logger.bold(`${tableName}.${colName}`)}`);
+          const colType = mapType(field);
+          await db.schema.alterTable(tableName).addColumn(colName, colType).execute();
+        }
+      }
+      if (versions?.drafts && !existingColSet.has("_status")) {
+        logger.info(`  ${logger.format("green", "✔")} Adding status column to: ${tableName}`);
+        await db.schema.alterTable(tableName).addColumn("_status", "text", (col) => col.defaultTo("draft")).execute();
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamptz" : "text";
+        if (!existingColSet.has(createdField)) {
+          logger.info(`  -> Adding missing timestamp column: ${tableName}.${createdField}`);
+          await db.schema.alterTable(tableName).addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+        if (!existingColSet.has(updatedField)) {
+          logger.info(`  -> Adding missing timestamp column: ${tableName}.${updatedField}`);
+          await db.schema.alterTable(tableName).addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+      if (pushDestructive) {
+        const expectedCols = new Set(flattenedFields.filter((f) => !(f.type === "relationship" && f.hasMany)).map((f) => toSnakeCase(f.name)));
+        if (hasTimestamps) {
+          const ts = collection.timestamps ?? {};
+          const config = typeof ts === "object" ? ts : {};
+          expectedCols.add(toSnakeCase(config.createdAt ?? "createdAt"));
+          expectedCols.add(toSnakeCase(config.updatedAt ?? "updatedAt"));
+        }
+        if (versions?.drafts)
+          expectedCols.add("_status");
+        expectedCols.add("id");
+        for (const existingCol of existingColSet) {
+          const colName = existingCol;
+          if (!expectedCols.has(colName)) {
+            logger.info(`  -> Dropping stale column: ${logger.format("red", `${tableName}.${colName}`)}`);
+            try {
+              await db.schema.alterTable(tableName).dropColumn(colName).execute();
+            } catch (_) {
+              logger.warn(`Failed to drop column ${colName}.`);
+            }
+          }
+        }
+      }
+    }
+    const relationalFields = getRelationalFields(collection.fields);
+    for (const field of relationalFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const colName = toSnakeCase(field.name);
+        const joinTableName = `${tableName}_${colName}_relations`.toLowerCase();
+        assertSafeIdentifier(joinTableName);
+        expectedTableNames.add(joinTableName);
+        if (!existingTableMap.has(joinTableName)) {
+          logger.info(`  -> Creating relation table: ${logger.format("green", `"${joinTableName}"`)}`);
+          await db.schema.createTable(joinTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("source_id", "text", (col) => col.notNull()).addColumn("target_id", "text", (col) => col.notNull()).addColumn("order", "integer", (col) => col.defaultTo(0)).execute();
+        }
+      }
+    }
+    for (const field of relationalFields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name);
+          const blockSlug = toSnakeCase(block.slug);
+          assertSafeIdentifier(blockName);
+          assertSafeIdentifier(blockSlug);
+          const blockTableName = `${tableName}_${blockName}_${blockSlug}`.toLowerCase();
+          assertSafeIdentifier(blockTableName);
+          expectedTableNames.add(blockTableName);
+          const existingBlockTable = existingTableMap.get(blockTableName);
+          if (!existingBlockTable) {
+            logger.info(`  -> Creating block table: ${logger.format("green", `"${blockTableName}"`)}`);
+            let bBuilder = db.schema.createTable(blockTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_order", "integer", (col) => col.defaultTo(0)).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug));
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              assertSafeIdentifier(bColName);
+              const bColType = mapType(bField);
+              bBuilder = bBuilder.addColumn(bColName, bColType, (col) => {
+                let c = col;
+                if (bField.unique)
+                  c = c.unique();
+                if (bField.required)
+                  c = c.notNull();
+                if (bField.defaultValue !== undefined)
+                  c = c.defaultTo(bField.defaultValue);
+                return c;
+              });
+            }
+            const tsType = dialect === "postgres" ? "timestamptz" : "text";
+            bBuilder = bBuilder.addColumn("created_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            bBuilder = bBuilder.addColumn("updated_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            await bBuilder.execute();
+          } else {
+            const existingBColSet = new Set(existingBlockTable.columns.map((c) => c.name));
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              if (!existingBColSet.has(bColName)) {
+                const bColType = mapType(bField);
+                await db.schema.alterTable(blockTableName).addColumn(bColName, bColType).execute();
+              }
+            }
+            if (!existingBColSet.has("_parent_id")) {
+              await db.schema.alterTable(blockTableName).addColumn("_parent_id", "text", (col) => col.notNull().defaultTo("")).execute();
+            }
+            if (!existingBColSet.has("_order")) {
+              await db.schema.alterTable(blockTableName).addColumn("_order", "integer", (col) => col.defaultTo(0)).execute();
+            }
+            if (!existingBColSet.has("block_type")) {
+              await db.schema.alterTable(blockTableName).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug)).execute();
+            }
+          }
+        }
+      }
+    }
+  }
+  if (pushDestructive) {
+    for (const tableName of existingTables) {
+      if (!expectedTableNames.has(tableName) && !tableName.startsWith("better_auth") && !tableName.startsWith("__kysely")) {
+        logger.info(`  -> Dropping stale table: ${logger.format("red", `"${tableName}"`)}`);
+        try {
+          await db.schema.dropTable(tableName).ifExists().cascade().execute();
+        } catch (_) {
+          try {
+            await db.schema.dropTable(tableName).ifExists().execute();
+          } catch (_2) {
+            logger.warn(`Failed to drop table ${tableName}`);
+          }
+        }
+      }
+    }
+  }
+  logger.info(`${logger.format("green", "✔")} Schema synchronization complete.`);
+}
+
+// src/db/d1.ts
+init_context();
 class D1Adapter extends BaseDatabaseAdapter {
   name = "d1";
   _rawDb;
@@ -57,8 +2349,8 @@ class D1Adapter extends BaseDatabaseAdapter {
     if (this._db)
       return;
     const { D1Dialect } = await import("kysely-d1");
-    const { createOpacaKysely } = await import("../chunk-gzbz5jwy.js");
-    this._db = createOpacaKysely({
+    const { createOpacaKysely: createOpacaKysely2 } = await Promise.resolve().then(() => (init_factory(), exports_factory));
+    this._db = createOpacaKysely2({
       dialect: new D1Dialect({ database: this._rawDb }),
       config: {
         collections: this._collections,
@@ -572,11 +2864,14 @@ class D1Adapter extends BaseDatabaseAdapter {
     return this.findGlobal(slug);
   }
   async runMigrations() {
+    const fs = await import("node:fs/promises");
+    const path = await Promise.resolve().then(() => (init_path(), exports_path));
+    const { pathToFileURL } = await Promise.resolve().then(() => (init_url(), exports_url));
     const migrator = new Migrator({
       db: this.db,
       provider: new FileMigrationProvider({
-        fs,
-        path,
+        fs: fs.default || fs,
+        path: path.default || path,
         migrationFolder: pathToFileURL(path.resolve(process.cwd(), this.migrationDir)).href
       })
     });