opacacms 0.1.0

package/src/cli/r2-mock.ts

@@ -0,0 +1,217 @@
+import { Database } from "bun:sqlite";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * A minimal R2Bucket mock for OpacaCMS CLI that uses Wrangler's local state.
+ * Stores metadata in _mf_objects table and blobs in .blobs sibling directory.
+ */
+export function createR2Mock(dbPath?: string) {
+  let sqlite: Database;
+  let blobsDir: string;
+  let finalDbPath: string | undefined;
+
+  // 1. Try to find Wrangler's local R2 state if no path provided
+  const wranglerR2Dir = path.resolve(
+    process.cwd(),
+    ".wrangler/state/v3/r2/miniflare-R2BucketObject",
+  );
+
+  if (!dbPath && fs.existsSync(wranglerR2Dir)) {
+    const files = fs.readdirSync(wranglerR2Dir);
+    const sqliteFile = files.find((f) => f.endsWith(".sqlite"));
+    if (sqliteFile) {
+      finalDbPath = path.join(wranglerR2Dir, sqliteFile);
+      console.log(`[OpacaCMS] Using Wrangler R2 local state: ${sqliteFile}`);
+    }
+  }
+
+  // 2. Handle specific path or fallback
+  if (!finalDbPath) {
+    const inputPath = dbPath || ".opaca/local-r2/mock-bucket.sqlite";
+    const absolutePath = path.isAbsolute(inputPath)
+      ? inputPath
+      : path.resolve(process.cwd(), inputPath);
+
+    // If it's a directory, append default filename
+    if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+      finalDbPath = path.join(absolutePath, "mock-bucket.sqlite");
+    } else if (!absolutePath.endsWith(".sqlite")) {
+      finalDbPath = absolutePath.endsWith("/")
+        ? path.join(absolutePath, "mock-bucket.sqlite")
+        : absolutePath + ".sqlite";
+    } else {
+      finalDbPath = absolutePath;
+    }
+    console.log(`[OpacaCMS] Using local R2 mock: ${path.basename(finalDbPath)}`);
+  }
+
+  // Ensure directory exists
+  const dir = path.dirname(finalDbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  try {
+    sqlite = new Database(finalDbPath);
+  } catch (err: any) {
+    throw new Error(`Failed to open R2 mock database at ${finalDbPath}: ${err.message}`);
+  }
+
+  blobsDir = finalDbPath.replace(".sqlite", ".blobs");
+  if (!fs.existsSync(blobsDir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(blobsDir, { recursive: true });
+  }
+
+  // Ensure table exists (miniflare 3 schema)
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS _mf_objects (
+      key TEXT PRIMARY KEY,
+      blob_id TEXT,
+      version TEXT,
+      size INTEGER,
+      etag TEXT,
+      uploaded INTEGER,
+      checksums TEXT,
+      http_metadata TEXT,
+      custom_metadata TEXT
+    )
+  `);
+
+  const getBlobPath = (blobId: string) => path.join(blobsDir, blobId);
+
+  return {
+    async put(key: string, value: any, options?: any) {
+      const blobId = crypto.randomUUID();
+      const filePath = getBlobPath(blobId);
+
+      const buffer =
+        value instanceof Uint8Array
+          ? value
+          : value instanceof ArrayBuffer
+            ? new Uint8Array(value)
+            : typeof value === "string" || value instanceof Buffer
+              ? Buffer.from(value)
+              : new Uint8Array(await (value as any).arrayBuffer());
+
+      fs.writeFileSync(filePath, buffer);
+
+      // MD5 for ETag (standard for R2/Miniflare)
+      const etag = crypto.createHash("md5").update(buffer).digest("hex");
+
+      // Miniflare 3 internal SQLite state often use MILLIS for 'uploaded'
+      // despite the R2 API returning seconds. Let's use MILLIS.
+      const uploaded = Date.now();
+      const size = buffer.length;
+
+      // Ensure we use the exact keys expected by Workerd/Miniflare
+      const httpMetadataObj: Record<string, string> = {};
+      if (options?.httpMetadata?.contentType) {
+        httpMetadataObj.contentType = options.httpMetadata.contentType;
+      }
+
+      const customMetadataObj: Record<string, string> = { ...options?.customMetadata };
+      if (options?.customMetadata?.sourceUrl) {
+        customMetadataObj.sourceUrl = options.customMetadata.sourceUrl;
+      }
+
+      const httpMetadata = JSON.stringify(httpMetadataObj);
+      const customMetadata = JSON.stringify(customMetadataObj);
+
+      sqlite
+        .prepare(`
+        INSERT OR REPLACE INTO _mf_objects 
+        (key, blob_id, version, size, etag, uploaded, checksums, http_metadata, custom_metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+        .run(key, blobId, "v1", size, etag, uploaded, "{}", httpMetadata, customMetadata);
+
+      return {
+        key,
+        size,
+        etag,
+        httpMetadata: options?.httpMetadata || {},
+        customMetadata: options?.customMetadata || {},
+      };
+    },
+
+    async get(key: string) {
+      const row = sqlite.prepare("SELECT * FROM _mf_objects WHERE key = ?").get(key) as any;
+      if (!row) return null;
+
+      const filePath = getBlobPath(row.blob_id);
+      if (!fs.existsSync(filePath)) return null;
+
+      const buffer = fs.readFileSync(filePath);
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new Uint8Array(buffer));
+          controller.close();
+        },
+      });
+
+      return {
+        key: row.key,
+        size: row.size,
+        etag: row.etag,
+        uploaded: new Date(row.uploaded), // Works with both s and ms
+        httpMetadata: JSON.parse(row.http_metadata || "{}"),
+        customMetadata: JSON.parse(row.custom_metadata || "{}"),
+        body: stream,
+        bodyUsed: false,
+        async arrayBuffer() {
+          return buffer.buffer;
+        },
+        async text() {
+          return buffer.toString();
+        },
+        async json() {
+          return JSON.parse(buffer.toString());
+        },
+      };
+    },
+
+    async head(key: string) {
+      const row = sqlite
+        .prepare(
+          "SELECT key, size, etag, http_metadata, custom_metadata, uploaded FROM _mf_objects WHERE key = ?",
+        )
+        .get(key) as any;
+      if (!row) return null;
+      return {
+        key: row.key,
+        size: row.size,
+        etag: row.etag,
+        uploaded: new Date(row.uploaded),
+        httpMetadata: JSON.parse(row.http_metadata || "{}"),
+        customMetadata: JSON.parse(row.custom_metadata || "{}"),
+      };
+    },
+
+    async delete(key: string) {
+      const row = sqlite.prepare("SELECT blob_id FROM _mf_objects WHERE key = ?").get(key) as any;
+      if (row) {
+        const filePath = getBlobPath(row.blob_id);
+        if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+        sqlite.prepare("DELETE FROM _mf_objects WHERE key = ?").run(key);
+      }
+    },
+
+    async list() {
+      const rows = sqlite.prepare("SELECT * FROM _mf_objects").all() as any[];
+      return {
+        objects: rows.map((row) => ({
+          key: row.key,
+          size: row.size,
+          etag: row.etag,
+          uploaded: new Date(row.uploaded),
+          httpMetadata: JSON.parse(row.http_metadata || "{}"),
+          customMetadata: JSON.parse(row.custom_metadata || "{}"),
+        })),
+        truncated: false,
+      };
+    },
+  };
+}

package/src/cli/seeding.ts

@@ -0,0 +1,405 @@
+import { faker } from "@faker-js/faker";
+import type { Collection, DatabaseAdapter, Field, OpacaConfig } from "../types";
+
+/**
+ * Default generators for each field type.
+ */
+export const defaultFieldGenerators: Record<string, () => any> = {
+  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(),
+  // Add block generator template
+  blocks: () => [],
+};
+
+async function getRandomIds(
+  db: DatabaseAdapter,
+  relationTo: string,
+  count: number = 1,
+): Promise<any[]> {
+  try {
+    const result = await db.find(relationTo, {}, { limit: 50 });
+    const docs = result.docs || [];
+
+    if (docs.length === 0) {
+      // Don't log for system collections or if it's expected
+      if (!relationTo.startsWith("_")) {
+        console.warn(`[Seeding] No documents found in '${relationTo}' for relationship.`);
+      }
+      return [];
+    }
+
+    // Shuffle and pick
+    const shuffled = [...docs].sort(() => 0.5 - Math.random());
+    const selected = shuffled.slice(0, count).map((doc) => (doc as any).id);
+    return selected;
+  } catch (e) {
+    console.error(`[Seeding] Failed to fetch random IDs for ${relationTo}:`, e);
+    return [];
+  }
+}
+
+/**
+ * Resolves a relationship by picking a random ID from the target collection.
+ */
+
+/**
+ * Generates data for a list of fields, recursively handling groups and layouts.
+ */
+async function generateDataForFields(
+  fields: Field[],
+  db: DatabaseAdapter,
+  locales: string[] = [],
+): Promise<Record<string, any>> {
+  const record: Record<string, any> = {};
+
+  for (const field of fields) {
+    // 1. Handle Layout Fields (Recursive)
+    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;
+    }
+
+    // 2. Handle Group (Nested)
+    if (field.type === "group" && field.name) {
+      record[field.name] = await generateDataForFields(field.fields, db, locales);
+      continue;
+    }
+
+    // 3. Handle Normal Fields with name
+    if (field.name) {
+      const isLocalized = !!(field as any).localized && locales.length > 0;
+
+      const generateFieldValue = async () => {
+        // Handle Relationships
+        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;
+        }
+
+        // Handle Blocks
+        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;
+        }
+
+        // Default Generators
+        const generator = defaultFieldGenerators[field.type];
+        if (generator) {
+          if (field.type === "select" || field.type === "radio") {
+            const options = (field as any).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: Record<string, any> = {};
+        for (const locale of locales) {
+          localizedValue[locale] = await generateFieldValue();
+        }
+        record[field.name] = localizedValue;
+      } else {
+        record[field.name] = await generateFieldValue();
+      }
+    }
+  }
+
+  return record;
+}
+
+/**
+ * Generates a single record for a collection.
+ */
+export async function generateRecord(db: DatabaseAdapter, collection: Collection, locales: string[] = []) {
+  return generateDataForFields(collection.fields as Field[], db, locales);
+}
+
+/**
+ * Topologically sorts collections based on their dependencies.
+ */
+export function sortCollections(collections: Collection[]): Collection[] {
+  const sorted: Collection[] = [];
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+
+  const visit = (collection: Collection) => {
+    if (visited.has(collection.slug)) return;
+    if (visiting.has(collection.slug)) {
+      throw new Error(`Circular dependency detected: ${collection.slug}`);
+    }
+
+    visiting.add(collection.slug);
+
+    // Implicit dependencies from relationships
+    const deps: string[] = [];
+
+    // Recursive search for relationships
+    const findDeps = (fields: Field[]) => {
+      for (const f of fields) {
+        if (f.type === "relationship") {
+          deps.push((f as any).relationTo);
+        } else if (f.type === "blocks" && f.blocks) {
+          f.blocks.forEach((b) => findDeps(b.fields as Field[]));
+        } else if ("fields" in f && f.fields) {
+          findDeps(f.fields as Field[]);
+        } else if ("tabs" in f && f.tabs) {
+          f.tabs.forEach((t) => findDeps(t.fields as Field[]));
+        }
+      }
+    };
+    findDeps(collection.fields as Field[]);
+
+    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;
+}
+
+/**
+ * Seeds the database with mock data.
+ */
+export async function autoSeed(
+  config: OpacaConfig,
+  countPerCollection = 10,
+  reset = false,
+  type: "collections" | "assets" | "all" = "all",
+) {
+  const { collections, db, globals, storages, serverURL } = config;
+
+  console.log(`🌱 Starting automatic seed (${countPerCollection} records per collection)...`);
+
+  // Include system collections (like _opaca_assets)
+  const { getSystemCollections } = await import("../db/system-schema.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("📁 Seeding only assets...");
+  } else if (type === "collections") {
+    collectionsToSeed = collectionsToSeed.filter((c) => c.slug !== "_opaca_assets");
+    console.log("📚 Seeding only user collections...");
+  }
+
+  // Connect and ensure adapter knows the schema (pass ALL collections for proper whitelisting)
+  await db.connect();
+  await db.migrate(allCollections, globals || []);
+
+  try {
+    if (reset) {
+      console.log("🧹 Resetting data (deleting existing records)...");
+      // Delete in reverse order to respect foreign key constraints if any
+      const reversed = [...collectionsToSeed].reverse();
+      for (const collection of reversed) {
+        console.log(`Cleaning ${collection.slug}...`);
+        await db.deleteMany?.(collection.slug, {});
+      }
+    }
+
+    const storageAdapter = (storages as any)?.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: any;
+
+        if (isAssetCollection) {
+          // ... (asset logic remains the same)
+          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: "" });
+
+          // Randomize between Picsum and Placehold.co
+          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}`;
+          }
+
+          // 1. Fetch real image
+          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: Record<string, string> = {
+            "image/jpeg": "jpg",
+            "image/png": "png",
+            "image/webp": "webp",
+            "image/gif": "gif",
+            "image/svg+xml": "svg",
+          };
+
+          const ext = extMap[mime_type] || "png";
+
+          // 2. Build FileRecord
+          const fileRecord = {
+            filename: `seed-image-${i}.${ext}`,
+            original_filename: `seed-image-${i}.${ext}`,
+            mime_type,
+            filesize: arrayBuffer.byteLength,
+            buffer: new Uint8Array(arrayBuffer),
+          };
+
+          // 3. Upload via adapter
+          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,
+            },
+          });
+
+          // 4. Persist metadata real
+          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, // (placeholder)
+            altText: faker.lorem.sentence(),
+          };
+
+          // LOG THE FULL URL
+          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();
+  }
+}