opacacms 0.3.1 → 0.3.3

package/dist/chunk-fatyf6f7.js

@@ -1,221 +0,0 @@
-import {
-  require_picocolors
-} from "./chunk-rwqwsanx.js";
-import {
-  Ct,
-  Gt,
-  Jt,
-  Nt,
-  Rt,
-  Vt,
-  Wt,
-  Zt,
-  be
-} from "./chunk-ec4jhybj.js";
-import {
-  defineCommand
-} from "./chunk-1qm0m8r8.js";
-import {
-  __toESM
-} from "./chunk-6bywt602.js";
-
-// src/cli/commands/init.ts
-import fs from "node:fs";
-import { resolve } from "node:path";
-var import_picocolors = __toESM(require_picocolors(), 1);
-var init_default = defineCommand({
-  meta: {
-    name: "init",
-    description: "Initialize a new OpacaCMS project"
-  },
-  args: {
-    target: {
-      type: "positional",
-      description: "Target directory name",
-      required: false
-    },
-    example: {
-      type: "string",
-      alias: "e",
-      description: "Use an example template"
-    }
-  },
-  async run({ args }) {
-    console.log();
-    Wt(import_picocolors.default.bgBlue(import_picocolors.default.white(" Welcome to OpacaCMS! ")));
-    let target = args.target;
-    if (!target) {
-      const response = await Zt({
-        message: "Where should we create your project?",
-        placeholder: "my-opaca-app",
-        defaultValue: "my-opaca-app"
-      });
-      if (Ct(response)) {
-        Nt("Operation cancelled.");
-        process.exit(0);
-      }
-      target = response;
-    }
-    if (args.example) {
-      const s2 = be();
-      s2.start(`Using example template: ${args.example}`);
-      let currentDir = resolve(import.meta.dirname);
-      let exampleDir = "";
-      const localExample = resolve(process.cwd(), "examples", args.example);
-      if (fs.existsSync(localExample)) {
-        exampleDir = localExample;
-      } else {
-        while (currentDir !== resolve(currentDir, "..")) {
-          const potential = resolve(currentDir, "examples", args.example);
-          if (fs.existsSync(potential)) {
-            exampleDir = potential;
-            break;
-          }
-          currentDir = resolve(currentDir, "..");
-        }
-      }
-      if (!exampleDir) {
-        s2.stop(`Example ${args.example} not found.`);
-        process.exit(1);
-      }
-      fs.cpSync(exampleDir, resolve(process.cwd(), target), { recursive: true });
-      s2.stop(`Copied example ${args.example} to ${target}!`);
-      Gt(`Run ${import_picocolors.default.cyan(`cd ${target} && bun install`)} to get started.`);
-      return;
-    }
-    const dbType = await Jt({
-      message: "Which database would you like to use?",
-      options: [
-        { value: "sqlite", label: "SQLite (Local/Bun)" },
-        { value: "d1", label: "Cloudflare D1" },
-        { value: "postgres", label: "PostgreSQL" }
-      ],
-      initialValue: "sqlite"
-    });
-    if (Ct(dbType)) {
-      Nt("Operation cancelled.");
-      process.exit(0);
-    }
-    const useAuth = await Rt({
-      message: "Enable Authentication (Better Auth)?",
-      initialValue: true
-    });
-    if (Ct(useAuth)) {
-      Nt("Operation cancelled.");
-      process.exit(0);
-    }
-    const s = be();
-    s.start(`Generating boilerplate in ./${target}...`);
-    fs.mkdirSync(resolve(process.cwd(), target), { recursive: true });
-    let dbImport = "";
-    let dbInit = "";
-    if (dbType === "sqlite") {
-      dbImport = `import { createSQLiteAdapter } from 'opacacms/db/sqlite';`;
-      dbInit = `createSQLiteAdapter('local.db')`;
-    } else if (dbType === "d1") {
-      dbImport = `import { createD1Adapter } from 'opacacms/db/d1';`;
-      dbInit = `createD1Adapter(env.DB)`;
-    } else if (dbType === "postgres") {
-      dbImport = `import { createPostgresAdapter } from 'opacacms/db/postgres';`;
-      dbInit = `createPostgresAdapter(process.env.DATABASE_URL!)`;
-    }
-    let authConfig = "";
-    if (useAuth) {
-      authConfig = `
-  auth: {
-    strategies: { emailPassword: true },
-    features: {
-      apiKeys: { enabled: true }
-    }
-  },`;
-    }
-    let configCode = `import { defineConfig } from 'opacacms/config';
-import { z, defineCollection } from 'opacacms/schema';
-${dbImport}
-
-const posts = defineCollection({
-  slug: 'posts',
-  schema: z.object({
-    id: z.text().default(() => crypto.randomUUID()),
-    title: z.text().required(),
-    content: z.richText(),
-  })
-});
-
-export default defineConfig({
-  appName: "My OpacaCMS App",
-  serverURL: "http://localhost:3000",
-  secret: "my-super-secret-key-change-me",
-  db: ${dbInit},
-  runMigrationsOnStartup: true,${authConfig}
-  collections: [posts]
-});
-`;
-    if (dbType === "d1") {
-      configCode = `import { defineConfig } from 'opacacms/config';
-import { z, defineCollection } from 'opacacms/schema';
-${dbImport}
-
-const posts = defineCollection({
-  slug: 'posts',
-  schema: z.object({
-    id: z.text().default(() => crypto.randomUUID()),
-    title: z.text().required(),
-    content: z.richText(),
-  })
-});
-
-const getConfig = (env: any, request: Request) => defineConfig({
-  appName: "My Edge App",
-  serverURL: new URL(request.url).origin,
-  secret: env.OPACA_SECRET,
-  db: ${dbInit},
-  runMigrationsOnStartup: true,${authConfig}
-  collections: [posts]
-});
-
-export default getConfig;
-`;
-    }
-    fs.writeFileSync(resolve(process.cwd(), target, "opacacms.config.ts"), configCode);
-    let serverCode = "";
-    if (dbType === "d1") {
-      serverCode = `import { createCloudflareWorkersHandler } from 'opacacms/runtimes/cloudflare-workers';
-import config from './opacacms.config';
-
-const app = createCloudflareWorkersHandler(config);
-
-export default app;
-`;
-    } else {
-      serverCode = `import { createBunHandler } from 'opacacms/runtimes/bun';
-import config from './opacacms.config';
-
-const { app, init } = createBunHandler(config, { port: 3000 });
-
-await init(); // Connects DB, runs migrations, starts server
-console.log('\uD83D\uDE80 Listening on http://localhost:3000');
-`;
-    }
-    fs.writeFileSync(resolve(process.cwd(), target, "index.ts"), serverCode);
-    const pkgJson = {
-      name: target,
-      type: "module",
-      scripts: {
-        dev: dbType === "d1" ? "wrangler dev" : "bun run --watch index.ts"
-      },
-      dependencies: {
-        opacacms: "latest"
-      }
-    };
-    fs.writeFileSync(resolve(process.cwd(), target, "package.json"), JSON.stringify(pkgJson, null, 2));
-    s.stop(`Project created successfully in ${import_picocolors.default.green(`./${target}`)}!`);
-    Vt(`cd ${target}
-bun install
-bun run dev`, "Next Steps");
-    Gt(`Build something awesome! \uD83C\uDF88`);
-  }
-});
-export {
-  init_default as default
-};

package/dist/chunk-gyaf5kgf.js

@@ -1,10 +0,0 @@
-import {
-  generateDiffCode
-} from "./chunk-7rr5p01g.js";
-import"./chunk-ec4jhybj.js";
-import"./chunk-qxt9vge8.js";
-import"./chunk-6qs0g65f.js";
-import"./chunk-6bywt602.js";
-export {
-  generateDiffCode
-};

package/dist/chunk-h6dhexzr.js

@@ -1,94 +0,0 @@
-import"./chunk-6bywt602.js";
-
-// src/cli/core/mocks/d1-mock.ts
-import { Database } from "bun:sqlite";
-import fs from "node:fs";
-import path from "node:path";
-function createD1Mock(dbPath = ".opaca/local-d1.db") {
-  const wranglerD1Dir = path.resolve(process.cwd(), ".wrangler/state/v3/d1/miniflare-D1DatabaseObject");
-  if (fs.existsSync(wranglerD1Dir)) {
-    const files = fs.readdirSync(wranglerD1Dir);
-    const sqliteFile = files.find((f) => f.endsWith(".sqlite"));
-    if (sqliteFile) {
-      const wranglerPath = path.join(wranglerD1Dir, sqliteFile);
-      try {
-        const sqlite = new Database(wranglerPath);
-        console.log(`[OpacaCMS] Using Wrangler D1 local state: ${sqliteFile}`);
-        return wrapSqlite(sqlite);
-      } catch (e) {
-        console.warn(`[OpacaCMS] Failed to open Wrangler D1 state at ${wranglerPath}. Falling back...`);
-      }
-    }
-  }
-  let finalPath = dbPath;
-  if (!finalPath) {
-    finalPath = ":memory:";
-    console.log("[OpacaCMS] Using in-memory D1 mock (no -c/--config provided)");
-  }
-  const absolutePath = finalPath === ":memory:" ? finalPath : path.isAbsolute(finalPath) ? finalPath : path.resolve(process.cwd(), finalPath);
-  try {
-    if (absolutePath !== ":memory:") {
-      const dir = path.dirname(absolutePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-    }
-    const sqlite = new Database(absolutePath);
-    if (absolutePath !== ":memory:") {
-      console.log(`[OpacaCMS] Using local CLI database: ${absolutePath}`);
-    }
-    return wrapSqlite(sqlite);
-  } catch (err) {
-    console.warn(`[OpacaCMS] Warning: Could not open database at ${absolutePath}. Using memory database.`);
-    return wrapSqlite(new Database(":memory:"));
-  }
-}
-function wrapSqlite(sqlite) {
-  return {
-    prepare(query) {
-      const stmt = sqlite.prepare(query);
-      const bridge = {
-        bind(...params) {
-          bridge._params = params;
-          return bridge;
-        },
-        async first() {
-          const params = bridge._params || [];
-          return stmt.get(...params);
-        },
-        async all() {
-          const params = bridge._params || [];
-          const results = stmt.all(...params);
-          return { results, success: true, meta: {} };
-        },
-        async run() {
-          const params = bridge._params || [];
-          const result = stmt.run(...params);
-          return {
-            success: true,
-            meta: { changes: result.changes, last_row_id: result.lastInsertRowid }
-          };
-        },
-        async raw() {
-          const params = bridge._params || [];
-          return stmt.all(...params);
-        }
-      };
-      return bridge;
-    },
-    async batch(statements) {
-      const results = [];
-      for (const stmt of statements) {
-        results.push(await stmt.all());
-      }
-      return results;
-    },
-    async exec(query) {
-      sqlite.exec(query);
-      return { count: 0, duration: 0 };
-    }
-  };
-}
-export {
-  createD1Mock
-};

package/dist/chunk-majsbncm.js

@@ -1,98 +0,0 @@
-import {
-  defineCommand,
-  runMain
-} from "./chunk-1qm0m8r8.js";
-import {
-  __require
-} from "./chunk-6bywt602.js";
-
-// src/cli/index.ts
-import fs from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-async function loadConfig(configPath) {
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`Config file not found at ${configPath}`);
-  }
-  const configUrl = pathToFileURL(configPath).href;
-  const mod = await import(configUrl);
-  if (!mod.default) {
-    throw new Error(`The configuration file at ${configPath} must have a 'default' export.`);
-  }
-  const namedExports = Object.keys(mod).filter((k) => k !== "default" && k !== "__esModule");
-  if (namedExports.length > 0) {
-    throw new Error(`Named exports are not allowed in the configuration file. Found: ${namedExports.join(", ")}.`);
-  }
-  let opaca = mod.default;
-  if (typeof opaca === "function") {
-    const { createD1Mock } = await import("./chunk-h6dhexzr.js");
-    const { createR2Mock } = await import("./chunk-x7bnzswh.js");
-    const mockDb = createD1Mock();
-    const mockBucket = createR2Mock();
-    const mockSecureBucket = createR2Mock();
-    opaca = await opaca({
-      DB: mockDb,
-      BUCKET: mockBucket,
-      SECURE_BUCKET: mockSecureBucket,
-      OPACA_SECRET: "cli-secret"
-    }, { url: "http://localhost:3000" });
-  }
-  if (opaca?.fetch) {
-    throw new Error("Default export is a Hono application. The CLI requires the configuration object.");
-  }
-  if (!opaca.db) {
-    throw new Error("No database adapter found in config");
-  }
-  return opaca;
-}
-function resolveConfigPath(explicitPath) {
-  let configPath = explicitPath ? resolve(process.cwd(), explicitPath) : "";
-  if (!configPath) {
-    const defaults = [
-      "opaca.config.ts",
-      "opaca.config.js",
-      "opacacms.config.ts",
-      "opacacms.config.js",
-      "src/opaca.config.ts",
-      "src/opacacms.config.js"
-    ];
-    for (const d of defaults) {
-      if (fs.existsSync(resolve(process.cwd(), d))) {
-        configPath = resolve(process.cwd(), d);
-        break;
-      }
-    }
-  }
-  if (!configPath || !fs.existsSync(configPath)) {
-    throw new Error("Config file not found. Use -c or --config to specify path.");
-  }
-  return configPath;
-}
-var mainCommand = defineCommand({
-  meta: {
-    name: "opacacms",
-    version: "0.1.0",
-    description: "OpacaCMS CLI - The Headless CMS that doesn't get in your way."
-  },
-  args: {
-    config: {
-      type: "string",
-      alias: "c",
-      description: "Path to the OpacaCMS configuration file"
-    }
-  },
-  subCommands: {
-    init: () => import("./chunk-fatyf6f7.js").then((m) => m.default),
-    migrate: () => import("./chunk-d7cgd6vn.js").then((m) => m.default),
-    seed: () => import("./chunk-d0tb1xjw.js").then((m) => m.default),
-    generate: () => import("./chunk-mp2gt9yh.js").then((m) => m.default),
-    plugin: () => import("./chunk-63yg00vx.js").then((m) => m.default),
-    doctor: () => import("./chunk-56n342hs.js").then((m) => m.default),
-    dev: () => import("./chunk-r0ms5tk1.js").then((m) => m.default)
-  }
-});
-if (__require.main == __require.module) {
-  runMain(mainCommand);
-}
-
-export { loadConfig, resolveConfigPath };

package/dist/chunk-mp2gt9yh.js

@@ -1,237 +0,0 @@
-import {
-  require_picocolors
-} from "./chunk-rwqwsanx.js";
-import {
-  Ct,
-  Nt,
-  R,
-  Vt,
-  Zt
-} from "./chunk-ec4jhybj.js";
-import {
-  defineCommand
-} from "./chunk-1qm0m8r8.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
-};