opacacms 0.3.16 → 0.3.18

package/dist/chunk-qsefknd3.js

@@ -1,593 +0,0 @@
-import {
-  buildKyselyWhere,
-  flattenPayload,
-  pushSchema,
-  unflattenRow
-} from "./chunk-re459gm9.js";
-import {
-  BaseDatabaseAdapter
-} from "./chunk-s8mqwnm1.js";
-import {
-  requestContext
-} from "./chunk-q5sb5dcr.js";
-import {
-  flattenFields,
-  getRelationalFields,
-  toSnakeCase
-} from "./chunk-5xpf5jxd.js";
-import {
-  logger
-} from "./chunk-jq1drsen.js";
-import {
-  __require
-} from "./chunk-8sqjbsgt.js";
-
-// 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";
-class BunSQLiteAdapter extends BaseDatabaseAdapter {
-  path;
-  name = "bun-sqlite";
-  _rawDb;
-  _db = null;
-  _collections = [];
-  _globals = [];
-  push;
-  migrationDir;
-  pushDestructive;
-  get raw() {
-    return this._rawDb;
-  }
-  get db() {
-    if (!this._db)
-      throw new Error("Database not connected. Call connect() first.");
-    return this._db;
-  }
-  constructor(path2, options) {
-    super();
-    this.path = path2;
-    this.push = options?.push ?? true;
-    this.pushDestructive = options?.pushDestructive ?? false;
-    this.migrationDir = options?.migrationDir ?? "./migrations";
-  }
-  async connect() {
-    if (this._db)
-      return;
-    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({
-      dialect: new BunSqliteDialect({
-        database: this._rawDb
-      }),
-      config: {
-        collections: this._collections,
-        globals: this._globals,
-        db: { name: "bun-sqlite" }
-      }
-    });
-  }
-  async disconnect() {
-    if (this._db)
-      await this.db.destroy();
-  }
-  async unsafe(query, params) {
-    const compiled = sql.raw(query);
-    const result = await compiled.execute(this.db);
-    return result.rows;
-  }
-  async count(collection, query) {
-    const tableName = toSnakeCase(collection);
-    let qb = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
-    if (query && Object.keys(query).length > 0) {
-      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-    }
-    const result = await qb.executeTakeFirst();
-    return Number(result?.count || 0);
-  }
-  async create(collection, data) {
-    const tableName = toSnakeCase(collection);
-    const colDef = this._collections.find((c) => c.slug === collection);
-    const flatData = flattenPayload(data);
-    const relationalFields = getRelationalFields(colDef?.fields || []);
-    const hasManyData = {};
-    const blocksData = {};
-    for (const field of relationalFields) {
-      const key = field.name;
-      if (Array.isArray(flatData[key])) {
-        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-          hasManyData[key] = flatData[key];
-        } else if (field.type === "blocks") {
-          blocksData[key] = flatData[key];
-        }
-        delete flatData[key];
-      }
-    }
-    const dbFields = flattenFields(colDef?.fields || []);
-    const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
-    validCols.add("id");
-    validCols.add(toSnakeCase("createdAt"));
-    validCols.add(toSnakeCase("updatedAt"));
-    const filteredData = {};
-    for (const col of Object.keys(flatData)) {
-      if (validCols.has(col)) {
-        filteredData[col] = flatData[col];
-      }
-    }
-    if (!filteredData.id) {
-      filteredData.id = crypto.randomUUID();
-      flatData.id = filteredData.id;
-    }
-    await this.db.insertInto(tableName).values(filteredData).execute();
-    for (const [key, values] of Object.entries(hasManyData)) {
-      const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
-      if (values.length > 0) {
-        const joinData = values.map((val, idx) => {
-          const tId = typeof val === "object" ? val.id : val;
-          return { id: crypto.randomUUID(), source_id: flatData.id, target_id: tId, order: idx };
-        });
-        await this.db.insertInto(joinTableName).values(joinData).execute();
-      }
-    }
-    for (const [key, blocks] of Object.entries(blocksData)) {
-      for (let i = 0;i < blocks.length; i++) {
-        const block = blocks[i];
-        if (!block.blockType)
-          continue;
-        const blockTableName = `${tableName}_${toSnakeCase(key)}_${toSnakeCase(block.blockType)}`.toLowerCase();
-        const bId = block.id || crypto.randomUUID();
-        const blockDef = relationalFields.find((f) => f.name === key && f.type === "blocks");
-        const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
-        const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-        const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
-        for (const f of blockJsonFields) {
-          if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
-            blockFlatData[f] = JSON.stringify(blockFlatData[f]);
-          }
-        }
-        delete blockFlatData.blockType;
-        const blockData = {
-          ...blockFlatData,
-          _parent_id: flatData.id,
-          _order: i,
-          block_type: block.blockType
-        };
-        await this.db.insertInto(blockTableName).values(blockData).execute();
-      }
-    }
-    return this.findOne(collection, { id: flatData.id }, this.db);
-  }
-  async findOne(collection, query, tx) {
-    const tableName = toSnakeCase(collection);
-    const executor = tx || this.db;
-    let qb = executor.selectFrom(tableName).selectAll();
-    if (query && Object.keys(query).length > 0) {
-      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-    }
-    const row = await qb.executeTakeFirst();
-    if (!row)
-      return null;
-    const unflattened = unflattenRow(row);
-    const colDef = this._collections.find((c) => c.slug === collection);
-    if (colDef) {
-      const relationalFields = getRelationalFields(colDef.fields);
-      for (const field of relationalFields) {
-        if (!field.name)
-          continue;
-        const snakeName = toSnakeCase(field.name);
-        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-          const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
-          try {
-            const relations = await executor.selectFrom(joinTableName).selectAll().where("source_id", "=", row.id).orderBy("order", "asc").execute();
-            const parts = field.name.split("__");
-            let current = unflattened;
-            for (let i = 0;i < parts.length - 1; i++) {
-              if (!current[parts[i]])
-                current[parts[i]] = {};
-              current = current[parts[i]];
-            }
-            current[parts[parts.length - 1]] = relations.map((r) => r.target_id);
-          } catch (e) {}
-        } else if (field.type === "blocks" && field.blocks) {
-          const blockData = [];
-          for (const b of field.blocks) {
-            const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
-            try {
-              const blocks = await executor.selectFrom(blockTableName).selectAll().where("_parent_id", "=", row.id).execute();
-              for (const blk of blocks) {
-                const uf = unflattenRow(blk);
-                uf.blockType = blk.block_type;
-                blockData.push(uf);
-              }
-            } catch (e) {}
-          }
-          blockData.sort((a, b) => a._order - b._order);
-          blockData.forEach((b) => {
-            delete b._order;
-            delete b._parentId;
-          });
-          const parts = field.name.split("__");
-          let current = unflattened;
-          for (let i = 0;i < parts.length - 1; i++) {
-            if (!current[parts[i]])
-              current[parts[i]] = {};
-            current = current[parts[i]];
-          }
-          current[parts[parts.length - 1]] = blockData;
-        }
-      }
-    }
-    return unflattened;
-  }
-  async find(collection, query, options) {
-    const page = options?.page || 1;
-    const limit = options?.limit || 10;
-    const offset = (page - 1) * limit;
-    const cursorColumn = options?.cursorColumn || "id";
-    const total = await this.count(collection, query);
-    const tableName = toSnakeCase(collection);
-    let qb = this.db.selectFrom(tableName).selectAll().limit(limit);
-    if (options?.after) {
-      qb = qb.where(cursorColumn, ">", options.after);
-    } else if (options?.before) {
-      qb = qb.where(cursorColumn, "<", options.before);
-    } else {
-      qb = qb.offset(offset);
-    }
-    if (query && Object.keys(query).length > 0) {
-      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-    }
-    if (options?.sort) {
-      const [col, dir] = (options.sort ?? "").split(":");
-      if (col) {
-        qb = qb.orderBy(col, dir === "desc" ? "desc" : "asc");
-      }
-    } else {
-      qb = qb.orderBy(cursorColumn, "desc");
-    }
-    const rows = await qb.execute();
-    if (rows.length === 0) {
-      const totalPages2 = Math.ceil(total / limit);
-      const afterAnchor = options?.after;
-      const beforeAnchor = options?.before;
-      return {
-        docs: [],
-        totalDocs: total,
-        limit,
-        totalPages: totalPages2,
-        page,
-        pagingCounter: offset + 1,
-        hasNextPage: false,
-        hasPrevPage: !!afterAnchor || page > 1,
-        prevPage: null,
-        nextPage: null,
-        nextCursor: null,
-        prevCursor: afterAnchor ? afterAnchor : null
-      };
-    }
-    const rowIds = rows.map((r) => r.id);
-    const docs = rows.map((r) => unflattenRow(r));
-    const colDef = this._collections.find((c) => c.slug === collection);
-    if (colDef) {
-      const relationalFields = getRelationalFields(colDef.fields);
-      for (const field of relationalFields) {
-        if (!field.name)
-          continue;
-        const snakeName = toSnakeCase(field.name);
-        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-          const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
-          try {
-            const allRelations = await this.db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
-            const relationsBySource = allRelations.reduce((acc, r) => {
-              if (!acc[r.source_id])
-                acc[r.source_id] = [];
-              acc[r.source_id].push(r.target_id);
-              return acc;
-            }, {});
-            const parts = field.name.split("__");
-            for (let docIdx = 0;docIdx < docs.length; docIdx++) {
-              const rowId = rowIds[docIdx];
-              let current = docs[docIdx];
-              for (let i = 0;i < parts.length - 1; i++) {
-                if (!current[parts[i]])
-                  current[parts[i]] = {};
-                current = current[parts[i]];
-              }
-              current[parts[parts.length - 1]] = relationsBySource[rowId] || [];
-            }
-          } catch (e) {}
-        } else if (field.type === "blocks" && field.blocks) {
-          const blocksBySource = {};
-          for (const b of field.blocks) {
-            const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
-            try {
-              const allBlocks = await this.db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
-              for (const blk of allBlocks) {
-                const uf = unflattenRow(blk);
-                uf.blockType = blk.block_type;
-                if (!blocksBySource[blk._parent_id])
-                  blocksBySource[blk._parent_id] = [];
-                blocksBySource[blk._parent_id].push(uf);
-              }
-            } catch (e) {}
-          }
-          const parts = field.name.split("__");
-          for (let docIdx = 0;docIdx < docs.length; docIdx++) {
-            const rowId = rowIds[docIdx];
-            const blockData = blocksBySource[rowId] || [];
-            blockData.sort((a, b) => a._order - b._order);
-            blockData.forEach((b) => {
-              delete b._order;
-              delete b._parentId;
-            });
-            let current = docs[docIdx];
-            for (let i = 0;i < parts.length - 1; i++) {
-              if (!current[parts[i]])
-                current[parts[i]] = {};
-              current = current[parts[i]];
-            }
-            current[parts[parts.length - 1]] = blockData;
-          }
-        }
-      }
-    }
-    const totalPages = Math.ceil(total / limit);
-    const hasNextPage = page * limit < total;
-    return {
-      docs: docs.filter(Boolean),
-      totalDocs: total,
-      limit,
-      totalPages,
-      page,
-      pagingCounter: offset + 1,
-      hasNextPage,
-      hasPrevPage: page > 1 || !!options?.after || !!options?.before,
-      prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < totalPages ? page + 1 : null,
-      nextCursor: hasNextPage && docs.length > 0 ? docs[docs.length - 1][cursorColumn] : null,
-      prevCursor: docs.length > 0 && (page > 1 || !!options?.after || !!options?.before) ? docs[0][cursorColumn] : null
-    };
-  }
-  async update(collection, query, data) {
-    return this.db.transaction().execute(async (tx) => {
-      let normalizedQuery = query;
-      if (typeof query !== "object" || query === null) {
-        normalizedQuery = { id: query };
-      }
-      const current = await this.findOne(collection, normalizedQuery, tx);
-      if (!current)
-        throw new Error("Document not found");
-      const store = requestContext.getStore();
-      if (store)
-        store.previousData = current;
-      const colDef = this._collections.find((c) => c.slug === collection);
-      const jsonFields = colDef?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-      const flatData = flattenPayload(data, "", jsonFields);
-      for (const field of jsonFields) {
-        if (flatData[field] && typeof flatData[field] === "object") {
-          flatData[field] = JSON.stringify(flatData[field]);
-        }
-      }
-      const relationalFields = getRelationalFields(colDef?.fields || []);
-      const hasManyData = {};
-      const blocksData = {};
-      for (const field of relationalFields) {
-        const key = field.name;
-        if (Array.isArray(flatData[key])) {
-          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-            hasManyData[key] = flatData[key];
-          } else if (field.type === "blocks") {
-            blocksData[key] = flatData[key];
-          }
-          delete flatData[key];
-        }
-      }
-      if (Object.keys(flatData).length > 0) {
-        await tx.updateTable(toSnakeCase(collection)).set(flatData).where("id", "=", current.id).execute();
-      }
-      for (const [key, values] of Object.entries(hasManyData)) {
-        const joinTableName = `${toSnakeCase(collection)}_${toSnakeCase(key)}_relations`.toLowerCase();
-        await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-        if (values.length > 0) {
-          const joinData = values.map((val, idx) => {
-            const tId = typeof val === "object" ? val.id : val;
-            return { id: crypto.randomUUID(), source_id: current.id, target_id: tId, order: idx };
-          });
-          await tx.insertInto(joinTableName).values(joinData).execute();
-        }
-      }
-      for (const [key, blocks] of Object.entries(blocksData)) {
-        const blockDef = relationalFields.find((f) => f.name === key && f.type === "blocks");
-        if (blockDef && "blocks" in blockDef && blockDef.blocks) {
-          for (const b of blockDef.blocks) {
-            const blockTableName = `${toSnakeCase(collection)}_${toSnakeCase(key)}_${toSnakeCase(b.slug)}`.toLowerCase();
-            try {
-              await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-            } catch (e) {}
-          }
-        }
-        for (let i = 0;i < blocks.length; i++) {
-          const block = blocks[i];
-          if (!block.blockType)
-            continue;
-          const blockTableName = `${toSnakeCase(collection)}_${toSnakeCase(key)}_${toSnakeCase(block.blockType)}`.toLowerCase();
-          const bId = block.id || crypto.randomUUID();
-          const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
-          const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-          const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
-          for (const f of blockJsonFields) {
-            if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
-              blockFlatData[f] = JSON.stringify(blockFlatData[f]);
-            }
-          }
-          delete blockFlatData.blockType;
-          const blockData = {
-            ...blockFlatData,
-            _parent_id: current.id,
-            _order: i,
-            block_type: block.blockType
-          };
-          await this.db.insertInto(blockTableName).values(blockData).execute();
-        }
-      }
-      return this.findOne(collection, { id: current.id }, tx);
-    });
-  }
-  async updateMany(collection, query, data) {
-    return this.db.transaction().execute(async (tx) => {
-      let qb = tx.updateTable(toSnakeCase(collection));
-      if (query && Object.keys(query).length > 0) {
-        qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-      }
-      const colDef = this._collections.find((c) => c.slug === collection);
-      const jsonFields = colDef?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-      const flatData = flattenPayload(data, "", jsonFields);
-      for (const field of jsonFields) {
-        if (flatData[field] && typeof flatData[field] === "object") {
-          flatData[field] = JSON.stringify(flatData[field]);
-        }
-      }
-      for (const key in flatData) {
-        if (Array.isArray(flatData[key])) {
-          delete flatData[key];
-        }
-      }
-      if (Object.keys(flatData).length > 0) {
-        const result = await qb.set(flatData).executeTakeFirst();
-        return Number(result.numUpdatedRows || 0);
-      }
-      return 0;
-    });
-  }
-  async delete(collection, query) {
-    let normalizedQuery = query;
-    if (typeof query !== "object" || query === null) {
-      normalizedQuery = { id: query };
-    }
-    const current = await this.findOne(collection, normalizedQuery);
-    if (!current)
-      return false;
-    await this.db.transaction().execute(async (tx) => {
-      const colDef = this._collections.find((c) => c.slug === collection);
-      if (colDef) {
-        const relationalFields = getRelationalFields(colDef.fields);
-        for (const field of relationalFields) {
-          if (!field.name)
-            continue;
-          const snakeName = toSnakeCase(field.name);
-          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-            const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
-            try {
-              await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-            } catch (e) {}
-          } else if (field.type === "blocks" && field.blocks) {
-            for (const b of field.blocks) {
-              const blockTableName = `${toSnakeCase(collection)}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-              } catch (e) {}
-            }
-          }
-        }
-      }
-      await tx.deleteFrom(toSnakeCase(collection)).where("id", "=", current.id).execute();
-    });
-    return true;
-  }
-  async deleteMany(collection, query) {
-    return this.db.transaction().execute(async (tx) => {
-      let selectQb = tx.selectFrom(toSnakeCase(collection)).select("id");
-      if (query && Object.keys(query).length > 0) {
-        selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-      }
-      const docs = await selectQb.execute();
-      if (docs.length === 0)
-        return 0;
-      const ids = docs.map((d) => d.id);
-      const colDef = this._collections.find((c) => c.slug === collection);
-      if (colDef) {
-        const relationalFields = getRelationalFields(colDef.fields);
-        for (const field of relationalFields) {
-          if (!field.name)
-            continue;
-          const snakeName = toSnakeCase(field.name);
-          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-            const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
-            try {
-              await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
-            } catch (e) {}
-          } else if (field.type === "blocks" && field.blocks) {
-            for (const b of field.blocks) {
-              const blockTableName = `${toSnakeCase(collection)}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
-              } catch (e) {}
-            }
-          }
-        }
-      }
-      const result = await tx.deleteFrom(toSnakeCase(collection)).where("id", "in", ids).executeTakeFirst();
-      return Number(result.numDeletedRows || 0);
-    });
-  }
-  async findGlobal(slug) {
-    const tableName = toSnakeCase(slug);
-    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
-    return row ? unflattenRow(row) : null;
-  }
-  async updateGlobal(slug, data) {
-    const tableName = toSnakeCase(slug);
-    const existing = await this.findGlobal(slug);
-    const flatData = flattenPayload(data);
-    const globalDef = this._globals.find((g) => g.slug === slug);
-    const now = new Date().toISOString();
-    flatData[toSnakeCase("updatedAt")] = now;
-    if (!existing) {
-      if (!flatData.id)
-        flatData.id = "global";
-      flatData[toSnakeCase("createdAt")] = now;
-      await this.db.insertInto(tableName).values(flatData).execute();
-    } else {
-      await this.db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
-    }
-    return this.findGlobal(slug);
-  }
-  async runMigrations() {
-    const migrator = new Migrator({
-      db: this.db,
-      provider: new FileMigrationProvider({
-        fs,
-        path,
-        migrationFolder: pathToFileURL(path.resolve(process.cwd(), this.migrationDir)).href
-      })
-    });
-    const { error, results } = await migrator.migrateToLatest();
-    results?.forEach((it) => {
-      if (it.status === "Success") {
-        logger.success(`\uD83D\uDE80 Migration "${it.migrationName}" was executed successfully`);
-      } else if (it.status === "Error") {
-        logger.error(`❌ Migration "${it.migrationName}" failed`);
-      }
-    });
-    if (error) {
-      throw error;
-    }
-  }
-  async migrate(collections, globals = []) {
-    this._collections = collections;
-    this._globals = globals;
-    if (this.push) {
-      await pushSchema(this.db, "sqlite", collections, globals, {
-        pushDestructive: this.pushDestructive
-      });
-    }
-  }
-}
-function createBunSQLiteAdapter(path2, options) {
-  return new BunSQLiteAdapter(path2, options);
-}
-
-export { BunSQLiteAdapter, createBunSQLiteAdapter };