opacacms 0.3.2 → 0.3.3

package/dist/chunk-9by912e9.js

@@ -1,318 +0,0 @@
-import {
-  generateDiffCode
-} from "./chunk-2gdsy99f.js";
-import {
-  require_picocolors
-} from "./chunk-f3dg5dq4.js";
-import {
-  Gt,
-  R,
-  Wt,
-  be
-} from "./chunk-gzdfc1ct.js";
-import {
-  loadConfig,
-  resolveConfigPath
-} from "./chunk-jvv72110.js";
-import {
-  defineCommand
-} from "./chunk-71wwx9vj.js";
-import {
-  getRandomMigrationName
-} from "./chunk-5b8r0v8c.js";
-import"./chunk-qxt9vge8.js";
-import {
-  logger
-} from "./chunk-jq1drsen.js";
-import"./chunk-6qs0g65f.js";
-import {
-  __require,
-  __toESM
-} from "./chunk-6bywt602.js";
-
-// src/cli/commands/migrate.ts
-import fs2 from "node:fs";
-import { relative as relative2, resolve as resolve2 } from "node:path";
-var import_picocolors = __toESM(require_picocolors(), 1);
-
-// src/cli/core/migrations/migrate-logic.ts
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import { relative, resolve } from "node:path";
-async function migrateCreateCommand(opaca, migrationName, outDir) {
-  const db = opaca.db;
-  const migrationDir = outDir || db.migrationDir || "./migrations";
-  const fullMigrationDir = resolve(process.cwd(), migrationDir);
-  if (!fs.existsSync(fullMigrationDir)) {
-    fs.mkdirSync(fullMigrationDir, { recursive: true });
-  }
-  const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
-  const { generateDiffCode: generateDiffCode2 } = await import("./chunk-0hxz770x.js");
-  let dialect = "sqlite";
-  if (db.name === "postgres")
-    dialect = "postgres";
-  if (db.name === "d1")
-    dialect = "d1";
-  const isD1 = dialect === "d1";
-  const name = !migrationName || migrationName === "migration" ? getRandomMigrationName() : migrationName;
-  const snapshotName = `${timestamp}_${name}`;
-  const fileName = `${snapshotName}.${isD1 ? "sql" : "ts"}`;
-  const filePath = resolve(fullMigrationDir, fileName);
-  const result = await generateDiffCode2(opaca, dialect, migrationDir, snapshotName, {
-    saveSnapshot: true,
-    interactive: true
-  });
-  if (!result.hasChanges) {
-    logger.info("✨ No schema changes detected. Migration not created.");
-    return false;
-  }
-  let template = "";
-  if (isD1) {
-    template = `-- OpacaCMS Auto-generated SQL Migration
--- Migration: ${snapshotName}
-
--- UP
-${result.upCode}
-`;
-  } else {
-    template = `import { type OpacaMigrationDb, sql } from 'opacacms/db';
-
-export async function up(db: OpacaMigrationDb): Promise<void> {
-${result.upCode}}
-
-export async function down(db: OpacaMigrationDb): Promise<void> {
-${result.downCode}}
-`;
-  }
-  fs.writeFileSync(filePath, template);
-  logger.success(`\uD83D\uDE80 Migration created successfully at ${relative(process.cwd(), filePath)}`);
-  return true;
-}
-async function migrateRunCommand(db) {
-  logger.info("\uD83C\uDFAC Running migrations...");
-  if (db.runMigrations) {
-    await db.connect();
-    try {
-      await db.runMigrations();
-      logger.success("✅ Migrations applied successfully!");
-    } catch (error) {
-      logger.error(`❌ Failed to run migrations: ${error.message}`);
-      throw error;
-    } finally {}
-  } else {
-    throw new Error(`Adapter ${db.name} does not support running migrations.`);
-  }
-}
-async function migrateStatusCommand(opaca) {
-  logger.info("\uD83D\uDCCA Checking migration status...");
-  const db = opaca.db;
-  const migrationDir = db.migrationDir || "./migrations";
-  const fullMigrationDir = resolve(process.cwd(), migrationDir);
-  if (!fs.existsSync(fullMigrationDir)) {
-    logger.info("No migrations directory found.");
-    return;
-  }
-  const migrationFiles = fs.readdirSync(fullMigrationDir).filter((f) => f.endsWith(".ts") || f.endsWith(".sql")).sort();
-  let appliedMigrations = [];
-  try {
-    await db.connect();
-    const rows = await db.unsafe("SELECT name FROM kysely_migration").catch(() => []);
-    appliedMigrations = rows.map((r) => r.name);
-  } catch (e) {} finally {}
-  console.log(`
-Found ${migrationFiles.length} migration files in ${migrationDir}:`);
-  for (const file of migrationFiles) {
-    const name = file.replace(/\.(ts|sql)$/, "");
-    const isApplied = appliedMigrations.includes(name);
-    console.log(`  ${isApplied ? "✅ [Applied]  " : "❌ [Pending]  "} ${file}`);
-  }
-  const pending = migrationFiles.filter((f) => !appliedMigrations.includes(f.replace(/\.(ts|sql)$/, "")));
-  if (pending.length > 0) {
-    console.log(`
-\uD83D\uDCA1 You have ${pending.length} pending migrations. Run 'opacacms migrate' to apply them.`);
-  } else {
-    console.log(`
-✨ All migrations are up to date.`);
-  }
-}
-async function migrateD1Command(migrationDir, isRemote, binding = "DB") {
-  const fullMigrationDir = resolve(process.cwd(), migrationDir);
-  if (!fs.existsSync(fullMigrationDir)) {
-    throw new Error(`[OpacaCMS] Migration directory not found: ${fullMigrationDir}`);
-  }
-  const migrations = fs.readdirSync(fullMigrationDir).filter((file) => file.endsWith(".sql")).sort();
-  if (migrations.length === 0) {
-    console.log(`[OpacaCMS] No SQL migrations found in ${fullMigrationDir}`);
-    return;
-  }
-  console.log(`[OpacaCMS] Found ${migrations.length} migrations. Applying to ${isRemote ? "\uD83C\uDF0A REMOTE (Cloudflare D1)" : "\uD83D\uDCBB LOCAL (SQLite)"}...`);
-  for (const migration of migrations) {
-    const filePath = resolve(fullMigrationDir, migration);
-    console.log(`
-[OpacaCMS] \uD83D\uDCE6 Applying: ${migration}...`);
-    const wranglerArgs = [
-      "wrangler",
-      "d1",
-      "execute",
-      binding,
-      "--file",
-      filePath,
-      isRemote ? "--remote" : "--local",
-      "--yes"
-    ];
-    const result = spawnSync("bun", ["x", ...wranglerArgs], {
-      stdio: "inherit",
-      shell: false,
-      cwd: process.cwd()
-    });
-    if (result.status !== 0) {
-      console.error(`[OpacaCMS] ❌ Failed to apply migration: ${migration}`);
-    } else {
-      console.log(`[OpacaCMS] ✅ Success: ${migration}`);
-    }
-  }
-  console.log(`
-[OpacaCMS] ✨ Database migration process completed!`);
-}
-
-// src/cli/commands/migrate.ts
-var migrate_default = defineCommand({
-  meta: {
-    name: "migrate",
-    description: "Manage database migrations"
-  },
-  args: {
-    config: {
-      type: "string",
-      alias: "c",
-      description: "Path to the OpacaCMS configuration file"
-    },
-    action: {
-      type: "positional",
-      description: "Action to perform: run (default), create, diff, status, d1",
-      required: false
-    },
-    name: {
-      type: "positional",
-      description: "Name of the migration (for create)",
-      required: false
-    },
-    out: {
-      type: "string",
-      alias: "o",
-      description: "Output directory for migrations"
-    },
-    remote: {
-      type: "boolean",
-      description: "Apply migrations to remote D1"
-    },
-    binding: {
-      type: "string",
-      alias: "b",
-      description: "D1 database binding name",
-      default: "DB"
-    }
-  },
-  async run({ args }) {
-    console.log();
-    Wt(import_picocolors.default.bgMagenta(import_picocolors.default.white(" OpacaCMS Migrations ")));
-    const s = be();
-    const action = args.action || "run";
-    let opaca;
-    if (action !== "d1") {
-      s.start("Loading configuration...");
-      try {
-        const configPath = resolveConfigPath(args.config);
-        opaca = await loadConfig(configPath);
-        s.stop(`Configuration loaded. DB: ${import_picocolors.default.cyan(opaca.db.name)}`);
-      } catch (err) {
-        s.stop(import_picocolors.default.red("Failed to load configuration."));
-        R.error(err.message);
-        process.exit(1);
-      }
-    }
-    try {
-      if (action === "create") {
-        const name = !args.name || args.name === "migration" ? getRandomMigrationName() : args.name;
-        s.start(`Generating baseline migration '${name}'...`);
-        const created = await migrateCreateCommand(opaca, name, args.out);
-        if (created) {
-          s.stop(`Baseline migration created successfully!`);
-        } else {
-          s.stop(`Operation aborted. No changes detected.`);
-        }
-      } else if (action === "diff") {
-        let name = args.name || "migration";
-        if (name === "migration") {
-          name = getRandomMigrationName();
-        }
-        s.start(`Analyzing schema for differences...`);
-        let dialect = "sqlite";
-        if (opaca.db.name === "postgres")
-          dialect = "postgres";
-        if (opaca.db.name === "d1")
-          dialect = "d1";
-        const migrationDir = opaca.db.migrationDir || "./migrations";
-        const { hasChanges, upCode, downCode } = await generateDiffCode(opaca, dialect, migrationDir, "diff_check", { saveSnapshot: false, interactive: false });
-        if (!hasChanges) {
-          s.stop(`Schema is already up to date. No migration generated.`);
-        } else {
-          s.start(`Generating diff migration '${name}'...`);
-          const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
-          const isD1 = dialect === "d1";
-          const fileName = `${timestamp}_${name}.${isD1 ? "sql" : "ts"}`;
-          const migrationDir2 = args.out || opaca.db.migrationDir || "./migrations";
-          const fullMigrationDir = resolve2(process.cwd(), migrationDir2);
-          if (!fs2.existsSync(fullMigrationDir)) {
-            fs2.mkdirSync(fullMigrationDir, { recursive: true });
-          }
-          const filePath = resolve2(fullMigrationDir, fileName);
-          let template = "";
-          if (isD1) {
-            template = `-- OpacaCMS Auto-generated SQL Diff Migration
-
-${upCode}`;
-          } else {
-            template = `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}
-}
-`;
-          }
-          fs2.writeFileSync(filePath, template);
-          s.stop(`Diff migration created successfully at ${relative2(process.cwd(), filePath)}!`);
-        }
-      } else if (action === "run") {
-        s.start(`Applying pending migrations...`);
-        await migrateRunCommand(opaca.db);
-        s.stop(`Migrations applied successfully!`);
-      } else if (action === "status") {
-        s.start(`Checking migration status...`);
-        await migrateStatusCommand(opaca);
-        s.stop(`Migration status checked.`);
-      } else if (action === "d1") {
-        s.start(`Applying D1 migrations...`);
-        await migrateD1Command(args.out || "./migrations", !!args.remote, args.binding);
-        s.stop(`D1 migrations processed!`);
-      } else {
-        R.error(`Unknown migration action: ${action}`);
-        process.exit(1);
-      }
-      Gt("Done! \uD83D\uDE80");
-    } catch (err) {
-      if (s)
-        s.stop(import_picocolors.default.red("Migration failed."));
-      R.error(err.message);
-      Gt(import_picocolors.default.red("Operation aborted."));
-      process.exit(1);
-    }
-  }
-});
-export {
-  migrate_default as default
-};

package/dist/chunk-f3dg5dq4.js

@@ -1,75 +0,0 @@
-import {
-  __commonJS
-} from "./chunk-6bywt602.js";
-
-// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
-export { require_picocolors };

package/dist/chunk-g17v7yfr.js

@@ -1,237 +0,0 @@
-import {
-  require_picocolors
-} from "./chunk-f3dg5dq4.js";
-import {
-  Ct,
-  Nt,
-  R,
-  Vt,
-  Zt
-} from "./chunk-gzdfc1ct.js";
-import {
-  defineCommand
-} from "./chunk-71wwx9vj.js";
-import {
-  __toESM
-} from "./chunk-6bywt602.js";
-
-// src/cli/commands/generate.ts
-import fs2 from "node:fs";
-import { resolve as resolve2 } from "node:path";
-var import_picocolors = __toESM(require_picocolors(), 1);
-
-// src/cli/core/types/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.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";
-  }
-}
-
-// src/cli/commands/generate.ts
-var generate_default = defineCommand({
-  meta: {
-    name: "generate",
-    description: "Generate boilerplates (collections/globals) or TypeScript definitions"
-  },
-  args: {
-    type: {
-      type: "positional",
-      description: "What to generate: 'types', 'collection', or 'global'",
-      required: true
-    },
-    name: {
-      type: "positional",
-      description: "The name of the collection or global to generate (if applicable)",
-      required: false
-    },
-    url: {
-      type: "string",
-      description: "The URL of the OpacaCMS instance (for 'types')"
-    },
-    token: {
-      type: "string",
-      description: "The API Key to use for fetching metadata (for 'types')"
-    },
-    out: {
-      type: "string",
-      alias: "o",
-      description: "The output file path (for 'types')"
-    }
-  },
-  async run({ args }) {
-    if (args.type === "types") {
-      if (!args.url || !args.token) {
-        R.error(import_picocolors.default.red("URL and Token are required to generate types from a remote instance."));
-        R.info("Usage: opacacms generate types --url <url> --token <token> [--out <file>]");
-        process.exit(1);
-      }
-      await generateTypesCommand(args.url, args.token, args.out || "opaca.d.ts");
-      return;
-    }
-    if (args.type === "collection" || args.type === "global") {
-      let name = args.name;
-      if (!name) {
-        const response = await Zt({
-          message: `What should we name your ${args.type}? (e.g. ${args.type === "collection" ? "posts" : "site-settings"})`
-        });
-        if (Ct(response)) {
-          Nt("Operation cancelled.");
-          process.exit(0);
-        }
-        name = response;
-      }
-      const isCollection = args.type === "collection";
-      const folderName = isCollection ? "collections" : "globals";
-      const fileName = `${name}.ts`;
-      const filePath = resolve2(process.cwd(), folderName, fileName);
-      if (fs2.existsSync(filePath)) {
-        R.error(import_picocolors.default.red(`File already exists at ${folderName}/${fileName}`));
-        process.exit(1);
-      }
-      fs2.mkdirSync(resolve2(process.cwd(), folderName), { recursive: true });
-      const template = isCollection ? `import { z, defineCollection } from 'opacacms/schema';
-
-export const ${name} = defineCollection({
-  slug: '${name}',
-  label: '${name.charAt(0).toUpperCase() + name.slice(1)}',
-  admin: {
-    useAsTitle: 'title',
-    icon: 'FileText'
-  },
-  schema: z.object({
-    id: z.text().default(() => crypto.randomUUID()),
-    title: z.text({ label: 'Title' }).required(),
-    content: z.richText({ label: 'Content' }),
-  })
-});
-` : `import { z, defineGlobal } from 'opacacms/schema';
-
-export const ${name} = defineGlobal({
-  slug: '${name}',
-  label: '${name.charAt(0).toUpperCase() + name.slice(1)}',
-  admin: {
-    icon: 'Settings'
-  },
-  schema: z.object({
-    siteName: z.text({ label: 'Site Name' }).required(),
-    description: z.textarea({ label: 'Description' }),
-  })
-});
-`;
-      fs2.writeFileSync(filePath, template);
-      R.success(import_picocolors.default.green(`Successfully generated ${args.type} at ./${folderName}/${fileName}`));
-      Vt(`Don't forget to import it into your opacacms.config.ts and add it to the '${folderName}' array!`, "Reminder");
-      return;
-    }
-    R.error(import_picocolors.default.red(`Unknown generation type: ${args.type}. Use 'types', 'collection', or 'global'.`));
-    process.exit(1);
-  }
-});
-export {
-  generate_default as default
-};