opacacms 0.2.1 → 0.3.1

package/dist/chunk-fatyf6f7.js

@@ -0,0 +1,221 @@
+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-526a3gqx.js → chunk-fnsf1dfm.js}

@@ -5,7 +5,7 @@ import {
   mapFieldToSQLiteType,
   toSnakeCase
 } from "./chunk-qxt9vge8.js";
-import"./chunk-8sqjbsgt.js";
+import"./chunk-6bywt602.js";
 export {
   toSnakeCase,
   mapFieldToSQLiteType,

package/dist/chunk-g9bxb6h0.js

@@ -0,0 +1,205 @@
+import {
+  sanitizeGraphQLName
+} from "./chunk-5b8r0v8c.js";
+
+// src/client.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+class OpacaError extends Error {
+  status;
+  data;
+  constructor(message, status, data = {}) {
+    super(message);
+    this.name = "OpacaError";
+    this.status = status;
+    this.data = data;
+  }
+}
+function createClient(configOrOptions) {
+  const options = configOrOptions.serverURL ? { baseURL: configOrOptions.serverURL } : configOrOptions;
+  const baseURL = options.baseURL.replace(/\/$/, "");
+  let engineConfig = null;
+  let metadataCache = null;
+  const getHeaders = () => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.token) {
+      headers.Authorization = `Bearer ${options.token}`;
+    }
+    return headers;
+  };
+  const fetcher = async (path, init) => {
+    const res = await fetch(`${baseURL}${path}`, {
+      ...init,
+      credentials: "include",
+      headers: {
+        ...getHeaders(),
+        ...init?.headers
+      }
+    });
+    if (!res.ok) {
+      const errorData = await res.json().catch(() => ({}));
+      throw new OpacaError(errorData.message || `API Error: ${res.status}`, res.status, errorData);
+    }
+    return res.json();
+  };
+  const initConfig = async () => {
+    if (engineConfig && metadataCache)
+      return;
+    try {
+      const [setupRes, metadataRes] = await Promise.all([
+        fetcher("/api/__admin/setup"),
+        fetcher("/api/__admin/collections")
+      ]);
+      engineConfig = setupRes.api || { rest: true, graphql: { enabled: false, path: "/graphql" } };
+      metadataCache = metadataRes;
+    } catch (e) {
+      engineConfig = { rest: true, graphql: { enabled: false, path: "/graphql" } };
+      metadataCache = { collections: [], globals: [] };
+    }
+  };
+  const buildSelectionSet = (fields) => {
+    if (!fields || fields.length === 0)
+      return "id";
+    const keys = ["id", "createdAt", "updatedAt"];
+    for (const f of fields) {
+      if (f.name)
+        keys.push(f.name);
+    }
+    return keys.join(" ");
+  };
+  const getSelectionSetForCollection = (slug) => {
+    const col = metadataCache?.collections?.find((c) => c.slug === slug);
+    return buildSelectionSet(col?.fields || []);
+  };
+  const getSelectionSetForGlobal = (slug) => {
+    const glbl = metadataCache?.globals?.find((g) => g.slug === slug);
+    return buildSelectionSet(glbl?.fields || []);
+  };
+  const client = {
+    getMetadata: () => fetcher("/api/__admin/metadata"),
+    getCollections: () => fetcher("/api/__admin/collections"),
+    getSetupStatus: () => fetcher("/api/__admin/setup"),
+    graphql: async (query, variables) => {
+      await initConfig();
+      if (!engineConfig?.graphql?.enabled) {
+        throw new OpacaError("GraphQL is not enabled on this server.", 400);
+      }
+      return fetcher(engineConfig.graphql.path, {
+        method: "POST",
+        body: JSON.stringify({ query, variables })
+      });
+    },
+    collections: new Proxy({}, {
+      get(_, collectionSlug) {
+        return {
+          find: async (query) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForCollection(String(collectionSlug));
+              const limit = query?.limit ? `limit: ${query.limit}` : "";
+              const page = query?.page ? `page: ${query.page}` : "";
+              const argsStr = [limit, page].filter(Boolean).join(", ");
+              const args = argsStr ? `(${argsStr})` : "";
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(collectionSlug)));
+              const gql = `query { find${capitalizedSlug}${args} { docs { ${selection} }, totalDocs, limit, totalPages, page, pagingCounter, hasPrevPage, hasNextPage, prevPage, nextPage, nextCursor, prevCursor } }`;
+              const res = await client.graphql(gql);
+              return res.data[`find${capitalizedSlug}`];
+            }
+            const searchParams = new URLSearchParams;
+            if (query) {
+              Object.entries(query).forEach(([key, value]) => {
+                searchParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+              });
+            }
+            const queryString = searchParams.toString();
+            return fetcher(`/api/${String(collectionSlug)}${queryString ? `?${queryString}` : ""}`);
+          },
+          findOne: async (id) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForCollection(String(collectionSlug));
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(collectionSlug)));
+              const res = await client.graphql(`query getDoc($id: String!) { get${capitalizedSlug}(id: $id) { ${selection} } }`, { id });
+              return res.data[`get${capitalizedSlug}`];
+            }
+            return fetcher(`/api/${String(collectionSlug)}/${id}`);
+          },
+          list: async () => {
+            return client.collections[collectionSlug].find();
+          },
+          create: async (data) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForCollection(String(collectionSlug));
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(collectionSlug)));
+              const res = await client.graphql(`mutation createDoc($data: JSON!) { create${capitalizedSlug}(data: $data) { ${selection} } }`, { data });
+              return res.data[`create${capitalizedSlug}`];
+            }
+            return fetcher(`/api/${String(collectionSlug)}`, {
+              method: "POST",
+              body: JSON.stringify(data)
+            });
+          },
+          update: async (id, data) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForCollection(String(collectionSlug));
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(collectionSlug)));
+              const res = await client.graphql(`mutation updateDoc($id: String!, $data: JSON!) { update${capitalizedSlug}(id: $id, data: $data) { ${selection} } }`, { id, data });
+              return res.data[`update${capitalizedSlug}`];
+            }
+            return fetcher(`/api/${String(collectionSlug)}/${id}`, {
+              method: "PATCH",
+              body: JSON.stringify(data)
+            });
+          },
+          delete: async (id) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(collectionSlug)));
+              const res = await client.graphql(`mutation deleteDoc($id: String!) { delete${capitalizedSlug}(id: $id) }`, { id });
+              return res.data[`delete${capitalizedSlug}`];
+            }
+            return fetcher(`/api/${String(collectionSlug)}/${id}`, {
+              method: "DELETE"
+            });
+          }
+        };
+      }
+    }),
+    globals: new Proxy({}, {
+      get(_, globalSlug) {
+        return {
+          get: async () => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForGlobal(String(globalSlug));
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(globalSlug)));
+              const res = await client.graphql(`query getGlobal { get${capitalizedSlug} { ${selection} } }`);
+              return res.data[`get${capitalizedSlug}`];
+            }
+            return fetcher(`/api/globals/${String(globalSlug)}`);
+          },
+          update: async (data) => {
+            await initConfig();
+            if (engineConfig?.graphql?.enabled && !engineConfig?.rest) {
+              const selection = getSelectionSetForGlobal(String(globalSlug));
+              const capitalizedSlug = capitalize(sanitizeGraphQLName(String(globalSlug)));
+              const res = await client.graphql(`mutation updateGlobal($data: JSON!) { update${capitalizedSlug}(data: $data) { ${selection} } }`, { data });
+              return res.data[`update${capitalizedSlug}`];
+            }
+            return fetcher(`/api/globals/${String(globalSlug)}`, {
+              method: "PATCH",
+              body: JSON.stringify(data)
+            });
+          }
+        };
+      }
+    })
+  };
+  return client;
+}
+
+export { OpacaError, createClient };

package/dist/chunk-gyaf5kgf.js

@@ -0,0 +1,10 @@
+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-9kxpbcb1.js → chunk-h6dhexzr.js}

@@ -1,6 +1,6 @@
-import"./chunk-8sqjbsgt.js";
+import"./chunk-6bywt602.js";
 
-// src/cli/d1-mock.ts
+// src/cli/core/mocks/d1-mock.ts
 import { Database } from "bun:sqlite";
 import fs from "node:fs";
 import path from "node:path";
@@ -20,14 +20,23 @@ function createD1Mock(dbPath = ".opaca/local-d1.db") {
       }
     }
   }
-  const absolutePath = path.isAbsolute(dbPath) ? dbPath : path.resolve(process.cwd(), dbPath);
-  const dir = path.dirname(absolutePath);
+  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 (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (absolutePath !== ":memory:") {
+      const dir = path.dirname(absolutePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
     }
     const sqlite = new Database(absolutePath);
-    console.log(`[OpacaCMS] Using local CLI 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.`);