opacacms 0.2.0 → 0.3.0

package/dist/{chunk-0gtxnxmd.js → chunk-qsh2nqz3.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,18 +17,20 @@ import {
 } from "./chunk-qxt9vge8.js";
 import {
   logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-jq1drsen.js";
+import {
+  __require
+} from "./chunk-6bywt602.js";
 
 // src/db/bun-sqlite.ts
-import { Database } from "bun:sqlite";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { FileMigrationProvider, Kysely, Migrator, sql } from "kysely";
-import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { FileMigrationProvider, Migrator, sql } from "kysely";
 class BunSQLiteAdapter extends BaseDatabaseAdapter {
+  path;
   name = "bun-sqlite";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -35,73 +40,47 @@ class BunSQLiteAdapter 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 BunSqliteDialect({
-        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 { Database } = await import("bun:sqlite");
+    const { BunSqliteDialect } = await import("kysely-bun-sqlite");
+    this._rawDb = new Database(this.path);
+    const { createOpacaKysely } = await import("./chunk-sqsfk9p4.js");
+    this._db = createOpacaKysely({
+      dialect: new BunSqliteDialect({
+        database: this._rawDb
+      }),
+      config: {
+        collections: this._collections,
+        globals: this._globals,
+        db: { name: "bun-sqlite" }
+      }
+    });
+  }
   async disconnect() {
-    await this._db.destroy();
+    if (this._db)
+      await this.db.destroy();
   }
   async unsafe(query, params) {
     const compiled = sql.raw(query);
-    const result = await compiled.execute(this._db);
+    const result = await compiled.execute(this.db);
     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") {
-            const d = new Date(value);
-            if (!isNaN(d.getTime())) {
-              result[colName] = d.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));
     }
@@ -111,13 +90,7 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
   async create(collection, data) {
     const tableName = toSnakeCase(collection);
     const colDef = this._collections.find((c) => c.slug === collection);
-    const jsonFields = colDef?.fields.filter((f) => f.name && ["richtext", "json", "file"].includes(f.type)).map((f) => toSnakeCase(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 flatData = flattenPayload(data);
     const relationalFields = getRelationalFields(colDef?.fields || []);
     const hasManyData = {};
     const blocksData = {};
@@ -132,24 +105,18 @@ class BunSQLiteAdapter 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 this._db.insertInto(tableName).values(coercedData).execute();
+    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) {
@@ -157,7 +124,7 @@ class BunSQLiteAdapter 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)) {
@@ -177,20 +144,20 @@ class BunSQLiteAdapter 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));
@@ -254,9 +221,17 @@ class BunSQLiteAdapter 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));
     }
@@ -266,11 +241,13 @@ class BunSQLiteAdapter 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,
@@ -278,10 +255,12 @@ class BunSQLiteAdapter 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);
@@ -296,7 +275,7 @@ class BunSQLiteAdapter 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] = [];
@@ -320,7 +299,7 @@ class BunSQLiteAdapter 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;
@@ -359,13 +338,15 @@ class BunSQLiteAdapter 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 };
@@ -373,6 +354,9 @@ class BunSQLiteAdapter 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) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -395,10 +379,8 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
           delete flatData[key];
         }
       }
-      flatData.updated_at = new Date().toISOString();
       if (Object.keys(flatData).length > 0) {
-        const coercedData = await this.coerceData(collection, flatData);
-        await tx.updateTable(toSnakeCase(collection)).set(coercedData).where("id", "=", current.id).execute();
+        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();
@@ -436,20 +418,20 @@ class BunSQLiteAdapter 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 }, tx);
     });
   }
   async updateMany(collection, query, data) {
-    return this._db.transaction().execute(async (tx) => {
+    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));
@@ -467,10 +449,8 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
           delete flatData[key];
         }
       }
-      flatData.updated_at = 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;
@@ -484,7 +464,7 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
     const current = await this.findOne(collection, normalizedQuery);
     if (!current)
       return false;
-    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);
@@ -512,7 +492,7 @@ class BunSQLiteAdapter extends BaseDatabaseAdapter {
     return true;
   }
   async deleteMany(collection, query) {
-    return this._db.transaction().execute(async (tx) => {
+    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));
@@ -549,7 +529,7 @@ class BunSQLiteAdapter 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) {
@@ -563,15 +543,15 @@ class BunSQLiteAdapter 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,
@@ -594,7 +574,7 @@ class BunSQLiteAdapter 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
       });
     }

package/dist/chunk-r0ms5tk1.js

@@ -0,0 +1,76 @@
+import {
+  require_picocolors
+} from "./chunk-rwqwsanx.js";
+import {
+  Gt,
+  R,
+  Vt,
+  Wt
+} from "./chunk-ec4jhybj.js";
+import {
+  defineCommand
+} from "./chunk-1qm0m8r8.js";
+import {
+  __toESM
+} from "./chunk-6bywt602.js";
+
+// src/cli/commands/dev.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { resolve } from "node:path";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var dev_default = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the OpacaCMS development server"
+  },
+  args: {
+    entry: {
+      type: "string",
+      description: "Path to your entry point (default: index.ts)",
+      default: "index.ts"
+    }
+  },
+  async run({ args }) {
+    console.log();
+    Wt(import_picocolors.default.bgBlue(import_picocolors.default.white(" OpacaCMS Dev Server ")));
+    const entryPath = resolve(process.cwd(), args.entry);
+    if (!fs.existsSync(entryPath)) {
+      R.error(import_picocolors.default.red(`Entry file not found at ${entryPath}`));
+      R.info("Try specifying the entry file: opacacms dev --entry src/index.ts");
+      process.exit(1);
+    }
+    Vt(`Watching for changes...`, "Status");
+    const isD1 = fs.readFileSync(entryPath, "utf-8").includes("createCloudflareWorkersHandler");
+    let cmd = "bun";
+    let cmdArgs = ["run", "--watch", args.entry];
+    if (isD1) {
+      cmd = "bun";
+      cmdArgs = ["x", "wrangler", "dev", args.entry];
+    }
+    const child = spawn(cmd, cmdArgs, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+      env: process.env
+    });
+    child.on("error", (err) => {
+      R.error(import_picocolors.default.red(`Failed to start server: ${err.message}`));
+    });
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        R.warn(`Server exited with code ${code}`);
+      }
+      Gt("Goodbye!");
+      process.exit(code || 0);
+    });
+    process.on("SIGINT", () => {
+      child.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      child.kill("SIGTERM");
+    });
+  }
+});
+export {
+  dev_default as default
+};

package/dist/chunk-rwqwsanx.js

@@ -0,0 +1,75 @@
+import {
+  __commonJS
+} from "./chunk-6bywt602.js";
+
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+export { require_picocolors };