opacacms 0.2.0 → 0.3.0

package/dist/{chunk-0bq155dy.js → chunk-e0g6gn7n.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,20 +17,25 @@ import {
 } from "./chunk-qxt9vge8.js";
 import {
   logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-jq1drsen.js";
+import {
+  __require
+} from "./chunk-6bywt602.js";
 
 // src/db/sqlite.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createRequire } from "node:module";
-import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect } from "kysely";
-var require2 = createRequire(import.meta.url);
-var Database = require2("better-sqlite3");
-
+import {
+  CompiledQuery,
+  FileMigrationProvider,
+  Migrator,
+  SqliteDialect
+} from "kysely";
 class SQLiteAdapter extends BaseDatabaseAdapter {
+  path;
   name = "sqlite";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -37,70 +45,48 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     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._rawDb = new Database(path2);
-    this._db = new Kysely({
-      dialect: new SqliteDialect({
-        database: this._rawDb
-      })
-    });
+    this.path = path2;
     this.push = options?.push ?? true;
     this.pushDestructive = options?.pushDestructive ?? false;
     this.migrationDir = options?.migrationDir ?? "./migrations";
   }
-  async connect() {}
+  async connect() {
+    if (this._db)
+      return;
+    const { createRequire } = await import("node:module");
+    const require2 = createRequire(import.meta.url);
+    const Database = require2("better-sqlite3");
+    this._rawDb = new Database(this.path);
+    const { createOpacaKysely } = await import("./chunk-sqsfk9p4.js");
+    this._db = createOpacaKysely({
+      dialect: new SqliteDialect({
+        database: this._rawDb
+      }),
+      config: {
+        collections: this._collections,
+        globals: this._globals,
+        db: { name: "sqlite" }
+      }
+    });
+  }
   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));
     }
@@ -109,7 +95,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async create(collection, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       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);
@@ -127,24 +113,18 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
           delete flatData[key];
         }
       }
-      if (!flatData.id)
-        flatData.id = crypto.randomUUID();
       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 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);
-      await tx.insertInto(tableName).values(coercedData).execute();
+      await tx.insertInto(tableName).values(filteredData).execute();
       for (const [key, values] of Object.entries(hasManyData)) {
         const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
         if (values.length > 0) {
@@ -172,13 +152,13 @@ class SQLiteAdapter 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 tx.insertInto(blockTableName).values(coercedBlockData).execute();
+          };
+          await tx.insertInto(blockTableName).values(blockData).execute();
         }
       }
       return this.findOne(collection, { id: flatData.id }, tx);
@@ -186,7 +166,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   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));
@@ -250,9 +230,17 @@ class SQLiteAdapter 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));
     }
@@ -262,11 +250,13 @@ class SQLiteAdapter 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,
@@ -274,10 +264,12 @@ class SQLiteAdapter 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);
@@ -292,7 +284,7 @@ class SQLiteAdapter 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] = [];
@@ -316,7 +308,7 @@ class SQLiteAdapter 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;
@@ -355,13 +347,15 @@ class SQLiteAdapter 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) {
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let normalizedQuery = query;
       if (typeof query !== "object" || query === null) {
         normalizedQuery = { id: query };
@@ -369,6 +363,9 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
       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) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -386,16 +383,9 @@ class SQLiteAdapter 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();
-      }
       const tableName = toSnakeCase(collection);
       if (Object.keys(flatData).length > 0) {
-        const coercedData = await this.coerceData(collection, flatData);
-        await tx.updateTable(tableName).set(coercedData).where("id", "=", current.id).execute();
+        await tx.updateTable(tableName).set(flatData).where("id", "=", current.id).execute();
       }
       for (const [key, values] of Object.entries(hasManyData)) {
         const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
@@ -433,13 +423,13 @@ class SQLiteAdapter 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 tx.insertInto(blockTableName).values(coercedBlockData).execute();
+          };
+          await tx.insertInto(blockTableName).values(blockData).execute();
         }
       }
       return this.findOne(collection, { id: current.id }, tx);
@@ -454,7 +444,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     if (!current)
       return false;
     const tableName = toSnakeCase(collection);
-    await this._db.transaction().execute(async (tx) => {
+    await this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       if (colDef) {
         const relationalFields = getRelationalFields(colDef.fields);
@@ -483,7 +473,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async updateMany(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let qb = tx.updateTable(tableName);
       if (query && Object.keys(query).length > 0) {
         qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -503,8 +493,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
         flatData[updatedField] = new Date().toISOString();
       }
       if (Object.keys(flatData).length > 0) {
-        const coercedData = await this.coerceData(collection, flatData);
-        const result = await qb.set(coercedData).executeTakeFirst();
+        const result = await qb.set(flatData).executeTakeFirst();
         return Number(result.numUpdatedRows || 0);
       }
       return 0;
@@ -512,7 +501,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async deleteMany(collection, query) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let selectQb = tx.selectFrom(tableName).select("id");
       if (query && Object.keys(query).length > 0) {
         selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -549,7 +538,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   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) {
@@ -562,15 +551,15 @@ class SQLiteAdapter 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,
@@ -593,7 +582,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     this._collections = collections;
     this._globals = globals;
     if (this.push) {
-      await pushSchema(this._db, "sqlite", collections, globals, {
+      await pushSchema(this.db, "sqlite", collections, globals, {
         pushDestructive: this.pushDestructive
       });
     }