opacacms 0.1.11 → 0.1.13

package/src/cli/r2-mock.ts

@@ -1,217 +0,0 @@
-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

@@ -1,409 +0,0 @@
-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) {
-          for (const b of f.blocks) {
-            findDeps(b.fields as Field[]);
-          }
-        } else if ("fields" in f && f.fields) {
-          findDeps(f.fields as Field[]);
-        } else if ("tabs" in f && f.tabs) {
-          for (const t of f.tabs) {
-            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 {
-    // Keep connection alive for potential reuse in tests
-  }
-}