opacacms 0.2.0 → 0.3.0

package/dist/{chunk-d1asgtke.js → chunk-qhdsjek6.js}

@@ -3,10 +3,13 @@ import {
   flattenPayload,
   pushSchema,
   unflattenRow
-} from "./chunk-dykn5hr6.js";
+} from "./chunk-j8js1y0h.js";
 import {
   BaseDatabaseAdapter
 } from "./chunk-s8mqwnm1.js";
+import {
+  requestContext
+} from "./chunk-q5sb5dcr.js";
 import {
   flattenFields,
   getRelationalFields,
@@ -14,17 +17,19 @@ import {
 } from "./chunk-qxt9vge8.js";
 import {
   logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-jq1drsen.js";
+import {
+  __require
+} from "./chunk-6bywt602.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";
+import { CompiledQuery, FileMigrationProvider, Migrator } from "kysely";
 class D1Adapter extends BaseDatabaseAdapter {
   name = "d1";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -34,69 +39,44 @@ 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");
+    const { createOpacaKysely } = await import("./chunk-sqsfk9p4.js");
+    this._db = createOpacaKysely({
+      dialect: new D1Dialect({ database: this._rawDb }),
+      config: {
+        collections: this._collections,
+        globals: this._globals,
+        db: { name: "d1" }
+      }
+    });
+  }
   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) {
-    const colDef = this._collections.find((c) => c.slug === collection);
-    if (!colDef)
-      return data;
-    const result = { ...data };
-    const allFields = flattenFields(colDef.fields);
-    for (const field of allFields) {
-      const colName = toSnakeCase(field.name);
-      if (!(colName in result))
-        continue;
-      const value = result[colName];
-      if (value === undefined || value === null)
-        continue;
-      switch (field.type) {
-        case "boolean":
-          result[colName] = value ? 1 : 0;
-          break;
-        case "number":
-          result[colName] = Number(value);
-          break;
-        case "date":
-          if (value instanceof Date) {
-            result[colName] = value.toISOString();
-          } else if (typeof value === "string") {
-            result[colName] = new Date(value).toISOString();
-          }
-          break;
-        case "richtext":
-        case "json":
-        case "file":
-          if (typeof value === "object") {
-            result[colName] = JSON.stringify(value);
-          }
-          break;
-      }
-    }
-    return result;
-  }
   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));
     }
@@ -129,18 +109,14 @@ class D1Adapter extends BaseDatabaseAdapter {
     validCols.add("id");
     validCols.add(toSnakeCase("createdAt"));
     validCols.add(toSnakeCase("updatedAt"));
-    const now = new Date().toISOString();
-    flatData[toSnakeCase("createdAt")] = now;
-    flatData[toSnakeCase("updatedAt")] = now;
     const filteredData = {};
     for (const col of Object.keys(flatData)) {
       if (validCols.has(col)) {
         filteredData[col] = flatData[col];
       }
     }
-    const coercedData = await this.coerceData(collection, filteredData);
     try {
-      await this._db.insertInto(tableName).values(coercedData).execute();
+      await this.db.insertInto(tableName).values(filteredData).execute();
     } catch (e) {
       logger.error(`[D1] Create failed in ${collection}: ${e.message}`);
       throw e;
@@ -152,7 +128,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)) {
@@ -172,20 +148,20 @@ class D1Adapter extends BaseDatabaseAdapter {
           }
         }
         delete blockFlatData.blockType;
-        const coercedBlockData = await this.coerceData(blockTableName, {
+        const blockData = {
           ...blockFlatData,
           _parent_id: flatData.id,
           _order: i,
           block_type: block.blockType
-        });
-        await this._db.insertInto(blockTableName).values(coercedBlockData).execute();
+        };
+        await this.db.insertInto(blockTableName).values(blockData).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));
@@ -249,9 +225,17 @@ class D1Adapter extends BaseDatabaseAdapter {
     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).offset(offset);
+    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));
     }
@@ -261,11 +245,13 @@ class D1Adapter extends BaseDatabaseAdapter {
         qb = qb.orderBy(col, dir === "desc" ? "desc" : "asc");
       }
     } else {
-      qb = qb.orderBy("created_at", "desc");
+      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,
@@ -273,10 +259,12 @@ class D1Adapter extends BaseDatabaseAdapter {
         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
+        hasNextPage: false,
+        hasPrevPage: !!afterAnchor || page > 1,
+        prevPage: null,
+        nextPage: null,
+        nextCursor: null,
+        prevCursor: afterAnchor ? afterAnchor : null
       };
     }
     const rowIds = rows.map((r) => r.id);
@@ -291,7 +279,7 @@ class D1Adapter extends BaseDatabaseAdapter {
         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 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] = [];
@@ -315,7 +303,7 @@ class D1Adapter extends BaseDatabaseAdapter {
           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();
+              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;
@@ -354,9 +342,11 @@ class D1Adapter extends BaseDatabaseAdapter {
       page,
       pagingCounter: offset + 1,
       hasNextPage: page * limit < total,
-      hasPrevPage: page > 1,
+      hasPrevPage: page > 1 || !!options?.after || !!options?.before,
       prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < totalPages ? page + 1 : null
+      nextPage: page < totalPages ? page + 1 : null,
+      nextCursor: 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) {
@@ -365,9 +355,12 @@ 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 store = requestContext.getStore();
+    if (store)
+      store.previousData = current;
     const colDef = this._collections.find((c) => c.slug === collection);
     const jsonFields = colDef?.fields.filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
     const flatData = flattenPayload(data, "", jsonFields);
@@ -385,30 +378,18 @@ class D1Adapter extends BaseDatabaseAdapter {
         delete flatData[key];
       }
     }
-    const ts = colDef?.timestamps !== false;
-    if (ts) {
-      const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
-      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
-      flatData[updatedField] = new Date().toISOString();
-    }
     if (Object.keys(flatData).length > 0) {
       const dbFields = flattenFields(colDef?.fields || []);
       const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
       validCols.add("id");
-      if (ts) {
-        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
-        validCols.add(toSnakeCase(config.createdAt || "createdAt"));
-        validCols.add(toSnakeCase(config.updatedAt || "updatedAt"));
-      }
       const filteredData = {};
       for (const col of Object.keys(flatData)) {
         if (validCols.has(col)) {
           filteredData[col] = flatData[col];
         }
       }
-      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(filteredData).where("id", "=", current.id).execute();
       } catch (e) {
         logger.error(`[D1] Update failed in ${collection}: ${e.message}`);
         throw e;
@@ -416,13 +397,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)) {
@@ -431,7 +412,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) {}
         }
       }
@@ -450,20 +431,20 @@ class D1Adapter extends BaseDatabaseAdapter {
           }
         }
         delete blockFlatData.blockType;
-        const coercedBlockData = await this.coerceData(blockTableName, {
+        const blockData = {
           ...blockFlatData,
           _parent_id: current.id,
           _order: i,
           block_type: block.blockType
-        });
-        await this._db.insertInto(blockTableName).values(coercedBlockData).execute();
+        };
+        await this.db.insertInto(blockTableName).values(blockData).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));
     }
@@ -475,31 +456,19 @@ class D1Adapter extends BaseDatabaseAdapter {
         delete flatData[key];
       }
     }
-    const ts = colDef?.timestamps !== false;
-    if (ts) {
-      const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
-      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
-      flatData[updatedField] = new Date().toISOString();
-    }
     if (Object.keys(flatData).length > 0) {
       const dbFields = flattenFields(colDef?.fields || []);
       const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
       validCols.add("id");
-      if (ts) {
-        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
-        validCols.add(toSnakeCase(config.createdAt || "createdAt"));
-        validCols.add(toSnakeCase(config.updatedAt || "updatedAt"));
-      }
       const filteredData = {};
       for (const col of Object.keys(flatData)) {
         if (validCols.has(col)) {
           filteredData[col] = flatData[col];
         }
       }
-      const coercedData = await this.coerceData(collection, filteredData);
       logger.debug(`[D1] Bulk updating in ${collection}...`);
       try {
-        const result = await qb.set(coercedData).executeTakeFirst();
+        const result = await qb.set(filteredData).executeTakeFirst();
         return Number(result.numUpdatedRows || 0);
       } catch (e) {
         logger.error(`[D1] Bulk update failed in ${collection}: ${e.message}`);
@@ -527,31 +496,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);
@@ -562,24 +531,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) {
@@ -593,15 +562,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,
@@ -624,7 +593,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
       });
     }