opacacms 0.3.18 → 0.3.19

package/dist/chunk-re459gm9.js

@@ -1,429 +0,0 @@
-import {
-  flattenFields,
-  getRelationalFields,
-  mapFieldToPostgresType,
-  mapFieldToSQLiteType,
-  toSnakeCase
-} from "./chunk-5xpf5jxd.js";
-import {
-  logger
-} from "./chunk-jq1drsen.js";
-import {
-  getSystemCollections,
-  init_system_schema
-} from "./chunk-h8v093av.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 && !(value instanceof Date)) {
-          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";
-
-// 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
-init_system_schema();
-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 tablesMetadata = [];
-  try {
-    tablesMetadata = await db.introspection.getTables();
-  } catch (e) {
-    logger.warn("Failed to fetch database introspection. Falling back to empty state.", e);
-  }
-  const existingTableMap = new Map(tablesMetadata.map((t) => [t.name, t]));
-  const existingTables = Array.from(existingTableMap.keys());
-  logger.debug(`Existing tables found: ${existingTables.join(", ")}`);
-  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 = true;
-    const versions = collection.versions;
-    const existingTable = existingTableMap.get(tableName);
-    if (!existingTable) {
-      logger.info(`  ${logger.format("green", "✔")} Creating table: ${logger.bold(`"${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" ? "timestamptz" : "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();
-    } else {
-      const existingColSet = new Set(existingTable.columns.map((c) => c.name));
-      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(`  ${logger.format("green", "✔")} Adding column: ${logger.bold(`${tableName}.${colName}`)}`);
-          const colType = mapType(field);
-          await db.schema.alterTable(tableName).addColumn(colName, colType).execute();
-        }
-      }
-      if (versions?.drafts && !existingColSet.has("_status")) {
-        logger.info(`  ${logger.format("green", "✔")} Adding status column to: ${tableName}`);
-        await db.schema.alterTable(tableName).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" ? "timestamptz" : "text";
-        if (!existingColSet.has(createdField)) {
-          logger.info(`  -> Adding missing timestamp column: ${tableName}.${createdField}`);
-          await db.schema.alterTable(tableName).addColumn(createdField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
-        }
-        if (!existingColSet.has(updatedField)) {
-          logger.info(`  -> Adding missing timestamp column: ${tableName}.${updatedField}`);
-          await db.schema.alterTable(tableName).addColumn(updatedField, tsType, (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 existingColSet) {
-          const colName = existingCol;
-          if (!expectedCols.has(colName)) {
-            logger.info(`  -> Dropping stale column: ${logger.format("red", `${tableName}.${colName}`)}`);
-            try {
-              await db.schema.alterTable(tableName).dropColumn(colName).execute();
-            } catch (_) {
-              logger.warn(`Failed to drop column ${colName}.`);
-            }
-          }
-        }
-      }
-    }
-    const relationalFields = getRelationalFields(collection.fields);
-    for (const field of relationalFields) {
-      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-        const colName = toSnakeCase(field.name);
-        const joinTableName = `${tableName}_${colName}_relations`.toLowerCase();
-        assertSafeIdentifier(joinTableName);
-        expectedTableNames.add(joinTableName);
-        if (!existingTableMap.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", "text", (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)) {
-        for (const block of field.blocks) {
-          const blockName = toSnakeCase(field.name);
-          const blockSlug = toSnakeCase(block.slug);
-          assertSafeIdentifier(blockName);
-          assertSafeIdentifier(blockSlug);
-          const blockTableName = `${tableName}_${blockName}_${blockSlug}`.toLowerCase();
-          assertSafeIdentifier(blockTableName);
-          expectedTableNames.add(blockTableName);
-          const existingBlockTable = existingTableMap.get(blockTableName);
-          if (!existingBlockTable) {
-            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", "text", (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" ? "timestamptz" : "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 {
-            const existingBColSet = new Set(existingBlockTable.columns.map((c) => c.name));
-            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.info(`${logger.format("green", "✔")} Schema synchronization complete.`);
-}
-
-export { flattenPayload, unflattenRow, buildKyselyWhere, pushSchema };

package/dist/chunk-s8mqwnm1.js

@@ -1,14 +0,0 @@
-// src/db/adapter.ts
-class BaseDatabaseAdapter {
-  get raw() {
-    return;
-  }
-  get db() {
-    return;
-  }
-  push;
-  pushDestructive;
-  migrationDir;
-}
-
-export { BaseDatabaseAdapter };

package/dist/chunk-z9ek88xr.js

@@ -1,15 +0,0 @@
-import {
-  flattenFields,
-  getRelationalFields,
-  mapFieldToPostgresType,
-  mapFieldToSQLiteType,
-  toSnakeCase
-} from "./chunk-5xpf5jxd.js";
-import"./chunk-8sqjbsgt.js";
-export {
-  toSnakeCase,
-  mapFieldToSQLiteType,
-  mapFieldToPostgresType,
-  getRelationalFields,
-  flattenFields
-};