opacacms 0.1.0

package/dist/chunk-8gkhn1d4.js

@@ -0,0 +1,309 @@
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
+
+// src/cli/seeding.ts
+import { faker } from "@faker-js/faker";
+var defaultFieldGenerators = {
+  text: () => faker.lorem.words(3),
+  textarea: () => faker.lorem.paragraph(),
+  number: () => faker.number.int({ min: 1, max: 1000 }),
+  richtext: () => JSON.stringify({
+    root: {
+      children: [
+        {
+          children: [
+            {
+              detail: 0,
+              format: 0,
+              mode: "normal",
+              style: "",
+              text: faker.lorem.sentence(),
+              type: "text",
+              version: 1
+            }
+          ],
+          direction: "ltr",
+          format: "",
+          indent: 0,
+          type: "heading",
+          tag: "h1",
+          version: 1
+        },
+        {
+          children: [
+            {
+              detail: 0,
+              format: 0,
+              mode: "normal",
+              style: "",
+              text: faker.lorem.paragraphs(2),
+              type: "text",
+              version: 1
+            }
+          ],
+          direction: "ltr",
+          format: "",
+          indent: 0,
+          type: "paragraph",
+          version: 1
+        }
+      ],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "root",
+      version: 1
+    }
+  }),
+  boolean: () => faker.datatype.boolean(),
+  date: () => faker.date.recent().toISOString(),
+  email: () => faker.internet.email(),
+  json: () => ({ [faker.lorem.word()]: faker.lorem.sentence() }),
+  select: () => faker.lorem.word(),
+  radio: () => faker.lorem.word(),
+  blocks: () => []
+};
+async function getRandomIds(db, relationTo, count = 1) {
+  try {
+    const result = await db.find(relationTo, {}, { limit: 50 });
+    const docs = result.docs || [];
+    if (docs.length === 0) {
+      if (!relationTo.startsWith("_")) {
+        console.warn(`[Seeding] No documents found in '${relationTo}' for relationship.`);
+      }
+      return [];
+    }
+    const shuffled = [...docs].sort(() => 0.5 - Math.random());
+    const selected = shuffled.slice(0, count).map((doc) => doc.id);
+    return selected;
+  } catch (e) {
+    console.error(`[Seeding] Failed to fetch random IDs for ${relationTo}:`, e);
+    return [];
+  }
+}
+async function generateDataForFields(fields, db, locales = []) {
+  const record = {};
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      Object.assign(record, await generateDataForFields(field.fields, db, locales));
+      continue;
+    }
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        Object.assign(record, await generateDataForFields(tab.fields, db, locales));
+      }
+      continue;
+    }
+    if (field.type === "group" && field.name) {
+      record[field.name] = await generateDataForFields(field.fields, db, locales);
+      continue;
+    }
+    if (field.name) {
+      const isLocalized = !!field.localized && locales.length > 0;
+      const generateFieldValue = async () => {
+        if (field.type === "relationship" && "relationTo" in field) {
+          if (field.hasMany) {
+            const count = faker.number.int({ min: 1, max: 3 });
+            return await getRandomIds(db, field.relationTo, count);
+          }
+          const ids = await getRandomIds(db, field.relationTo, 1);
+          return ids[0] || null;
+        }
+        if (field.type === "blocks" && field.blocks) {
+          const blockCount = faker.number.int({ min: 1, max: 3 });
+          const generatedBlocks = [];
+          for (let i = 0;i < blockCount; i++) {
+            const blockType = field.blocks[faker.number.int({ min: 0, max: field.blocks.length - 1 })];
+            if (!blockType)
+              continue;
+            const blockData = await generateDataForFields(blockType.fields, db, locales);
+            generatedBlocks.push({
+              ...blockData,
+              blockType: blockType.slug,
+              id: faker.string.uuid()
+            });
+          }
+          return generatedBlocks;
+        }
+        const generator = defaultFieldGenerators[field.type];
+        if (generator) {
+          if (field.type === "select" || field.type === "radio") {
+            const options = field.options;
+            const choices = options?.choices || [];
+            if (choices.length > 0) {
+              const choice = choices[Math.floor(Math.random() * choices.length)];
+              return typeof choice === "string" ? choice : choice.value;
+            }
+          }
+          return generator();
+        }
+        return null;
+      };
+      if (isLocalized) {
+        const localizedValue = {};
+        for (const locale of locales) {
+          localizedValue[locale] = await generateFieldValue();
+        }
+        record[field.name] = localizedValue;
+      } else {
+        record[field.name] = await generateFieldValue();
+      }
+    }
+  }
+  return record;
+}
+async function generateRecord(db, collection, locales = []) {
+  return generateDataForFields(collection.fields, db, locales);
+}
+function sortCollections(collections) {
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  const visit = (collection) => {
+    if (visited.has(collection.slug))
+      return;
+    if (visiting.has(collection.slug)) {
+      throw new Error(`Circular dependency detected: ${collection.slug}`);
+    }
+    visiting.add(collection.slug);
+    const deps = [];
+    const findDeps = (fields) => {
+      for (const f of fields) {
+        if (f.type === "relationship") {
+          deps.push(f.relationTo);
+        } else if (f.type === "blocks" && f.blocks) {
+          f.blocks.forEach((b) => findDeps(b.fields));
+        } else if ("fields" in f && f.fields) {
+          findDeps(f.fields);
+        } else if ("tabs" in f && f.tabs) {
+          f.tabs.forEach((t) => findDeps(t.fields));
+        }
+      }
+    };
+    findDeps(collection.fields);
+    for (const depSlug of deps) {
+      const depColl = collections.find((c) => c.slug === depSlug);
+      if (depColl)
+        visit(depColl);
+    }
+    visiting.delete(collection.slug);
+    visited.add(collection.slug);
+    sorted.push(collection);
+  };
+  for (const collection of collections) {
+    visit(collection);
+  }
+  return sorted;
+}
+async function autoSeed(config, countPerCollection = 10, reset = false, type = "all") {
+  const { collections, db, globals, storages, serverURL } = config;
+  console.log(`\uD83C\uDF31 Starting automatic seed (${countPerCollection} records per collection)...`);
+  const { getSystemCollections } = await import("./chunk-v521d72w.js");
+  const systemCollections = getSystemCollections().filter((c) => c.slug === "_opaca_assets");
+  const allCollections = [...systemCollections, ...collections];
+  let collectionsToSeed = sortCollections(allCollections);
+  if (type === "assets") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug === "_opaca_assets");
+    console.log("\uD83D\uDCC1 Seeding only assets...");
+  } else if (type === "collections") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug !== "_opaca_assets");
+    console.log("\uD83D\uDCDA Seeding only user collections...");
+  }
+  await db.connect();
+  await db.migrate(allCollections, globals || []);
+  try {
+    if (reset) {
+      console.log("\uD83E\uDDF9 Resetting data (deleting existing records)...");
+      const reversed = [...collectionsToSeed].reverse();
+      for (const collection of reversed) {
+        console.log(`Cleaning ${collection.slug}...`);
+        await db.deleteMany?.(collection.slug, {});
+      }
+    }
+    const storageAdapter = storages?.default || storages;
+    const locales = config.i18n?.locales || [];
+    for (const collection of collectionsToSeed) {
+      console.log(`Seeding ${collection.slug}...`);
+      const isAssetCollection = collection.slug === "_opaca_assets";
+      for (let i = 0;i < countPerCollection; i++) {
+        let data;
+        if (isAssetCollection) {
+          const id = faker.string.uuid();
+          const width = faker.number.int({ min: 400, max: 1200 });
+          const height = faker.number.int({ min: 300, max: 800 });
+          const color = faker.color.rgb({ prefix: "" });
+          const textColor = faker.color.rgb({ prefix: "" });
+          const usePicsum = Math.random() > 0.5;
+          let imageUrl = "";
+          if (usePicsum) {
+            const categories = ["nature", "city", "tech", "people", "animals", "architecture"];
+            const category = faker.helpers.arrayElement(categories);
+            imageUrl = `https://picsum.photos/seed/${category}-${id}/${width}/${height}`;
+          } else {
+            imageUrl = `https://placehold.co/${width}x${height}/${color}/${textColor}.png?text=Seed+${i}`;
+          }
+          const res = await fetch(imageUrl);
+          if (!res.ok) {
+            throw new Error(`Failed to fetch placeholder image: ${imageUrl}`);
+          }
+          const arrayBuffer = await res.arrayBuffer();
+          const mime_type = res.headers.get("content-type")?.split(";")[0] || "image/png";
+          const extMap = {
+            "image/jpeg": "jpg",
+            "image/png": "png",
+            "image/webp": "webp",
+            "image/gif": "gif",
+            "image/svg+xml": "svg"
+          };
+          const ext = extMap[mime_type] || "png";
+          const fileRecord = {
+            filename: `seed-image-${i}.${ext}`,
+            original_filename: `seed-image-${i}.${ext}`,
+            mime_type,
+            filesize: arrayBuffer.byteLength,
+            buffer: new Uint8Array(arrayBuffer)
+          };
+          if (!storageAdapter || typeof storageAdapter.upload !== "function") {
+            throw new Error("Storage adapter is required for seeding assets and must have an 'upload' method.");
+          }
+          const uploaded = await storageAdapter.upload(fileRecord, {
+            generateUniqueName: true,
+            customMetadata: {
+              sourceUrl: imageUrl
+            }
+          });
+          data = {
+            id,
+            key: uploaded.filename,
+            filename: uploaded.filename,
+            originalFilename: fileRecord.original_filename,
+            mimeType: uploaded.mime_type,
+            filesize: uploaded.filesize,
+            width,
+            height,
+            bucket: "default",
+            url: uploaded.url,
+            thumbnailUrl: uploaded.url,
+            altText: faker.lorem.sentence()
+          };
+          const baseURL = serverURL || "http://localhost:8787";
+          console.log(`[Asset] Source: ${imageUrl}`);
+          console.log(`[Asset] Seeded: ${baseURL}/api/assets/${id}/view (${uploaded.filename})`);
+        } else {
+          data = await generateRecord(db, collection, locales);
+        }
+        await db.create(collection.slug, data);
+      }
+    }
+    console.log("✅ Seeding completed.");
+  } finally {
+    await db.disconnect();
+  }
+}
+export {
+  sortCollections,
+  generateRecord,
+  defaultFieldGenerators,
+  autoSeed
+};

package/dist/chunk-8sqjbsgt.js

@@ -0,0 +1,42 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toCommonJS, __export, __esm, __require };

package/dist/chunk-9kxpbcb1.js

@@ -0,0 +1,85 @@
+import"./chunk-8sqjbsgt.js";
+
+// src/cli/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...`);
+      }
+    }
+  }
+  const absolutePath = path.isAbsolute(dbPath) ? dbPath : path.resolve(process.cwd(), dbPath);
+  const dir = path.dirname(absolutePath);
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const sqlite = new Database(absolutePath);
+    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-cvdd4eqh.js

@@ -0,0 +1,110 @@
+// src/db/kysely/field-mapper.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function mapFieldToPostgresType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+      return "text";
+    case "number":
+      return "double precision";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "timestamp with time zone";
+    case "json":
+    case "file":
+      return "jsonb";
+    default:
+      return "text";
+  }
+}
+function mapFieldToSQLiteType(field) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "select":
+    case "radio":
+    case "relationship":
+    case "date":
+    case "json":
+    case "file":
+      return "text";
+    case "number":
+      return "numeric";
+    case "boolean":
+      return "integer";
+    default:
+      return "text";
+  }
+}
+function flattenFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "join" || field.type === "virtual")
+      continue;
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "group") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = currentName ? `${currentName}__` : "";
+        result.push(...flattenFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "blocks") {
+      continue;
+    }
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+      continue;
+    }
+    if (currentName) {
+      result.push({ ...field, name: currentName });
+    }
+    if (field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        result.push(...flattenFields(field.fields, prefix));
+      }
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...flattenFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+function getRelationalFields(fields, prefix = "") {
+  const result = [];
+  for (const field of fields) {
+    const currentName = field.name ? `${prefix}${field.name}` : undefined;
+    if (field.type === "relationship" && "hasMany" in field && field.hasMany || field.type === "blocks") {
+      if (currentName) {
+        result.push({ ...field, name: currentName });
+      }
+      continue;
+    }
+    if (field.type === "group" || field.type === "row" || field.type === "collapsible") {
+      if (field.fields && Array.isArray(field.fields)) {
+        const nextPrefix = field.type === "group" && field.name ? `${currentName}__` : prefix;
+        result.push(...getRelationalFields(field.fields, nextPrefix));
+      }
+      continue;
+    }
+    if (field.type === "tabs" && field.tabs && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        if (tab.fields && Array.isArray(tab.fields)) {
+          result.push(...getRelationalFields(tab.fields, prefix));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+export { toSnakeCase, mapFieldToPostgresType, mapFieldToSQLiteType, flattenFields, getRelationalFields };

package/dist/chunk-d3ffeqp9.js

@@ -0,0 +1,87 @@
+// src/client.ts
+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(/\/$/, "");
+  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 client = {
+    getMetadata: () => fetcher("/api/__admin/metadata"),
+    getCollections: () => fetcher("/api/__admin/collections"),
+    getSetupStatus: () => fetcher("/api/__admin/setup"),
+    collections: new Proxy({}, {
+      get(_, collectionSlug) {
+        return {
+          find: (query) => {
+            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: (id) => fetcher(`/api/${String(collectionSlug)}/${id}`),
+          list: () => fetcher(`/api/${String(collectionSlug)}`),
+          create: (data) => fetcher(`/api/${String(collectionSlug)}`, {
+            method: "POST",
+            body: JSON.stringify(data)
+          }),
+          update: (id, data) => fetcher(`/api/${String(collectionSlug)}/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+          }),
+          delete: (id) => fetcher(`/api/${String(collectionSlug)}/${id}`, {
+            method: "DELETE"
+          })
+        };
+      }
+    }),
+    globals: new Proxy({}, {
+      get(_, globalSlug) {
+        return {
+          get: () => fetcher(`/api/globals/${String(globalSlug)}`),
+          update: (data) => fetcher(`/api/globals/${String(globalSlug)}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+          })
+        };
+      }
+    })
+  };
+  return client;
+}
+
+export { OpacaError, createClient };