opacacms 0.1.12 → 0.1.13

package/src/db/index.ts

@@ -1,10 +0,0 @@
-import type { Kysely } from "kysely";
-export { sql } from "kysely";
-export type OpacaMigrationDb = Kysely<any>;
-
-export * from "./adapter";
-export * from "./postgres";
-export * from "./sqlite";
-export * from "./better-sqlite";
-export * from "./bun-sqlite";
-export * from "./d1";

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

@@ -1,142 +0,0 @@
-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

@@ -1,149 +0,0 @@
-import type { Field } from "../../types";
-
-export function toSnakeCase(str: string): string {
-  const res = str.replace(/([A-Z])/g, "_$1").toLowerCase();
-  if (res.startsWith("_") && !str.startsWith("_")) {
-    return res.slice(1);
-  }
-  return res;
-}
-
-/**
- * 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

@@ -1,223 +0,0 @@
-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 { type OpacaMigrationDb, sql } from 'opacacms/db';
-
-export async function up(db: OpacaMigrationDb): Promise<void> {
-${upCode}}
-
-export async function down(db: OpacaMigrationDb): 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

@@ -1,92 +0,0 @@
-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);
-}