opacacms 0.2.1 → 0.3.1

package/dist/chunk-sqsfk9p4.js

@@ -0,0 +1,700 @@
+import {
+  getPreviousDataFromContext,
+  getUserIdFromContext
+} from "./chunk-q5sb5dcr.js";
+import {
+  toSnakeCase
+} from "./chunk-qxt9vge8.js";
+import"./chunk-6bywt602.js";
+
+// src/db/kysely/factory.ts
+import { CamelCasePlugin, Kysely } from "kysely";
+
+// 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);
+    }
+  }
+}
+
+// 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;
+  }
+}
+
+// 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;
+  }
+}
+
+// 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;
+  }
+}
+
+// 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
+    };
+  }
+}
+
+// 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/factory.ts
+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;
+}
+export {
+  createOpacaKysely
+};