opacacms 0.3.2 → 0.3.3

package/dist/chunk-2gdsy99f.js

@@ -1,581 +0,0 @@
-import {
-  Ct,
-  Jt,
-  Rt,
-  Wt
-} from "./chunk-gzdfc1ct.js";
-import {
-  flattenFields,
-  getRelationalFields,
-  mapFieldToPostgresType,
-  mapFieldToSQLiteType,
-  toSnakeCase
-} from "./chunk-qxt9vge8.js";
-import {
-  getSystemCollections,
-  init_system_schema
-} from "./chunk-6qs0g65f.js";
-
-// src/db/kysely/snapshot/snapshot-manager.ts
-init_system_schema();
-import fs from "node:fs";
-import { resolve } from "node:path";
-function createSchemaSnapshot(collections, globals, dialect) {
-  const allSchemas = [...getSystemCollections(), ...collections, ...globals];
-  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
-  const snapshot = { tables: {} };
-  for (const collection of allSchemas) {
-    const tableName = toSnakeCase(collection.slug);
-    const table = { name: tableName, columns: {} };
-    table.columns["id"] = { name: "id", type: "text", required: true, unique: true };
-    const flattenedFields = flattenFields(collection.fields);
-    for (const field of flattenedFields) {
-      if (field.type === "relationship" && "hasMany" in field && field.hasMany)
-        continue;
-      const colName = toSnakeCase(field.name);
-      if (colName === "id")
-        continue;
-      table.columns[colName] = {
-        name: colName,
-        type: mapType(field),
-        required: field.required || false,
-        unique: field.unique || false,
-        defaultValue: field.defaultValue
-      };
-    }
-    if (collection.timestamps !== false) {
-      const config = typeof collection.timestamps === "object" ? collection.timestamps : {};
-      const createdField = toSnakeCase(config.createdAt || "createdAt");
-      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
-      const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
-      table.columns[createdField] = {
-        name: createdField,
-        type: tsType,
-        required: false,
-        unique: false
-      };
-      table.columns[updatedField] = {
-        name: updatedField,
-        type: tsType,
-        required: false,
-        unique: false
-      };
-    }
-    const versions = collection.versions;
-    if (versions?.drafts) {
-      table.columns["_status"] = {
-        name: "_status",
-        type: "text",
-        required: false,
-        unique: false,
-        defaultValue: "draft"
-      };
-    }
-    snapshot.tables[tableName] = table;
-    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();
-        snapshot.tables[joinTableName] = {
-          name: joinTableName,
-          columns: {
-            id: { name: "id", type: "text", required: true, unique: true },
-            source_id: { name: "source_id", type: "text", required: true, unique: false },
-            target_id: { name: "target_id", type: "text", required: true, unique: false },
-            order: {
-              name: "order",
-              type: "integer",
-              required: false,
-              unique: false,
-              defaultValue: 0
-            }
-          }
-        };
-      }
-    }
-    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);
-          const blockTableName = `${tableName}_${blockName}_${blockSlug}`.toLowerCase();
-          const blockTable = {
-            name: blockTableName,
-            columns: {
-              id: { name: "id", type: "text", required: true, unique: true },
-              _parent_id: { name: "_parent_id", type: "text", required: true, unique: false },
-              _order: {
-                name: "_order",
-                type: "integer",
-                required: false,
-                unique: false,
-                defaultValue: 0
-              },
-              block_type: {
-                name: "block_type",
-                type: "text",
-                required: true,
-                unique: false,
-                defaultValue: block.slug
-              }
-            }
-          };
-          const blockFlattened = flattenFields(block.fields);
-          for (const bField of blockFlattened) {
-            const bColName = toSnakeCase(bField.name);
-            if (bColName === "id")
-              continue;
-            blockTable.columns[bColName] = {
-              name: bColName,
-              type: mapType(bField),
-              required: bField.required || false,
-              unique: bField.unique || false,
-              defaultValue: bField.defaultValue
-            };
-          }
-          const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
-          blockTable.columns["created_at"] = {
-            name: "created_at",
-            type: tsType,
-            required: false,
-            unique: false
-          };
-          blockTable.columns["updated_at"] = {
-            name: "updated_at",
-            type: tsType,
-            required: false,
-            unique: false
-          };
-          snapshot.tables[blockTableName] = blockTable;
-        }
-      }
-    }
-  }
-  return snapshot;
-}
-function saveSnapshot(migrationDir, snapshotName, snapshot) {
-  const metaDir = resolve(process.cwd(), migrationDir, "meta");
-  if (!fs.existsSync(metaDir)) {
-    fs.mkdirSync(metaDir, { recursive: true });
-  }
-  const filePath = resolve(metaDir, `${snapshotName}.json`);
-  fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), "utf-8");
-  const lastPath = resolve(metaDir, `_journal.json`);
-  let journal = { snapshots: [] };
-  if (fs.existsSync(lastPath)) {
-    try {
-      journal = JSON.parse(fs.readFileSync(lastPath, "utf-8"));
-    } catch (e) {}
-  }
-  journal.snapshots.push(snapshotName);
-  fs.writeFileSync(lastPath, JSON.stringify(journal, null, 2), "utf-8");
-}
-function loadLastSnapshot(migrationDir) {
-  const metaDir = resolve(process.cwd(), migrationDir, "meta");
-  const lastPath = resolve(metaDir, `_journal.json`);
-  if (!fs.existsSync(lastPath))
-    return null;
-  try {
-    const journal = JSON.parse(fs.readFileSync(lastPath, "utf-8"));
-    const lastSnapshotName = journal.snapshots[journal.snapshots.length - 1];
-    if (!lastSnapshotName)
-      return null;
-    const snapshotPath = resolve(metaDir, `${lastSnapshotName}.json`);
-    if (!fs.existsSync(snapshotPath))
-      return null;
-    return JSON.parse(fs.readFileSync(snapshotPath, "utf-8"));
-  } catch (e) {
-    return null;
-  }
-}
-
-// src/cli/core/migrations/schema-diff-engine.ts
-async function compareSchemas(previous, current, interactive = true) {
-  const actions = [];
-  const prevTableNames = Object.keys(previous.tables);
-  const currTableNames = Object.keys(current.tables);
-  const missingTables = prevTableNames.filter((t) => !currTableNames.includes(t));
-  const newTables = currTableNames.filter((t) => !prevTableNames.includes(t));
-  const resolvedMissingTables = new Set;
-  const resolvedNewTables = new Set;
-  if (interactive) {
-    for (const newTable of newTables) {
-      if (missingTables.length > 0) {
-        const options = missingTables.filter((t) => !resolvedMissingTables.has(t)).map((t) => ({ value: t, label: t }));
-        if (options.length > 0) {
-          Wt(`Detecting that collection '${newTable}' was added.`);
-          const answer = await Jt({
-            message: `Is the collection '${newTable}' a rename of any removed collection?`,
-            options: [{ value: "none", label: "No, it's a new collection." }, ...options]
-          });
-          if (!Ct(answer) && answer !== "none") {
-            const oldTableName = answer;
-            actions.push({
-              type: "rename_table",
-              tableName: oldTableName,
-              newName: newTable
-            });
-            resolvedMissingTables.add(oldTableName);
-            resolvedNewTables.add(newTable);
-            const oldTableSnap = previous.tables[oldTableName];
-            const newTableSnap = current.tables[newTable];
-            if (oldTableSnap && newTableSnap) {
-              await compareColumns(newTable, oldTableSnap.columns, newTableSnap.columns, actions, interactive);
-            }
-          }
-        }
-      }
-    }
-  }
-  for (const newTable of newTables) {
-    if (!resolvedNewTables.has(newTable)) {
-      actions.push({
-        type: "create_table",
-        tableName: newTable,
-        tableSnapshot: current.tables[newTable]
-      });
-    }
-  }
-  for (const missingTable of missingTables) {
-    if (!resolvedMissingTables.has(missingTable)) {
-      let confirmed = false;
-      if (interactive) {
-        const result = await Rt({
-          message: `Collection '${missingTable}' was removed from collections array. Do you want to drop it from the database? (This WILL cause data loss)`,
-          initialValue: false
-        });
-        if (!Ct(result)) {
-          confirmed = result;
-        }
-      }
-      actions.push({
-        type: "drop_table",
-        tableName: missingTable,
-        confirmed
-      });
-    }
-  }
-  for (const tableName of currTableNames) {
-    if (prevTableNames.includes(tableName)) {
-      const oldTableSnap = previous.tables[tableName];
-      const newTableSnap = current.tables[tableName];
-      if (oldTableSnap && newTableSnap) {
-        await compareColumns(tableName, oldTableSnap.columns, newTableSnap.columns, actions, interactive);
-      }
-    }
-  }
-  return actions;
-}
-async function compareColumns(tableName, prevCols, currCols, actions, interactive) {
-  const prevColNames = Object.keys(prevCols);
-  const currColNames = Object.keys(currCols);
-  const missingCols = prevColNames.filter((c) => !currColNames.includes(c));
-  const newCols = currColNames.filter((c) => !prevColNames.includes(c));
-  const resolvedMissingCols = new Set;
-  const resolvedNewCols = new Set;
-  if (interactive) {
-    for (const newCol of newCols) {
-      if (missingCols.length > 0) {
-        const options = missingCols.filter((c) => !resolvedMissingCols.has(c)).map((c) => ({ value: c, label: c }));
-        if (options.length > 0) {
-          const answer = await Jt({
-            message: `In table '${tableName}', is the column '${newCol}' a rename of any removed column?`,
-            options: [{ value: "none", label: "No, it's a new column." }, ...options]
-          });
-          if (!Ct(answer) && answer !== "none") {
-            const oldColName = answer;
-            actions.push({
-              type: "rename_column",
-              tableName,
-              columnName: oldColName,
-              newColumnName: newCol
-            });
-            resolvedMissingCols.add(oldColName);
-            resolvedNewCols.add(newCol);
-          }
-        }
-      }
-    }
-  }
-  for (const newCol of newCols) {
-    if (!resolvedNewCols.has(newCol)) {
-      actions.push({
-        type: "add_column",
-        tableName,
-        columnName: newCol,
-        columnSnapshot: currCols[newCol]
-      });
-    }
-  }
-  for (const missingCol of missingCols) {
-    if (!resolvedMissingCols.has(missingCol)) {
-      let confirmed = false;
-      if (interactive) {
-        const result = await Rt({
-          message: `In table '${tableName}', column '${missingCol}' was removed. Do you want to drop it from the database?`,
-          initialValue: false
-        });
-        if (!Ct(result)) {
-          confirmed = result;
-        }
-      }
-      actions.push({
-        type: "drop_column",
-        tableName,
-        columnName: missingCol,
-        confirmed
-      });
-    }
-  }
-  for (const colName of currColNames) {
-    if (prevColNames.includes(colName)) {
-      const prev = prevCols[colName];
-      const curr = currCols[colName];
-      if (prev && curr) {
-        if (prev.type !== curr.type || prev.required !== curr.required || prev.unique !== curr.unique || JSON.stringify(prev.defaultValue) !== JSON.stringify(curr.defaultValue)) {
-          actions.push({
-            type: "change_column",
-            tableName,
-            columnName: colName,
-            columnSnapshot: curr
-          });
-        }
-      }
-    }
-  }
-}
-
-// src/cli/core/migrations/schema-diff.ts
-async function generateDiffCode(opaca, dialect, migrationDir, snapshotName, options = {
-  saveSnapshot: true,
-  interactive: true
-}) {
-  const collections = opaca.collections || [];
-  const globals = opaca.globals || [];
-  const currentSnapshot = createSchemaSnapshot(collections, globals, dialect);
-  let previousSnapshot = loadLastSnapshot(migrationDir);
-  let isInitial = false;
-  if (!previousSnapshot) {
-    isInitial = true;
-    previousSnapshot = { tables: {} };
-  }
-  const actions = await compareSchemas(previousSnapshot, currentSnapshot, options.interactive);
-  if (actions.length === 0) {
-    return { hasChanges: false, upCode: "", downCode: "" };
-  }
-  let upCode = "";
-  let downCode = "";
-  for (const action of actions) {
-    if (action.type === "create_table") {
-      const table = action.tableSnapshot;
-      if (dialect === "d1") {
-        upCode += `CREATE TABLE "${table.name}" (
-`;
-        const cols = Object.values(table.columns);
-        const colDefs = cols.map((c) => {
-          let def = `  "${c.name}" ${c.type.toUpperCase()}`;
-          if (c.name === "id")
-            def += " PRIMARY KEY";
-          if (c.required && c.name !== "id")
-            def += " NOT NULL";
-          if (c.unique && c.name !== "id")
-            def += " UNIQUE";
-          if (c.defaultValue !== undefined) {
-            let val = c.defaultValue;
-            if (typeof val === "string")
-              val = `'${val}'`;
-            else if (typeof val === "boolean")
-              val = val ? 1 : 0;
-            def += ` DEFAULT ${val}`;
-          }
-          if ((c.name === "created_at" || c.name === "updated_at") && c.defaultValue === undefined) {
-            def += ` DEFAULT CURRENT_TIMESTAMP`;
-          }
-          return def;
-        });
-        upCode += colDefs.join(`,
-`) + `
-);
-
-`;
-        downCode = `DROP TABLE "${table.name}";
-
-` + downCode;
-      } else {
-        upCode += `  await db.schema.createTable('${table.name}')
-`;
-        for (const c of Object.values(table.columns)) {
-          if (c.name === "id") {
-            upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())
-`;
-            continue;
-          }
-          let constraints = "";
-          if (c.required)
-            constraints += ".notNull()";
-          if (c.unique)
-            constraints += ".unique()";
-          if (c.defaultValue !== undefined) {
-            let val = c.defaultValue;
-            if (typeof val === "string")
-              val = `'${val}'`;
-            else if (typeof val === "boolean")
-              val = dialect === "sqlite" ? val ? 1 : 0 : val;
-            constraints += `.defaultTo(${val})`;
-          }
-          if ((c.name === "created_at" || c.name === "updated_at" || c.name === "createdAt" || c.name === "updatedAt") && c.defaultValue === undefined) {
-            constraints += ".defaultTo(sql`CURRENT_TIMESTAMP`)";
-          }
-          upCode += `    .addColumn('${c.name}', '${c.type}', (col) => col${constraints})
-`;
-        }
-        upCode += `    .execute();
-
-`;
-        downCode = `  await db.schema.dropTable('${table.name}').execute();
-` + downCode;
-      }
-    } else if (action.type === "drop_table") {
-      if (dialect === "d1") {
-        if (action.confirmed) {
-          upCode += `DROP TABLE "${action.tableName}";
-
-`;
-        } else {
-          upCode += `  -- Data Loss Prevention: Review before dropping table
-`;
-          upCode += `  -- DROP TABLE "${action.tableName}";
-
-`;
-        }
-      } else {
-        if (action.confirmed) {
-          upCode += `  await db.schema.dropTable('${action.tableName}').execute();
-
-`;
-        } else {
-          upCode += `  // Data Loss Prevention: Review before dropping table
-`;
-          upCode += `  // await db.schema.dropTable('${action.tableName}').execute();
-
-`;
-        }
-      }
-    } else if (action.type === "rename_table") {
-      if (dialect === "d1") {
-        upCode += `ALTER TABLE "${action.tableName}" RENAME TO "${action.newName}";
-
-`;
-        downCode = `ALTER TABLE "${action.newName}" RENAME TO "${action.tableName}";
-
-` + downCode;
-      } else {
-        upCode += `  await db.schema.alterTable('${action.tableName}').renameTo('${action.newName}').execute();
-
-`;
-        downCode = `  await db.schema.alterTable('${action.newName}').renameTo('${action.tableName}').execute();
-
-` + downCode;
-      }
-    } else if (action.type === "add_column") {
-      const c = action.columnSnapshot;
-      if (dialect === "d1") {
-        let def = `ALTER TABLE "${action.tableName}" ADD COLUMN "${c.name}" ${c.type.toUpperCase()}`;
-        if (c.defaultValue !== undefined) {
-          let val = c.defaultValue;
-          if (typeof val === "string")
-            val = `'${val}'`;
-          else if (typeof val === "boolean")
-            val = val ? 1 : 0;
-          def += ` DEFAULT ${val}`;
-        } else if (c.name === "created_at" || c.name === "updated_at" || c.name === "createdAt" || c.name === "updatedAt") {
-          def += ` DEFAULT CURRENT_TIMESTAMP`;
-        }
-        upCode += `${def};
-`;
-        downCode = `-- ALTER TABLE "${action.tableName}" DROP COLUMN "${c.name}"; -- Note: D1 does not support DROP COLUMN
-` + downCode;
-      } else {
-        let constraints = "";
-        if (c.required)
-          constraints += ".notNull()";
-        if (c.unique)
-          constraints += ".unique()";
-        if (c.defaultValue !== undefined) {
-          let val = c.defaultValue;
-          if (typeof val === "string")
-            val = `'${val}'`;
-          else if (typeof val === "boolean")
-            val = dialect === "sqlite" ? val ? 1 : 0 : val;
-          constraints += `.defaultTo(${val})`;
-        }
-        if ((c.name === "created_at" || c.name === "updated_at" || c.name === "createdAt" || c.name === "updatedAt") && c.defaultValue === undefined) {
-          constraints += ".defaultTo(sql`CURRENT_TIMESTAMP`)";
-        }
-        upCode += `  await db.schema.alterTable('${action.tableName}')
-    .addColumn('${c.name}', '${c.type}', (col) => col${constraints})
-    .execute();
-
-`;
-        downCode = `  await db.schema.alterTable('${action.tableName}')
-    .dropColumn('${c.name}')
-    .execute();
-
-` + downCode;
-      }
-    } else if (action.type === "drop_column") {
-      if (dialect === "d1") {
-        if (action.confirmed) {
-          upCode += `ALTER TABLE "${action.tableName}" DROP COLUMN "${action.columnName}";
-
-`;
-        } else {
-          upCode += `  -- Data Loss Prevention: Review before dropping column
-`;
-          upCode += `  -- ALTER TABLE "${action.tableName}" DROP COLUMN "${action.columnName}";
-
-`;
-        }
-      } else {
-        if (action.confirmed) {
-          upCode += `  await db.schema.alterTable('${action.tableName}').dropColumn('${action.columnName}').execute();
-
-`;
-        } else {
-          upCode += `  // Data Loss Prevention: Review before dropping column
-`;
-          upCode += `  // await db.schema.alterTable('${action.tableName}').dropColumn('${action.columnName}').execute();
-
-`;
-        }
-      }
-    } else if (action.type === "rename_column") {
-      if (dialect === "d1") {
-        upCode += `ALTER TABLE "${action.tableName}" RENAME COLUMN "${action.columnName}" TO "${action.newColumnName}";
-
-`;
-        downCode = `ALTER TABLE "${action.tableName}" RENAME COLUMN "${action.newColumnName}" TO "${action.columnName}";
-
-` + downCode;
-      } else {
-        upCode += `  await db.schema.alterTable('${action.tableName}').renameColumn('${action.columnName}', '${action.newColumnName}').execute();
-
-`;
-        downCode = `  await db.schema.alterTable('${action.tableName}').renameColumn('${action.newColumnName}', '${action.columnName}').execute();
-
-` + downCode;
-      }
-    }
-  }
-  if (options.saveSnapshot) {
-    saveSnapshot(migrationDir, snapshotName, currentSnapshot);
-  }
-  return {
-    hasChanges: true,
-    upCode: upCode.trimEnd(),
-    downCode: downCode.trimEnd()
-  };
-}
-
-export { generateDiffCode };