opacacms 0.3.18 → 0.3.19

package/dist/db/bun-sqlite.js

@@ -1,33 +1,1620 @@
-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";
+import { createRequire } from "node:module";
+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__ */ createRequire(import.meta.url);
+
+// src/db/kysely/field-mapper.ts
+var exports_field_mapper = {};
+__export(exports_field_mapper, {
+  toSnakeCase: () => toSnakeCase,
+  mapFieldToSQLiteType: () => mapFieldToSQLiteType,
+  mapFieldToPostgresType: () => mapFieldToPostgresType,
+  getRelationalFields: () => getRelationalFields,
+  flattenFields: () => flattenFields
+});
+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/db/system-schema.ts
+var exports_system_schema = {};
+__export(exports_system_schema, {
+  getSystemCollections: () => getSystemCollections
+});
+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/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+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();
+});
+
+// src/db/bun-sqlite.ts
+import { FileMigrationProvider, Migrator, sql as sql2 } 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/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/bun-sqlite.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { FileMigrationProvider, Migrator, sql } from "kysely";
+init_context();
 class BunSQLiteAdapter extends BaseDatabaseAdapter {
   path;
   name = "bun-sqlite";
@@ -46,9 +1633,9 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
       throw new Error("Database not connected. Call connect() first.");
     return this._db;
   }
-  constructor(path2, options) {
+  constructor(path, options) {
     super();
-    this.path = path2;
+    this.path = path;
     this.push = options?.push ?? true;
     this.pushDestructive = options?.pushDestructive ?? false;
     this.migrationDir = options?.migrationDir ?? "./migrations";
@@ -59,8 +1646,8 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
     const { Database } = await import("bun:sqlite");
     const { BunSqliteDialect } = await import("kysely-bun-sqlite");
     this._rawDb = new Database(this.path);
-    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 BunSqliteDialect({
         database: this._rawDb
       }),
@@ -76,7 +1663,7 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
       await this.db.destroy();
   }
   async unsafe(query, params) {
-    const compiled = sql.raw(query);
+    const compiled = sql2.raw(query);
     const result = await compiled.execute(this.db);
     return result.rows;
   }
@@ -557,11 +2144,14 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
     return this.findGlobal(slug);
   }
   async runMigrations() {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const { pathToFileURL } = await import("node: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
       })
     });
@@ -587,8 +2177,8 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
     }
   }
 }
-function createBunSQLiteAdapter(path2, options) {
-  return new BunSQLiteAdapter(path2, options);
+function createBunSQLiteAdapter(path, options) {
+  return new BunSQLiteAdapter(path, options);
 }
 export {
   createBunSQLiteAdapter,