opacacms 0.2.1 → 0.3.1

package/dist/{chunk-51z3x7kq.js → chunk-a3qae86h.js}

@@ -3,7 +3,7 @@ async function loadPluginSettings(config) {
   if (!config.db)
     return {};
   try {
-    const result = await config.db.find("_opaca_plugin_settings");
+    const result = await config.db.find("_plugin_settings");
     if (!result || !result.docs)
       return {};
     return result.docs.reduce((acc, curr) => {

package/dist/{chunk-3rdhbedb.js → chunk-adq2b75c.js}

@@ -1,8 +1,8 @@
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-v9z61v3g.js";
-import"./chunk-8sqjbsgt.js";
+} from "./chunk-6qs0g65f.js";
+import"./chunk-6bywt602.js";
 init_system_schema();
 
 export {

package/dist/chunk-d0tb1xjw.js

@@ -0,0 +1,93 @@
+import {
+  require_picocolors
+} from "./chunk-rwqwsanx.js";
+import {
+  Gt,
+  R,
+  Wt,
+  be
+} from "./chunk-ec4jhybj.js";
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./chunk-majsbncm.js";
+import {
+  defineCommand
+} from "./chunk-1qm0m8r8.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-6bywt602.js";
+
+// src/cli/commands/seed.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+
+// src/cli/core/seeding/seed-logic.ts
+async function seedCommand(opaca, count, reset, type, targetTable) {
+  const { autoSeed } = await import("./chunk-3j9zjfmn.js");
+  try {
+    await autoSeed(opaca, count, reset, type);
+  } catch (error) {
+    console.error(`[OpacaCMS] Seeding failed: ${error.message}`);
+    throw error;
+  }
+}
+
+// src/cli/commands/seed.ts
+var seed_default = defineCommand({
+  meta: {
+    name: "seed",
+    description: "Seed the database with mock data"
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      description: "Path to the OpacaCMS configuration file"
+    },
+    count: {
+      type: "string",
+      description: "Number of documents to seed",
+      default: "10"
+    },
+    reset: {
+      type: "boolean",
+      description: "Clear the database before seeding"
+    },
+    assets: {
+      type: "boolean",
+      description: "Seed only assets"
+    }
+  },
+  async run({ args }) {
+    console.log();
+    Wt(import_picocolors.default.bgGreen(import_picocolors.default.white(" OpacaCMS Seeder ")));
+    const s = be();
+    s.start("Loading configuration...");
+    let opaca;
+    try {
+      const configPath = resolveConfigPath(args.config);
+      opaca = await loadConfig(configPath);
+      s.stop(`Configuration loaded. DB: ${import_picocolors.default.cyan(opaca.db.name)}`);
+    } catch (err) {
+      s.stop(import_picocolors.default.red("Failed to load configuration."));
+      R.error(err.message);
+      process.exit(1);
+    }
+    const type = args.assets ? "assets" : "collections";
+    const count = parseInt(args.count, 10);
+    s.start(`Seeding ${count} ${type}...`);
+    try {
+      await seedCommand(opaca, count, !!args.reset, type);
+      s.stop(`Successfully seeded ${import_picocolors.default.green(count)} ${type}!`);
+      Gt("Database seeded successfully. \uD83C\uDF31");
+    } catch (error) {
+      s.stop(import_picocolors.default.red("Seeding failed."));
+      R.error(error.message);
+      process.exit(1);
+    }
+  }
+});
+export {
+  seed_default as default
+};

package/dist/chunk-d7cgd6vn.js

@@ -0,0 +1,318 @@
+import {
+  generateDiffCode
+} from "./chunk-7rr5p01g.js";
+import {
+  require_picocolors
+} from "./chunk-rwqwsanx.js";
+import {
+  Gt,
+  R,
+  Wt,
+  be
+} from "./chunk-ec4jhybj.js";
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./chunk-majsbncm.js";
+import {
+  defineCommand
+} from "./chunk-1qm0m8r8.js";
+import {
+  getRandomMigrationName
+} from "./chunk-5b8r0v8c.js";
+import"./chunk-qxt9vge8.js";
+import {
+  logger
+} from "./chunk-jq1drsen.js";
+import"./chunk-6qs0g65f.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-6bywt602.js";
+
+// src/cli/commands/migrate.ts
+import fs2 from "node:fs";
+import { relative as relative2, resolve as resolve2 } from "node:path";
+var import_picocolors = __toESM(require_picocolors(), 1);
+
+// src/cli/core/migrations/migrate-logic.ts
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { relative, resolve } from "node:path";
+async function migrateCreateCommand(opaca, migrationName, outDir) {
+  const db = opaca.db;
+  const migrationDir = outDir || db.migrationDir || "./migrations";
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+  if (!fs.existsSync(fullMigrationDir)) {
+    fs.mkdirSync(fullMigrationDir, { recursive: true });
+  }
+  const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
+  const { generateDiffCode: generateDiffCode2 } = await import("./chunk-gyaf5kgf.js");
+  let dialect = "sqlite";
+  if (db.name === "postgres")
+    dialect = "postgres";
+  if (db.name === "d1")
+    dialect = "d1";
+  const isD1 = dialect === "d1";
+  const name = !migrationName || migrationName === "migration" ? getRandomMigrationName() : migrationName;
+  const snapshotName = `${timestamp}_${name}`;
+  const fileName = `${snapshotName}.${isD1 ? "sql" : "ts"}`;
+  const filePath = resolve(fullMigrationDir, fileName);
+  const result = await generateDiffCode2(opaca, dialect, migrationDir, snapshotName, {
+    saveSnapshot: true,
+    interactive: true
+  });
+  if (!result.hasChanges) {
+    logger.info("✨ No schema changes detected. Migration not created.");
+    return false;
+  }
+  let template = "";
+  if (isD1) {
+    template = `-- OpacaCMS Auto-generated SQL Migration
+-- Migration: ${snapshotName}
+
+-- UP
+${result.upCode}
+`;
+  } else {
+    template = `import { type OpacaMigrationDb, sql } from 'opacacms/db';
+
+export async function up(db: OpacaMigrationDb): Promise<void> {
+${result.upCode}}
+
+export async function down(db: OpacaMigrationDb): Promise<void> {
+${result.downCode}}
+`;
+  }
+  fs.writeFileSync(filePath, template);
+  logger.success(`\uD83D\uDE80 Migration created successfully at ${relative(process.cwd(), filePath)}`);
+  return true;
+}
+async function migrateRunCommand(db) {
+  logger.info("\uD83C\uDFAC Running migrations...");
+  if (db.runMigrations) {
+    await db.connect();
+    try {
+      await db.runMigrations();
+      logger.success("✅ Migrations applied successfully!");
+    } catch (error) {
+      logger.error(`❌ Failed to run migrations: ${error.message}`);
+      throw error;
+    } finally {}
+  } else {
+    throw new Error(`Adapter ${db.name} does not support running migrations.`);
+  }
+}
+async function migrateStatusCommand(opaca) {
+  logger.info("\uD83D\uDCCA Checking migration status...");
+  const db = opaca.db;
+  const migrationDir = db.migrationDir || "./migrations";
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+  if (!fs.existsSync(fullMigrationDir)) {
+    logger.info("No migrations directory found.");
+    return;
+  }
+  const migrationFiles = fs.readdirSync(fullMigrationDir).filter((f) => f.endsWith(".ts") || f.endsWith(".sql")).sort();
+  let appliedMigrations = [];
+  try {
+    await db.connect();
+    const rows = await db.unsafe("SELECT name FROM kysely_migration").catch(() => []);
+    appliedMigrations = rows.map((r) => r.name);
+  } catch (e) {} finally {}
+  console.log(`
+Found ${migrationFiles.length} migration files in ${migrationDir}:`);
+  for (const file of migrationFiles) {
+    const name = file.replace(/\.(ts|sql)$/, "");
+    const isApplied = appliedMigrations.includes(name);
+    console.log(`  ${isApplied ? "✅ [Applied]  " : "❌ [Pending]  "} ${file}`);
+  }
+  const pending = migrationFiles.filter((f) => !appliedMigrations.includes(f.replace(/\.(ts|sql)$/, "")));
+  if (pending.length > 0) {
+    console.log(`
+\uD83D\uDCA1 You have ${pending.length} pending migrations. Run 'opacacms migrate' to apply them.`);
+  } else {
+    console.log(`
+✨ All migrations are up to date.`);
+  }
+}
+async function migrateD1Command(migrationDir, isRemote, binding = "DB") {
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+  if (!fs.existsSync(fullMigrationDir)) {
+    throw new Error(`[OpacaCMS] Migration directory not found: ${fullMigrationDir}`);
+  }
+  const migrations = fs.readdirSync(fullMigrationDir).filter((file) => file.endsWith(".sql")).sort();
+  if (migrations.length === 0) {
+    console.log(`[OpacaCMS] No SQL migrations found in ${fullMigrationDir}`);
+    return;
+  }
+  console.log(`[OpacaCMS] Found ${migrations.length} migrations. Applying to ${isRemote ? "\uD83C\uDF0A REMOTE (Cloudflare D1)" : "\uD83D\uDCBB LOCAL (SQLite)"}...`);
+  for (const migration of migrations) {
+    const filePath = resolve(fullMigrationDir, migration);
+    console.log(`
+[OpacaCMS] \uD83D\uDCE6 Applying: ${migration}...`);
+    const wranglerArgs = [
+      "wrangler",
+      "d1",
+      "execute",
+      binding,
+      "--file",
+      filePath,
+      isRemote ? "--remote" : "--local",
+      "--yes"
+    ];
+    const result = spawnSync("bun", ["x", ...wranglerArgs], {
+      stdio: "inherit",
+      shell: false,
+      cwd: process.cwd()
+    });
+    if (result.status !== 0) {
+      console.error(`[OpacaCMS] ❌ Failed to apply migration: ${migration}`);
+    } else {
+      console.log(`[OpacaCMS] ✅ Success: ${migration}`);
+    }
+  }
+  console.log(`
+[OpacaCMS] ✨ Database migration process completed!`);
+}
+
+// src/cli/commands/migrate.ts
+var migrate_default = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Manage database migrations"
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      description: "Path to the OpacaCMS configuration file"
+    },
+    action: {
+      type: "positional",
+      description: "Action to perform: run (default), create, diff, status, d1",
+      required: false
+    },
+    name: {
+      type: "positional",
+      description: "Name of the migration (for create)",
+      required: false
+    },
+    out: {
+      type: "string",
+      alias: "o",
+      description: "Output directory for migrations"
+    },
+    remote: {
+      type: "boolean",
+      description: "Apply migrations to remote D1"
+    },
+    binding: {
+      type: "string",
+      alias: "b",
+      description: "D1 database binding name",
+      default: "DB"
+    }
+  },
+  async run({ args }) {
+    console.log();
+    Wt(import_picocolors.default.bgMagenta(import_picocolors.default.white(" OpacaCMS Migrations ")));
+    const s = be();
+    const action = args.action || "run";
+    let opaca;
+    if (action !== "d1") {
+      s.start("Loading configuration...");
+      try {
+        const configPath = resolveConfigPath(args.config);
+        opaca = await loadConfig(configPath);
+        s.stop(`Configuration loaded. DB: ${import_picocolors.default.cyan(opaca.db.name)}`);
+      } catch (err) {
+        s.stop(import_picocolors.default.red("Failed to load configuration."));
+        R.error(err.message);
+        process.exit(1);
+      }
+    }
+    try {
+      if (action === "create") {
+        const name = !args.name || args.name === "migration" ? getRandomMigrationName() : args.name;
+        s.start(`Generating baseline migration '${name}'...`);
+        const created = await migrateCreateCommand(opaca, name, args.out);
+        if (created) {
+          s.stop(`Baseline migration created successfully!`);
+        } else {
+          s.stop(`Operation aborted. No changes detected.`);
+        }
+      } else if (action === "diff") {
+        let name = args.name || "migration";
+        if (name === "migration") {
+          name = getRandomMigrationName();
+        }
+        s.start(`Analyzing schema for differences...`);
+        let dialect = "sqlite";
+        if (opaca.db.name === "postgres")
+          dialect = "postgres";
+        if (opaca.db.name === "d1")
+          dialect = "d1";
+        const migrationDir = opaca.db.migrationDir || "./migrations";
+        const { hasChanges, upCode, downCode } = await generateDiffCode(opaca, dialect, migrationDir, "diff_check", { saveSnapshot: false, interactive: false });
+        if (!hasChanges) {
+          s.stop(`Schema is already up to date. No migration generated.`);
+        } else {
+          s.start(`Generating diff migration '${name}'...`);
+          const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
+          const isD1 = dialect === "d1";
+          const fileName = `${timestamp}_${name}.${isD1 ? "sql" : "ts"}`;
+          const migrationDir2 = args.out || opaca.db.migrationDir || "./migrations";
+          const fullMigrationDir = resolve2(process.cwd(), migrationDir2);
+          if (!fs2.existsSync(fullMigrationDir)) {
+            fs2.mkdirSync(fullMigrationDir, { recursive: true });
+          }
+          const filePath = resolve2(fullMigrationDir, fileName);
+          let template = "";
+          if (isD1) {
+            template = `-- OpacaCMS Auto-generated SQL Diff Migration
+
+${upCode}`;
+          } else {
+            template = `import { type OpacaMigrationDb, sql } from 'opacacms/db';
+
+export async function up(db: OpacaMigrationDb): Promise<void> {
+${upCode}
+}
+
+export async function down(db: OpacaMigrationDb): Promise<void> {
+${downCode}
+}
+`;
+          }
+          fs2.writeFileSync(filePath, template);
+          s.stop(`Diff migration created successfully at ${relative2(process.cwd(), filePath)}!`);
+        }
+      } else if (action === "run") {
+        s.start(`Applying pending migrations...`);
+        await migrateRunCommand(opaca.db);
+        s.stop(`Migrations applied successfully!`);
+      } else if (action === "status") {
+        s.start(`Checking migration status...`);
+        await migrateStatusCommand(opaca);
+        s.stop(`Migration status checked.`);
+      } else if (action === "d1") {
+        s.start(`Applying D1 migrations...`);
+        await migrateD1Command(args.out || "./migrations", !!args.remote, args.binding);
+        s.stop(`D1 migrations processed!`);
+      } else {
+        R.error(`Unknown migration action: ${action}`);
+        process.exit(1);
+      }
+      Gt("Done! \uD83D\uDE80");
+    } catch (err) {
+      if (s)
+        s.stop(import_picocolors.default.red("Migration failed."));
+      R.error(err.message);
+      Gt(import_picocolors.default.red("Operation aborted."));
+      process.exit(1);
+    }
+  }
+});
+export {
+  migrate_default as default
+};

package/dist/{chunk-6d1vdfwa.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,15 +17,20 @@ import {
 } from "./chunk-qxt9vge8.js";
 import {
   logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-jq1drsen.js";
 import {
   __require
-} from "./chunk-8sqjbsgt.js";
+} from "./chunk-6bywt602.js";
 
 // src/db/sqlite.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect } from "kysely";
+import {
+  CompiledQuery,
+  FileMigrationProvider,
+  Migrator,
+  SqliteDialect
+} from "kysely";
 class SQLiteAdapter extends BaseDatabaseAdapter {
   path;
   name = "sqlite";
@@ -55,10 +63,16 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     const require2 = createRequire(import.meta.url);
     const Database = require2("better-sqlite3");
     this._rawDb = new Database(this.path);
-    this._db = new Kysely({
+    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() {
@@ -70,44 +84,6 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     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"));
@@ -137,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) {
@@ -182,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);
@@ -260,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));
     }
@@ -272,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,
@@ -284,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);
@@ -365,9 +347,11 @@ 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) {
@@ -379,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);
@@ -396,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();
@@ -443,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);
@@ -513,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;