opacacms 0.1.0

package/src/db/kysely/data-mapper.ts

@@ -0,0 +1,142 @@
+import { toSnakeCase } from "./field-mapper";
+
+/**
+ * Converts a snake_case string to camelCase.
+ */
+export function toCamelCase(str: string): string {
+  if (str.startsWith("_")) return str; // Keep system prefixes
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+export function flattenPayload(payload: any, prefix = "", excludeKeys: string[] = []): any {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return payload;
+  const result: any = {};
+
+  for (const key in payload) {
+    if (Object.hasOwn(payload, key)) {
+      const value = payload[key];
+      if (value === undefined) continue;
+
+      // Do not flatten Date objects or arrays
+      if (
+        typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date) &&
+        !excludeKeys.includes(key)
+      ) {
+        // Only flatten objects that aren't system keys (like _access)
+        if (key.startsWith("_") && prefix === "") {
+          result[key] = value;
+        } else {
+          // It's a group, flatten it
+          const flatNested = flattenPayload(value, `${prefix}${key}__`);
+          Object.assign(result, flatNested);
+        }
+      } else {
+        if (value === undefined) continue;
+        // IMPORTANT: Convert column name to snake_case when saving
+        const colName = `${prefix}${toSnakeCase(key)}`;
+
+        // Serialize arrays and objects to JSON strings for SQLite/D1
+        if (typeof value === "object" && value !== null) {
+          result[colName] = JSON.stringify(value);
+        } else {
+          result[colName] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+
+export function unflattenRow(row: any): any {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) return row;
+  const result: any = {};
+
+  for (const key in row) {
+    if (Object.hasOwn(row, key)) {
+      let value = row[key];
+
+      // Try to parse JSON strings back to objects/arrays
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (
+          (trimmed.startsWith("[") && trimmed.endsWith("]")) ||
+          (trimmed.startsWith("{") && trimmed.endsWith("}"))
+        ) {
+          try {
+            value = JSON.parse(value);
+          } catch (e) {
+            // Not valid JSON, keep as string
+          }
+        }
+      }
+
+      // If it's a direct match for timestamps or system fields, keep as is
+      if (
+        key === "created_at" ||
+        key === "updated_at" ||
+        key === "createdAt" ||
+        key === "updatedAt"
+      ) {
+        if (typeof value === "string" && !value.includes("T") && value.includes(" ")) {
+          // Normalize SQLite/D1 "YYYY-MM-DD HH:MM:SS" to ISO "YYYY-MM-DDTHH:MM:SSZ"
+          value = `${value.replace(" ", "T")}Z`;
+        }
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+
+      if (key.startsWith("_")) {
+        result[key] = value;
+        continue;
+      }
+
+      const parts = key.split("__");
+      if (parts.length === 1) {
+        result[toCamelCase(key)] = value;
+        continue;
+      }
+
+      // Try to unflatten, but detect collisions (e.g., "email" vs "email_verified")
+      let current = result;
+      let collision = false;
+      const path: any[] = [];
+
+      for (let i = 0; i < parts.length - 1; i++) {
+        const part = toCamelCase(parts[i]!);
+        if (
+          current[part] !== undefined &&
+          (typeof current[part] !== "object" || current[part] === null)
+        ) {
+          collision = true;
+          break;
+        }
+        path.push({ obj: current, key: part });
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+
+      if (!collision) {
+        const lastPart = toCamelCase(parts[parts.length - 1]!);
+        if (current[lastPart] !== undefined && typeof current[lastPart] === "object") {
+          collision = true;
+        } else {
+          current[lastPart] = value;
+        }
+      }
+
+      if (collision) {
+        // If we hit a collision, we must undo any structural changes made for this key
+        // and just use the full camelCase key at the root.
+        // Actually, just setting it at the root is mostly safe as long as we don't leave
+        // empty objects that shouldn't be there. But for simplicity and robustness:
+        result[toCamelCase(key)] = value;
+      }
+    }
+  }
+  return result;
+}

package/src/db/kysely/field-mapper.ts

@@ -0,0 +1,148 @@
+import type { Field } from "../../types";
+
+export function toSnakeCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, "_$1")
+    .toLowerCase()
+    .replace(/^_/, "");
+}
+
+/**
+ * Maps an OpacaCMS FieldType to a Kysely column data type for PostgreSQL.
+ */
+export function mapFieldToPostgresType(field: Field): string {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+      return "text";
+    case "number":
+      return "double precision";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "timestamp with time zone";
+    case "json":
+    case "file":
+      return "jsonb";
+    default:
+      return "text";
+  }
+}
+
+/**
+ * Maps an OpacaCMS FieldType to a Kysely column data type for SQLite/D1.
+ */
+export function mapFieldToSQLiteType(field: Field): string {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+    case "date": // SQLite stores dates as text
+    case "json":
+    case "file":
+      return "text";
+    case "number":
+      return "numeric";
+    case "boolean":
+      return "integer"; // 0 or 1
+    default:
+      return "text";
+  }
+}
+
+/**
+ * Recursively flattens a field list, collecting only fields with a 'name'.
+ * This skips layout fields like 'row', 'collapsible', 'tabs' while preserving their nested named fields.
+ * Group and Blocks fields are also flattened, prefixing their children's names to avoid collisions.
+ * It explicitly excludes virtual fields like 'join' since they are resolved at runtime.
+ */
+export function flattenFields(fields: Field[], prefix = ""): Field[] {
+  const result: Field[] = [];
+
+  for (const field of fields) {
+    if (field.type === "join" || field.type === "virtual") continue;
+
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+
+    if (field.type === "group") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = currentName ? `${currentName}__` : "";
+        result.push(...flattenFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+
+    if (field.type === "blocks") {
+      continue;
+    }
+
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+      continue;
+    }
+
+    if (currentName) {
+      result.push({ ...field, name: currentName });
+    }
+
+    if (field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        result.push(...flattenFields(field.fields, prefix));
+      }
+    }
+
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...flattenFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Recursively find all relational fields (relationship with hasMany or blocks).
+ * This is used by adapters to fetch related data during findOne/find.
+ */
+export function getRelationalFields(fields: Field[], prefix = ""): Field[] {
+  const result: Field[] = [];
+
+  for (const field of fields) {
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+
+    if (
+      (field.type === "relationship" && "hasMany" in field && field.hasMany) ||
+      field.type === "blocks"
+    ) {
+      if (currentName) {
+        result.push({ ...field, name: currentName });
+      }
+      continue;
+    }
+
+    if (field.type === "group" || field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = field.type === "group" && field.name ? `${currentName}__` : prefix;
+        result.push(...getRelationalFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...getRelationalFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+
+  return result;
+}

package/src/db/kysely/migration-generator.ts

@@ -0,0 +1,223 @@
+import type { Collection, Global } from "../../types";
+import {
+  flattenFields,
+  mapFieldToPostgresType,
+  mapFieldToSQLiteType,
+  toSnakeCase,
+} from "./field-mapper";
+
+/**
+ * Generates Kysely migration code for 'up' and 'down' functions based on schema definitions.
+ */
+export function generateMigrationCode(
+  collections: Collection[],
+  globals: Global[] = [],
+  dialect: "postgres" | "sqlite" | "d1",
+): string {
+  const allSchemas = [...collections, ...globals];
+  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
+  const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+
+  let upCode = "";
+  let downCode = "";
+
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const flattenedFields = flattenFields(collection.fields);
+
+    // Main Table
+    upCode += `  await db.schema.createTable('${slug}')\n`;
+    upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())\n`;
+
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) continue;
+      const colName = toSnakeCase(field.name!);
+      if (colName === "id") continue;
+
+      const colType = mapType(field);
+      const constraints: string[] = [];
+      if (field.required) constraints.push("notNull()");
+      if (field.unique) constraints.push("unique()");
+
+      if (field.defaultValue !== undefined) {
+        let val = field.defaultValue;
+        if (typeof val === "string") {
+          val = `'${val}'`;
+        } else if (typeof val === "boolean") {
+          val = dialect === "sqlite" || dialect === "d1" ? (val ? 1 : 0) : val;
+        }
+        constraints.push(`defaultTo(${val})`);
+      }
+
+      const constraintChain = constraints.length > 0 ? `.${constraints.join(".")}` : "";
+      upCode += `    .addColumn('${colName}', '${colType}', (col) => col${constraintChain})\n`;
+    }
+
+    // Timestamps
+    const ts = (collection as any).timestamps !== false;
+    if (ts) {
+      const config =
+        typeof (collection as any).timestamps === "object" ? (collection as any).timestamps : {};
+      const createdField = toSnakeCase(config.createdAt || "createdAt");
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      upCode += `    .addColumn('${createdField}', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))\n`;
+      upCode += `    .addColumn('${updatedField}', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))\n`;
+    }
+    upCode += `    .execute();\n\n`;
+
+    downCode = `  await db.schema.dropTable('${slug}').execute();\n` + downCode;
+
+    // Join Tables
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const colName = toSnakeCase(field.name!);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        upCode += `  await db.schema.createTable('${joinTableName}')\n`;
+        upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())\n`;
+        upCode += `    .addColumn('source_id', 'text', (col) => col.notNull())\n`;
+        upCode += `    .addColumn('target_id', 'text', (col) => col.notNull())\n`;
+        upCode += `    .addColumn('order', 'integer', (col) => col.defaultTo(0))\n`;
+        upCode += `    .execute();\n\n`;
+
+        downCode = `  await db.schema.dropTable('${joinTableName}').execute();\n` + downCode;
+      }
+    }
+
+    // Block Tables
+    for (const field of collection.fields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name!);
+          const blockTableName = `${slug}_${blockName}_${block.slug}`.toLowerCase();
+
+          upCode += `  await db.schema.createTable('${blockTableName}')\n`;
+          upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())\n`;
+          upCode += `    .addColumn('_parent_id', 'text', (col) => col.notNull())\n`;
+          upCode += `    .addColumn('_order', 'integer', (col) => col.defaultTo(0))\n`;
+          upCode += `    .addColumn('block_type', 'text', (col) => col.notNull())\n`;
+
+          const blockFlattened = flattenFields(block.fields);
+          for (const bField of blockFlattened) {
+            const bColName = toSnakeCase(bField.name!);
+            if (bColName === "id") continue;
+            const bColType = mapType(bField);
+
+            const bConstraints: string[] = [];
+            if (bField.required) bConstraints.push("notNull()");
+            if (bField.unique) bConstraints.push("unique()");
+            if (bField.defaultValue !== undefined) {
+              let bVal = bField.defaultValue;
+              if (typeof bVal === "string") bVal = `'${bVal}'`;
+              else if (typeof bVal === "boolean")
+                bVal = dialect === "sqlite" || dialect === "d1" ? (bVal ? 1 : 0) : bVal;
+              bConstraints.push(`defaultTo(${bVal})`);
+            }
+
+            const bConstraintChain = bConstraints.length > 0 ? `.${bConstraints.join(".")}` : "";
+            upCode += `    .addColumn('${bColName}', '${bColType}', (col) => col${bConstraintChain})\n`;
+          }
+          upCode += `    .addColumn('created_at', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))\n`;
+          upCode += `    .addColumn('updated_at', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))\n`;
+          upCode += `    .execute();\n\n`;
+
+          downCode = `  await db.schema.dropTable('${blockTableName}').execute();\n` + downCode;
+        }
+      }
+    }
+  }
+
+  return `import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+${upCode}}
+
+export async function down(db: Kysely<any>): Promise<void> {
+${downCode}}
+`;
+}
+
+/**
+ * Generates raw SQL migration code for Cloudflare D1.
+ */
+export function generateSQLCode(collections: Collection[], globals: Global[] = []): string {
+  const allSchemas = [...collections, ...globals];
+  let sql = "-- OpacaCMS Auto-generated SQL Migration\n\n";
+
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const flattenedFields = flattenFields(collection.fields);
+
+    sql += `CREATE TABLE IF NOT EXISTS "${slug}" (\n`;
+    sql += `  "id" TEXT PRIMARY KEY`;
+
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) continue;
+      const colName = toSnakeCase(field.name!);
+      if (colName === "id") continue;
+
+      const colType = mapFieldToSQLiteType(field);
+      sql += `,\n  "${colName}" ${colType.toUpperCase()}`;
+      if (field.required) sql += " NOT NULL";
+      if (field.unique) sql += " UNIQUE";
+      if (field.defaultValue !== undefined) {
+        let val = field.defaultValue;
+        if (typeof val === "string") val = `'${val}'`;
+        else if (typeof val === "boolean") val = val ? 1 : 0;
+        sql += ` DEFAULT ${val}`;
+      }
+    }
+
+    const ts = (collection as any).timestamps !== false;
+    if (ts) {
+      const config =
+        typeof (collection as any).timestamps === "object" ? (collection as any).timestamps : {};
+      const createdField = toSnakeCase(config.createdAt || "createdAt");
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      sql += `,\n  "${createdField}" TEXT DEFAULT CURRENT_TIMESTAMP`;
+      sql += `,\n  "${updatedField}" TEXT DEFAULT CURRENT_TIMESTAMP`;
+    }
+    sql += "\n);\n\n";
+
+    // Join Tables
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const colName = toSnakeCase(field.name!);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        sql += `CREATE TABLE IF NOT EXISTS "${joinTableName}" (\n`;
+        sql += `  "id" TEXT PRIMARY KEY,\n`;
+        sql += `  "source_id" TEXT NOT NULL,\n`;
+        sql += `  "target_id" TEXT NOT NULL,\n`;
+        sql += `  "order" INTEGER DEFAULT 0\n`;
+        sql += `);\n\n`;
+      }
+    }
+
+    // Block Tables
+    for (const field of collection.fields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name!);
+          const blockTableName = `${slug}_${blockName}_${block.slug}`.toLowerCase();
+          sql += `CREATE TABLE IF NOT EXISTS "${blockTableName}" (\n`;
+          sql += `  "id" TEXT PRIMARY KEY,\n`;
+          sql += `  "_parent_id" TEXT NOT NULL,\n`;
+          sql += `  "_order" INTEGER DEFAULT 0,\n`;
+          sql += `  "block_type" TEXT NOT NULL`;
+
+          const blockFlattened = flattenFields(block.fields);
+          for (const bField of blockFlattened) {
+            const bColName = toSnakeCase(bField.name!);
+            if (bColName === "id") continue;
+            const bColType = mapFieldToSQLiteType(bField);
+            sql += `,\n  "${bColName}" ${bColType.toUpperCase()}`;
+          }
+          sql += `,\n  "created_at" TEXT DEFAULT CURRENT_TIMESTAMP,\n`;
+          sql += `  "updated_at" TEXT DEFAULT CURRENT_TIMESTAMP\n`;
+          sql += `);\n\n`;
+        }
+      }
+    }
+  }
+
+  return sql;
+}

package/src/db/kysely/query-builder.ts

@@ -0,0 +1,92 @@
+import type { ExpressionBuilder } from "kysely";
+
+/**
+ * Builds a Kysely expression from a generic query object.
+ *
+ * @param eb The Kysely ExpressionBuilder (e.g., from .where((eb) => buildKyselyWhere(eb, query)))
+ * @param query The query object (e.g., { age: { gt: 18 }, name: 'John' })
+ * @returns A single Expression combining all conditions with AND, or undefined.
+ */
+export function buildKyselyWhere(
+  eb: ExpressionBuilder<any, any>,
+  query: Record<string, any> | undefined,
+): any {
+  if (!query || Object.keys(query).length === 0) return undefined;
+
+  const conditions: any[] = [];
+
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined) continue;
+
+    if (key === "or" && Array.isArray(value)) {
+      const orConditions = value.map((v) => buildKyselyWhere(eb, v)).filter((c) => c !== undefined);
+      if (orConditions.length > 0) {
+        conditions.push(eb.or(orConditions));
+      }
+      continue;
+    }
+
+    if (key === "and" && Array.isArray(value)) {
+      const andConditions = value
+        .map((v) => buildKyselyWhere(eb, v))
+        .filter((c) => c !== undefined);
+      if (andConditions.length > 0) {
+        conditions.push(eb.and(andConditions));
+      }
+      continue;
+    }
+
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      !(value instanceof Date)
+    ) {
+      for (const [op, val] of Object.entries(value)) {
+        if (val === undefined) continue;
+        switch (op) {
+          case "gt":
+            conditions.push(eb(key, ">", val));
+            break;
+          case "gte":
+            conditions.push(eb(key, ">=", val));
+            break;
+          case "lt":
+            conditions.push(eb(key, "<", val));
+            break;
+          case "lte":
+            conditions.push(eb(key, "<=", val));
+            break;
+          case "like":
+            conditions.push(eb(key, "like", String(val)));
+            break;
+          case "ne":
+            if (val === null) conditions.push(eb(key, "is not", null));
+            else conditions.push(eb(key, "!=", val));
+            break;
+          case "in":
+            if (Array.isArray(val)) conditions.push(eb(key, "in", val));
+            break;
+          case "is":
+            if (val === null) conditions.push(eb(key, "is", null));
+            break;
+          default:
+            if (val === null) conditions.push(eb(key, "is", null));
+            else conditions.push(eb(key, "=", val));
+            break;
+        }
+      }
+    } else {
+      if (value === null) {
+        conditions.push(eb(key, "is", null));
+      } else {
+        conditions.push(eb(key, "=", value));
+      }
+    }
+  }
+
+  if (conditions.length === 0) return undefined;
+  if (conditions.length === 1) return conditions[0];
+
+  return eb.and(conditions);
+}