opacacms 0.1.21 → 0.2.1

package/dist/{chunk-fqastxq9.js → chunk-06ks4ggh.js}

@@ -3,28 +3,30 @@ import {
   flattenPayload,
   pushSchema,
   unflattenRow
-} from "./chunk-cpw2y3pn.js";
+} from "./chunk-dykn5hr6.js";
 import {
   BaseDatabaseAdapter
 } from "./chunk-s8mqwnm1.js";
-import {
-  logger
-} from "./chunk-62ev8gnc.js";
 import {
   flattenFields,
   getRelationalFields,
   toSnakeCase
-} from "./chunk-2kyhqvhc.js";
+} from "./chunk-qxt9vge8.js";
+import {
+  logger
+} from "./chunk-t0zg026p.js";
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
 
 // src/db/d1.ts
 import fs from "node:fs/promises";
 import path from "node:path";
 import { CompiledQuery, FileMigrationProvider, Kysely, Migrator } from "kysely";
-import { D1Dialect } from "kysely-d1";
 class D1Adapter extends BaseDatabaseAdapter {
   name = "d1";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -34,26 +36,33 @@ class D1Adapter extends BaseDatabaseAdapter {
     return this._rawDb;
   }
   get db() {
+    if (!this._db)
+      throw new Error("Database not connected. Call connect() first.");
     return this._db;
   }
   constructor(db, options) {
     super();
     this._rawDb = db;
-    this._db = new Kysely({
-      dialect: new D1Dialect({ database: db })
-    });
     const isDev = typeof process !== "undefined" && true;
     this.push = options?.push ?? isDev;
     this.pushDestructive = options?.pushDestructive ?? false;
     this.migrationDir = options?.migrationDir ?? "./migrations";
   }
-  async connect() {}
+  async connect() {
+    if (this._db)
+      return;
+    const { D1Dialect } = await import("kysely-d1");
+    this._db = new Kysely({
+      dialect: new D1Dialect({ database: this._rawDb })
+    });
+  }
   async disconnect() {
-    await this._db.destroy();
+    if (this._db)
+      await this.db.destroy();
   }
   async unsafe(query, params) {
     const compiled = CompiledQuery.raw(query, params || []);
-    const result = await this._db.executeQuery(compiled);
+    const result = await this.db.executeQuery(compiled);
     return result.rows;
   }
   async coerceData(collection, data) {
@@ -96,7 +105,7 @@ class D1Adapter extends BaseDatabaseAdapter {
   }
   async count(collection, query) {
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
+    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));
     }
@@ -140,7 +149,7 @@ class D1Adapter extends BaseDatabaseAdapter {
     }
     const coercedData = await this.coerceData(collection, filteredData);
     try {
-      await this._db.insertInto(tableName).values(coercedData).execute();
+      await this.db.insertInto(tableName).values(coercedData).execute();
     } catch (e) {
       logger.error(`[D1] Create failed in ${collection}: ${e.message}`);
       throw e;
@@ -152,7 +161,7 @@ class D1Adapter extends BaseDatabaseAdapter {
           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();
+        await this.db.insertInto(joinTableName).values(joinData).execute();
       }
     }
     for (const [key, blocks] of Object.entries(blocksData)) {
@@ -178,14 +187,14 @@ class D1Adapter extends BaseDatabaseAdapter {
           _order: i,
           block_type: block.blockType
         });
-        await this._db.insertInto(blockTableName).values(coercedBlockData).execute();
+        await this.db.insertInto(blockTableName).values(coercedBlockData).execute();
       }
     }
-    return this.findOne(collection, { id: flatData.id }, this._db);
+    return this.findOne(collection, { id: flatData.id }, this.db);
   }
   async findOne(collection, query, tx) {
     const tableName = toSnakeCase(collection);
-    const executor = tx || this._db;
+    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));
@@ -251,7 +260,7 @@ class D1Adapter extends BaseDatabaseAdapter {
     const offset = (page - 1) * limit;
     const total = await this.count(collection, query);
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
+    let qb = this.db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -264,7 +273,87 @@ class D1Adapter extends BaseDatabaseAdapter {
       qb = qb.orderBy("created_at", "desc");
     }
     const rows = await qb.execute();
-    const docs = await Promise.all(rows.map((row) => this.findOne(collection, { id: row.id })));
+    if (rows.length === 0) {
+      const totalPages2 = Math.ceil(total / limit);
+      return {
+        docs: [],
+        totalDocs: total,
+        limit,
+        totalPages: totalPages2,
+        page,
+        pagingCounter: offset + 1,
+        hasNextPage: page * limit < total,
+        hasPrevPage: page > 1,
+        prevPage: page > 1 ? page - 1 : null,
+        nextPage: page < totalPages2 ? page + 1 : 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);
     return {
       docs: docs.filter(Boolean),
@@ -285,7 +374,7 @@ class D1Adapter extends BaseDatabaseAdapter {
     if (typeof query !== "object" || query === null) {
       normalizedQuery = { id: query };
     }
-    const current = await this.findOne(collection, normalizedQuery, this._db);
+    const current = await this.findOne(collection, normalizedQuery, this.db);
     if (!current)
       throw new Error("Document not found");
     const colDef = this._collections.find((c) => c.slug === collection);
@@ -328,7 +417,7 @@ class D1Adapter extends BaseDatabaseAdapter {
       }
       const coercedData = await this.coerceData(collection, filteredData);
       try {
-        await this._db.updateTable(tableName).set(coercedData).where("id", "=", current.id).execute();
+        await this.db.updateTable(tableName).set(coercedData).where("id", "=", current.id).execute();
       } catch (e) {
         logger.error(`[D1] Update failed in ${collection}: ${e.message}`);
         throw e;
@@ -336,13 +425,13 @@ class D1Adapter extends BaseDatabaseAdapter {
     }
     for (const [key, values] of Object.entries(hasManyData)) {
       const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
-      await this._db.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+      await this.db.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 this._db.insertInto(joinTableName).values(joinData).execute();
+        await this.db.insertInto(joinTableName).values(joinData).execute();
       }
     }
     for (const [key, blocks] of Object.entries(blocksData)) {
@@ -351,7 +440,7 @@ class D1Adapter extends BaseDatabaseAdapter {
         for (const b of blockDef.blocks) {
           const blockTableName = `${tableName}_${toSnakeCase(key)}_${toSnakeCase(b.slug)}`.toLowerCase();
           try {
-            await this._db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+            await this.db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
           } catch (e) {}
         }
       }
@@ -376,14 +465,14 @@ class D1Adapter extends BaseDatabaseAdapter {
           _order: i,
           block_type: block.blockType
         });
-        await this._db.insertInto(blockTableName).values(coercedBlockData).execute();
+        await this.db.insertInto(blockTableName).values(coercedBlockData).execute();
       }
     }
-    return this.findOne(collection, { id: current.id }, this._db);
+    return this.findOne(collection, { id: current.id }, this.db);
   }
   async updateMany(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    let qb = this._db.updateTable(tableName);
+    let qb = this.db.updateTable(tableName);
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -447,31 +536,31 @@ class D1Adapter extends BaseDatabaseAdapter {
         if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
           const joinTableName = `${tableName}_${snakeName}_relations`.toLowerCase();
           try {
-            await this._db.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+            await this.db.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
           } catch (e) {}
         } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
           for (const b of field.blocks) {
             const blockTableName = `${tableName}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
             try {
-              await this._db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+              await this.db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
             } catch (e) {}
           }
         }
       }
     }
-    await this._db.deleteFrom(tableName).where("id", "=", current.id).execute();
+    await this.db.deleteFrom(tableName).where("id", "=", current.id).execute();
     return true;
   }
   async deleteMany(collection, query) {
     const tableName = toSnakeCase(collection);
-    let selectQb = this._db.selectFrom(tableName).select("id");
+    let selectQb = this.db.selectFrom(tableName).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)
+    const rowsToDelete = await selectQb.execute();
+    const idsToDelete = rowsToDelete.map((row) => row.id);
+    if (idsToDelete.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);
@@ -482,24 +571,24 @@ class D1Adapter extends BaseDatabaseAdapter {
         if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
           const joinTableName = `${tableName}_${snakeName}_relations`.toLowerCase();
           try {
-            await this._db.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
+            await this.db.deleteFrom(joinTableName).where("source_id", "in", idsToDelete).execute();
           } catch (e) {}
         } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
           for (const b of field.blocks) {
             const blockTableName = `${tableName}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
             try {
-              await this._db.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
+              await this.db.deleteFrom(blockTableName).where("_parent_id", "in", idsToDelete).execute();
             } catch (e) {}
           }
         }
       }
     }
-    const result = await this._db.deleteFrom(tableName).where("id", "in", ids).executeTakeFirst();
+    const result = await this.db.deleteFrom(tableName).where("id", "in", idsToDelete).executeTakeFirst();
     return Number(result.numDeletedRows || 0);
   }
   async findGlobal(slug) {
     const tableName = toSnakeCase(slug);
-    const row = await this._db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
+    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
     return row ? unflattenRow(row) : null;
   }
   async updateGlobal(slug, data) {
@@ -513,15 +602,15 @@ class D1Adapter extends BaseDatabaseAdapter {
       if (!flatData.id)
         flatData.id = "global";
       flatData[toSnakeCase("createdAt")] = now;
-      await this._db.insertInto(tableName).values(flatData).execute();
+      await this.db.insertInto(tableName).values(flatData).execute();
     } else {
-      await this._db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
+      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,
+      db: this.db,
       provider: new FileMigrationProvider({
         fs,
         path,
@@ -544,7 +633,7 @@ class D1Adapter extends BaseDatabaseAdapter {
     this._collections = collections;
     this._globals = globals;
     if (this.push) {
-      await pushSchema(this._db, "d1", collections, globals, {
+      await pushSchema(this.db, "d1", collections, globals, {
         pushDestructive: this.pushDestructive
       });
     }