opacacms 0.1.0

package/dist/chunk-6ew02s0c.js

@@ -0,0 +1,472 @@
+import {
+  logger
+} from "./chunk-62ev8gnc.js";
+import {
+  flattenFields,
+  getRelationalFields,
+  mapFieldToPostgresType,
+  mapFieldToSQLiteType,
+  toSnakeCase
+} from "./chunk-cvdd4eqh.js";
+import {
+  getSystemCollections,
+  init_system_schema
+} from "./chunk-ybbbqj63.js";
+
+// src/db/kysely/data-mapper.ts
+function toCamelCase(str) {
+  if (str.startsWith("_"))
+    return str;
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function flattenPayload(payload, prefix = "", excludeKeys = []) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+    return payload;
+  const result = {};
+  for (const key in payload) {
+    if (Object.hasOwn(payload, key)) {
+      const value = payload[key];
+      if (value === undefined)
+        continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !excludeKeys.includes(key)) {
+        if (key.startsWith("_") && prefix === "") {
+          result[key] = value;
+        } else {
+          const flatNested = flattenPayload(value, `${prefix}${key}__`);
+          Object.assign(result, flatNested);
+        }
+      } else {
+        if (value === undefined)
+          continue;
+        const colName = `${prefix}${toSnakeCase(key)}`;
+        if (typeof value === "object" && value !== null) {
+          result[colName] = JSON.stringify(value);
+        } else {
+          result[colName] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function unflattenRow(row) {
+  if (typeof row !== "object" || row === null || Array.isArray(row))
+    return row;
+  const result = {};
+  for (const key in row) {
+    if (Object.hasOwn(row, key)) {
+      let value = row[key];
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          try {
+            value = JSON.parse(value);
+          } catch (e) {}
+        }
+      }
+      if (key === "created_at" || key === "updated_at" || key === "createdAt" || key === "updatedAt") {
+        if (typeof value === "string" && !value.includes("T") && value.includes(" ")) {
+          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;
+      }
+      let current = result;
+      let collision = false;
+      const path = [];
+      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) {
+        result[toCamelCase(key)] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/db/kysely/query-builder.ts
+function buildKyselyWhere(eb, query) {
+  if (!query || Object.keys(query).length === 0)
+    return;
+  const conditions = [];
+  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;
+  if (conditions.length === 1)
+    return conditions[0];
+  return eb.and(conditions);
+}
+
+// src/db/kysely/schema-builder.ts
+import { sql } from "kysely";
+init_system_schema();
+
+// src/db/kysely/sql-utils.ts
+function assertSafeIdentifier(identifier) {
+  if (typeof identifier !== "string" || !identifier) {
+    throw new Error(`Invalid identifier: must be a non-empty string. Got: ${identifier}`);
+  }
+  const isValid = /^[a-zA-Z0-9_-]+$/.test(identifier);
+  if (!isValid) {
+    throw new Error(`API Error: Unsafe SQL identifier detected: "${identifier}". Identifiers can only contain alphanumeric characters, underscores, and hyphens.`);
+  }
+}
+
+// src/db/kysely/schema-builder.ts
+async function pushSchema(db, dialect, collections, globals = [], options = {}) {
+  const rawSchemas = [...getSystemCollections(), ...collections, ...globals];
+  const allSchemas = [];
+  const seenSlugs = new Set;
+  for (const schema of rawSchemas) {
+    if (!seenSlugs.has(schema.slug)) {
+      seenSlugs.add(schema.slug);
+      allSchemas.push(schema);
+    }
+  }
+  const { pushDestructive } = options;
+  logger.debug(`Starting schema push via Kysely (${dialect})...`);
+  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
+  let existingTables = [];
+  try {
+    if (dialect === "postgres") {
+      const res = await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`.execute(db);
+      existingTables = res.rows.map((r) => r.table_name);
+    } else {
+      const res = await sql`SELECT name FROM sqlite_master WHERE type='table'`.execute(db);
+      existingTables = res.rows.map((r) => r.name);
+    }
+  } catch (_) {
+    logger.warn("Failed to fetch existing tables:");
+  }
+  logger.info(`Existing tables: ${existingTables.join(", ")}`);
+  const existingTableSet = new Set(existingTables);
+  const expectedTableNames = new Set;
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const tableName = toSnakeCase(slug);
+    assertSafeIdentifier(tableName);
+    expectedTableNames.add(tableName);
+    const flattenedFields = flattenFields(collection.fields);
+    const hasTimestamps = collection.timestamps !== false;
+    const versions = collection.versions;
+    if (!existingTableSet.has(tableName)) {
+      logger.info(`  -> Creating table: ${logger.format("green", `"${tableName}"`)}`);
+      let builder = db.schema.createTable(tableName).ifNotExists();
+      builder = builder.addColumn("id", "text", (col) => col.primaryKey());
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        const colType = mapType(field);
+        builder = builder.addColumn(colName, colType, (col) => {
+          let c = col;
+          if (field.unique)
+            c = c.unique();
+          if (field.required)
+            c = c.notNull();
+          if (field.defaultValue !== undefined)
+            c = c.defaultTo(field.defaultValue);
+          return c;
+        });
+      }
+      if (versions?.drafts) {
+        builder = builder.addColumn("_status", "text", (col) => col.defaultTo("draft"));
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+        builder = builder.addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+        builder = builder.addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+      }
+      await builder.execute();
+      if (versions) {
+        const versionsTable = `${slug}_versions`.toLowerCase();
+        assertSafeIdentifier(versionsTable);
+        expectedTableNames.add(versionsTable);
+        if (!existingTableSet.has(versionsTable)) {
+          logger.info(`  -> Creating versions table: ${logger.format("green", `"${versionsTable}"`)}`);
+          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+    } else {
+      let existingColumns = [];
+      try {
+        if (dialect === "postgres") {
+          const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${slug}`.execute(db);
+          existingColumns = res.rows.map((r) => r.column_name);
+        } else {
+          const res = await sql`PRAGMA table_info(${sql.id(slug)})`.execute(db);
+          existingColumns = res.rows.map((r) => r.name);
+        }
+      } catch (e) {
+        logger.warn(`Failed to fetch columns for ${slug}:`, e);
+      }
+      const existingColSet = new Set(existingColumns);
+      for (const field of flattenedFields) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+          continue;
+        const colName = toSnakeCase(field.name);
+        if (colName === "id")
+          continue;
+        assertSafeIdentifier(colName);
+        if (!existingColSet.has(colName)) {
+          logger.info(`  -> Adding missing column: ${logger.format("green", `${slug}.${colName}`)}`);
+          const colType = mapType(field);
+          await db.schema.alterTable(slug).addColumn(colName, colType).execute();
+        }
+      }
+      if (versions?.drafts && !existingColSet.has("_status")) {
+        logger.info(`  -> Adding missing status column to: ${slug}`);
+        await db.schema.alterTable(slug).addColumn("_status", "text", (col) => col.defaultTo("draft")).execute();
+      }
+      if (hasTimestamps) {
+        const ts = collection.timestamps ?? {};
+        const config = typeof ts === "object" ? ts : {};
+        const createdField = toSnakeCase(config.createdAt ?? "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt ?? "updatedAt");
+        const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+        if (!existingColSet.has(createdField)) {
+          logger.info(`  -> Adding missing timestamp column: ${slug}.${createdField}`);
+          await db.schema.alterTable(slug).addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+        if (!existingColSet.has(updatedField)) {
+          logger.info(`  -> Adding missing timestamp column: ${slug}.${updatedField}`);
+          await db.schema.alterTable(slug).addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+      if (versions) {
+        const versionsTable = `${slug}_versions`.toLowerCase();
+        expectedTableNames.add(versionsTable);
+        if (!existingTableSet.has(versionsTable)) {
+          logger.info(`  -> Creating missing versions table for: ${slug}`);
+          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+        }
+      }
+      if (pushDestructive) {
+        const expectedCols = new Set(flattenedFields.filter((f) => !(f.type === "relationship" && f.hasMany)).map((f) => toSnakeCase(f.name)));
+        if (hasTimestamps) {
+          const ts = collection.timestamps ?? {};
+          const config = typeof ts === "object" ? ts : {};
+          expectedCols.add(toSnakeCase(config.createdAt ?? "createdAt"));
+          expectedCols.add(toSnakeCase(config.updatedAt ?? "updatedAt"));
+        }
+        if (versions?.drafts)
+          expectedCols.add("_status");
+        expectedCols.add("id");
+        for (const existingCol of existingColumns) {
+          if (!expectedCols.has(existingCol)) {
+            logger.info(`  -> Dropping stale column: ${logger.format("red", `${slug}.${existingCol}`)}`);
+            try {
+              await db.schema.alterTable(slug).dropColumn(existingCol).execute();
+            } catch (_) {
+              logger.warn(`Failed to drop column ${existingCol}.`);
+            }
+          }
+        }
+      }
+    }
+    const relationalFields = getRelationalFields(collection.fields);
+    for (const field of relationalFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const sourceIdType = "text";
+        const colName = toSnakeCase(field.name);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        assertSafeIdentifier(joinTableName);
+        expectedTableNames.add(joinTableName);
+        if (!existingTableSet.has(joinTableName)) {
+          logger.info(`  -> Creating relation table: ${logger.format("green", `"${joinTableName}"`)}`);
+          await db.schema.createTable(joinTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("source_id", sourceIdType, (col) => col.notNull()).addColumn("target_id", "text", (col) => col.notNull()).addColumn("order", "integer", (col) => col.defaultTo(0)).execute();
+        }
+      }
+    }
+    for (const field of relationalFields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        const parentIdType = "text";
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name);
+          const blockSlug = toSnakeCase(block.slug);
+          assertSafeIdentifier(blockName);
+          assertSafeIdentifier(blockSlug);
+          const blockTableName = `${slug}_${blockName}_${blockSlug}`.toLowerCase();
+          assertSafeIdentifier(blockTableName);
+          expectedTableNames.add(blockTableName);
+          if (!existingTableSet.has(blockTableName)) {
+            logger.info(`  -> Creating block table: ${logger.format("green", `"${blockTableName}"`)}`);
+            let bBuilder = db.schema.createTable(blockTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", parentIdType, (col) => col.notNull()).addColumn("_order", "integer", (col) => col.defaultTo(0)).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug));
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              assertSafeIdentifier(bColName);
+              const bColType = mapType(bField);
+              bBuilder = bBuilder.addColumn(bColName, bColType, (col) => {
+                let c = col;
+                if (bField.unique)
+                  c = c.unique();
+                if (bField.required)
+                  c = c.notNull();
+                if (bField.defaultValue !== undefined)
+                  c = c.defaultTo(bField.defaultValue);
+                return c;
+              });
+            }
+            const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+            bBuilder = bBuilder.addColumn("created_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            bBuilder = bBuilder.addColumn("updated_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
+            await bBuilder.execute();
+          } else {
+            let existingBCols = [];
+            try {
+              if (dialect === "postgres") {
+                const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${blockTableName}`.execute(db);
+                existingBCols = res.rows.map((r) => r.column_name);
+              } else {
+                const res = await sql`PRAGMA table_info(${sql.id(blockTableName)})`.execute(db);
+                existingBCols = res.rows.map((r) => r.name);
+              }
+            } catch (_) {}
+            const existingBColSet = new Set(existingBCols);
+            const blockFlattened = flattenFields(block.fields);
+            for (const bField of blockFlattened) {
+              const bColName = toSnakeCase(bField.name);
+              if (bColName === "id")
+                continue;
+              if (!existingBColSet.has(bColName)) {
+                const bColType = mapType(bField);
+                await db.schema.alterTable(blockTableName).addColumn(bColName, bColType).execute();
+              }
+            }
+            if (!existingBColSet.has("_parent_id")) {
+              await db.schema.alterTable(blockTableName).addColumn("_parent_id", "text", (col) => col.notNull().defaultTo("")).execute();
+            }
+            if (!existingBColSet.has("_order")) {
+              await db.schema.alterTable(blockTableName).addColumn("_order", "integer", (col) => col.defaultTo(0)).execute();
+            }
+            if (!existingBColSet.has("block_type")) {
+              await db.schema.alterTable(blockTableName).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug)).execute();
+            }
+          }
+        }
+      }
+    }
+  }
+  if (pushDestructive) {
+    for (const tableName of existingTables) {
+      if (!expectedTableNames.has(tableName) && !tableName.startsWith("better_auth") && !tableName.startsWith("__kysely")) {
+        logger.info(`  -> Dropping stale table: ${logger.format("red", `"${tableName}"`)}`);
+        try {
+          await db.schema.dropTable(tableName).ifExists().cascade().execute();
+        } catch (_) {
+          try {
+            await db.schema.dropTable(tableName).ifExists().execute();
+          } catch (_2) {
+            logger.warn(`Failed to drop table ${tableName}`);
+          }
+        }
+      }
+    }
+  }
+  logger.success(`Schema push to Kysely (${dialect}) completed.`);
+}
+
+export { flattenPayload, unflattenRow, buildKyselyWhere, pushSchema };

package/dist/chunk-7a9kn0np.js

@@ -0,0 +1,116 @@
+import"./chunk-8sqjbsgt.js";
+
+// src/cli/commands/generate-types.ts
+import fs from "node:fs";
+import { resolve } from "node:path";
+async function generateTypesCommand(url, token, out) {
+  console.log(`[OpacaCMS] Fetching metadata from ${url}/api/__admin/metadata...`);
+  let data;
+  try {
+    const res = await fetch(`${url.replace(/\/$/, "")}/api/__admin/metadata`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!res.ok) {
+      if (res.status === 401 || res.status === 403) {
+        throw new Error("Authentication failed. Ensure your API Key is correct and has the necessary permissions.");
+      }
+      const errorText = await res.text().catch(() => "Unknown error");
+      throw new Error(`Server responded with ${res.status}: ${errorText}`);
+    }
+    data = await res.json();
+  } catch (err) {
+    console.error(`[OpacaCMS] Failed to fetch metadata: ${err.message}`);
+    process.exit(1);
+  }
+  console.log(`[OpacaCMS] Successfully fetched metadata for ${data.collections.length} collections and ${data.globals?.length || 0} globals.`);
+  let dtsContent = `// Automatically generated by OpacaCMS CLI
+// Do not edit this file manually
+
+export interface OpacaAsset {
+  assetId: string;
+  url: string;
+  filename: string;
+  mime_type: string;
+  filesize: number;
+  meta?: Record<string, any>;
+}
+
+export interface OpacaCollections {
+  collections: {
+`;
+  for (const collection of data.collections) {
+    dtsContent += `    "${collection.slug}": {
+`;
+    dtsContent += `      id: string | number;
+`;
+    for (const field of collection.fields) {
+      const typeStr = mapFieldToTsType(field.type);
+      const isOptional = field.required ? "" : "?";
+      dtsContent += `      ${field.name}${isOptional}: ${typeStr};
+`;
+    }
+    if (collection.timestamps) {
+      dtsContent += `      createdAt: string;
+`;
+      dtsContent += `      updatedAt: string;
+`;
+    }
+    dtsContent += `    };
+`;
+  }
+  dtsContent += `  };
+`;
+  if (data.globals && data.globals.length > 0) {
+    dtsContent += `  globals: {
+`;
+    for (const globalConf of data.globals) {
+      dtsContent += `    "${globalConf.slug}": {
+`;
+      for (const field of globalConf.fields) {
+        const typeStr = mapFieldToTsType(field.type);
+        const isOptional = field.required ? "" : "?";
+        dtsContent += `      ${field.name}${isOptional}: ${typeStr};
+`;
+      }
+      dtsContent += `    };
+`;
+    }
+    dtsContent += `  };
+`;
+  } else {
+    dtsContent += `  globals: Record<string, any>;
+`;
+  }
+  dtsContent += `}
+`;
+  const outputPath = resolve(process.cwd(), out || "opaca-types.d.ts");
+  fs.writeFileSync(outputPath, dtsContent);
+  console.log(`[OpacaCMS] Types successfully generated at ${outputPath}`);
+}
+function mapFieldToTsType(type) {
+  switch (type) {
+    case "text":
+    case "textarea":
+    case "richtext":
+    case "select":
+    case "date":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+      return "any | any[]";
+    case "file":
+      return "OpacaAsset";
+    case "relationship":
+      return "string | number | any";
+    default:
+      return "any";
+  }
+}
+export {
+  generateTypesCommand
+};