opacacms 0.1.0

package/test/populate.test.ts

@@ -0,0 +1,79 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { Hono } from "hono";
+import { defineConfig } from "../src/config";
+import { createBunSQLiteAdapter } from "../src/db/bun-sqlite";
+import { createAPIRouter } from "../src/server/router";
+
+let app: Hono;
+const dbPath = ":memory:";
+const db = createBunSQLiteAdapter(dbPath, { push: true });
+
+beforeAll(async () => {
+  const config = defineConfig({
+    db,
+    collections: [
+      {
+        slug: "authors",
+        fields: [{ name: "name", type: "text" }],
+      },
+      {
+        slug: "posts",
+        fields: [
+          { name: "title", type: "text" },
+          { name: "authorId", type: "relationship", relationTo: "authors" },
+        ],
+      },
+    ],
+  });
+
+  app = new Hono();
+  app.route("/", createAPIRouter(config));
+
+  await db.connect();
+});
+
+afterAll(async () => {
+  await db.disconnect();
+});
+
+test("POST /api/authors - create author", async () => {
+  const res = await app.request("/api/authors", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name: "Jane Doe" }),
+  });
+  expect(res.status).toBe(201);
+  const data = (await res.json()) as any;
+  expect(data.id).toBeDefined();
+  // store id for next test
+  process.env.TEST_AUTHOR_ID = data.id.toString();
+});
+
+test("POST /api/posts - create post with authorId", async () => {
+  const authorId = process.env.TEST_AUTHOR_ID;
+  const res = await app.request("/api/posts", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title: "Hello World", authorId }),
+  });
+  expect(res.status).toBe(201);
+  const data = (await res.json()) as any;
+  expect(data.authorId).toBe(authorId);
+  process.env.TEST_POST_ID = data.id.toString();
+});
+
+test("GET /api/posts/:id?populate=authorId - retrieves populated data", async () => {
+  const postId = process.env.TEST_POST_ID;
+  const res = await app.request(`/api/posts/${postId}?populate=authorId`);
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as any;
+  expect(data.authorId).toBeObject();
+  expect(data.authorId.name).toBe("Jane Doe");
+});
+
+test("GET /api/posts - handles populate for multiple docs", async () => {
+  const res = await app.request(`/api/posts?populate=authorId`);
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as any;
+  expect(data.docs[0].authorId.name).toBe("Jane Doe");
+});

package/test/runtimes.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { createBunSQLiteAdapter } from "../src/db/bun-sqlite";
+import { createBunHandler } from "../src/runtimes/bun";
+import { createCloudflareWorkersHandler } from "../src/runtimes/cloudflare-workers";
+import { createNextHandler } from "../src/runtimes/next";
+import { createNodeHandler } from "../src/runtimes/node";
+import type { OpacaConfig } from "../src/types";
+
+describe("Runtimes", () => {
+  const mockConfig: OpacaConfig = {
+    db: createBunSQLiteAdapter(":memory:"),
+    collections: [],
+  };
+
+  test("Next.js handler should export proper HTTP methods", () => {
+    const handler = createNextHandler(mockConfig);
+    expect(handler.GET).toBeDefined();
+    expect(handler.POST).toBeDefined();
+    expect(handler.PUT).toBeDefined();
+    expect(handler.DELETE).toBeDefined();
+    expect(handler.PATCH).toBeDefined();
+    expect(handler.OPTIONS).toBeDefined();
+    expect(typeof handler.GET).toBe("function");
+  });
+
+  test("Bun handler should expose app and init function", () => {
+    const handler = createBunHandler(mockConfig);
+    expect(handler.app).toBeDefined();
+    expect(typeof handler.init).toBe("function");
+  });
+
+  test("Node handler should expose app and init function", () => {
+    const handler = createNodeHandler(mockConfig);
+    expect(handler.app).toBeDefined();
+    expect(typeof handler.init).toBe("function");
+  });
+
+  test("Cloudflare Workers handler should expose a fetch method", () => {
+    const handler = createCloudflareWorkersHandler(mockConfig);
+    expect(handler.fetch).toBeDefined();
+    expect(typeof handler.fetch).toBe("function");
+  });
+});

package/test/schema-builder.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { Collection, Field } from "../src/schema";
+
+describe("Fluent API Schema Builder", () => {
+  test("Should build a valid OpacaCMS Collection object matching perfectly with legacy JSON", () => {
+    const builder = Collection.create("posts")
+      .label("Blog Posts")
+      .useAsTitle("title")
+      .timestamps(true)
+      .fields([
+        Field.text("title").required().description("The post title"),
+        Field.richText("content").mode("notion"),
+        Field.relationship("author").to("users").single(),
+      ])
+      .access({
+        read: () => true,
+        update: ({ data }) => {
+          // Type Test: Ensure 'data' has inferred types.
+          // Because of TypeScript generics, data.title, data.content, data.author should be recognized.
+          // Hovering over 'data' in an IDE would show: { title: string; content: any; author: string | string[] }
+          const _title: string = data.title;
+          const _auth: string | string[] = data.author;
+
+          return true;
+        },
+      });
+
+    const schema = builder.build();
+
+    expect(schema).toEqual({
+      slug: "posts",
+      label: "Blog Posts",
+      timestamps: true,
+      admin: {
+        useAsTitle: "title",
+      },
+      fields: [
+        {
+          type: "text",
+          name: "title",
+          required: true,
+          admin: { description: "The post title" },
+        },
+        {
+          type: "richtext",
+          name: "content",
+          options: { defaultMode: "notion" },
+        },
+        {
+          type: "relationship",
+          name: "author",
+          relationTo: "users",
+          hasMany: false,
+        },
+      ],
+      access: expect.any(Object), // Access object is present containing the functions
+    });
+  });
+
+  test("Should build complex nested fields (Array, Group, Blocks)", () => {
+    const builder = Collection.create("settings").fields([
+      Field.group("contact").fields(Field.text("email").required(), Field.text("phone")),
+      Field.array("links").of(Field.row().fields(Field.text("label"), Field.text("url"))),
+      Field.blocks("layout").blocks(
+        Field.block("hero").label("Hero Section").fields(Field.text("headline")),
+      ),
+    ]);
+
+    const schema = builder.build();
+
+    expect(schema.fields).toEqual([
+      {
+        type: "group",
+        name: "contact",
+        fields: [
+          { type: "text", name: "email", required: true },
+          { type: "text", name: "phone" },
+        ],
+      },
+      {
+        type: "array",
+        name: "links",
+        fields: [
+          {
+            type: "row",
+            name: "",
+            fields: [
+              { type: "text", name: "label" },
+              { type: "text", name: "url" },
+            ],
+          },
+        ],
+      },
+      {
+        type: "blocks",
+        name: "layout",
+        blocks: [
+          {
+            slug: "hero",
+            label: "Hero Section",
+            fields: [{ type: "text", name: "headline" }],
+          },
+        ],
+      },
+    ]);
+  });
+});

package/test/schema-features.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { Collection, Field } from "../src/schema";
+
+describe("Fluent API Schema Features", () => {
+  test("Should support Slug fields correctly", () => {
+    const posts = Collection.create("posts")
+      .fields([Field.text("title"), Field.slug("slug").from("title").unique()])
+      .build();
+
+    expect(posts.slug).toBe("posts");
+    expect(posts.fields).toHaveLength(2);
+    expect(posts.fields[1]!.type).toBe("slug");
+    expect((posts.fields[1] as any).from).toBe("title");
+    expect(posts.fields[1]!.unique).toBe(true);
+  });
+
+  test("Should support field localization", () => {
+    const pages = Collection.create("pages")
+      .fields([Field.text("title").localized()])
+      .build();
+
+    expect(pages.fields[0]!.localized).toBe(true);
+  });
+
+  test("Should support versions and drafts", () => {
+    const pages = Collection.create("pages")
+      .versions({ drafts: true, maxRevisions: 10, autosave: true })
+      .build();
+
+    expect(pages.versions).toBeDefined();
+    expect(pages.versions!.drafts).toBe(true);
+    expect(pages.versions!.maxRevisions).toBe(10);
+  });
+
+  test("Should support webhooks", () => {
+    const subs = Collection.create("subscribers")
+      .webhooks([
+        {
+          events: ["afterCreate"],
+          url: "https://example.com/webhook",
+        },
+      ])
+      .build();
+
+    expect(subs.webhooks).toBeDefined();
+    expect(subs.webhooks![0]!.events).toContain("afterCreate");
+    expect(subs.webhooks![0]!.url).toBe("https://example.com/webhook");
+  });
+
+  test("Should support admin UI views and bulk actions", () => {
+    const orders = Collection.create("orders")
+      .admin({
+        views: [{ name: "Pending", filter: { status: "pending" } }],
+        bulkActions: [{ label: "Approve", action: async () => true }],
+      })
+      .build();
+
+    expect(orders.admin).toBeDefined();
+    expect((orders.admin as any).views).toBeDefined();
+    expect((orders.admin as any).views![0]!.name).toBe("Pending");
+    expect((orders.admin as any).bulkActions).toBeDefined();
+  });
+});

package/test/seeding.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import { generateRecord, sortCollections } from "../src/cli/seeding";
+import { createBunSQLiteAdapter } from "../src/db/bun-sqlite";
+import type { Collection, DatabaseAdapter } from "../src/types";
+
+describe("Seeding Logic", () => {
+  const mockDb = {
+    find: async () => ({ docs: [{ id: "123" }], totalDocs: 1 }),
+    create: async () => ({ id: "456" }),
+  } as unknown as DatabaseAdapter;
+
+  const collections: Collection[] = [
+    {
+      slug: "users",
+      fields: [
+        { name: "name", type: "text" },
+        { name: "email", type: "text" },
+      ],
+    },
+    {
+      slug: "posts",
+      fields: [
+        { name: "title", type: "text" },
+        { name: "author", type: "relationship", relationTo: "users" },
+      ],
+    },
+  ];
+
+  test("sortCollections handles dependencies", () => {
+    const sorted = sortCollections(collections);
+    const userIndex = sorted.findIndex((c) => c.slug === "users");
+    const postIndex = sorted.findIndex((c) => c.slug === "posts");
+    expect(userIndex).toBeLessThan(postIndex);
+  });
+
+  test("generateRecord creates mock data", async () => {
+    const userRecord = await generateRecord(mockDb, collections[0]!);
+    expect(userRecord.name).toBeString();
+    expect(userRecord.email).toBeString();
+  });
+
+  test("generateRecord handles relationships", async () => {
+    const postRecord = await generateRecord(mockDb, collections[1]!);
+    expect(postRecord.title).toBeString();
+    expect(postRecord.author).toBe("123");
+  });
+
+  test("integrates with real database", async () => {
+    const db = createBunSQLiteAdapter(":memory:", { push: true });
+    await db.connect();
+
+    try {
+      // Create tables
+      await db.unsafe("CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT, email TEXT)");
+      await db.migrate(collections as Collection[]);
+
+      const record = await generateRecord(db, collections[0]!);
+      const created = (await db.create("users", record)) as any;
+
+      expect(created.name).toBe(record.name);
+
+      const found = await db.find("users");
+      expect(found.docs.length).toBe(1);
+    } finally {
+      await db.disconnect();
+    }
+  });
+});

package/test/storage/local.test.ts

@@ -0,0 +1,72 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createLocalAdapter } from "../../src/storage/adapters/local";
+import { FileTooLargeError, Invalidmime_typeError } from "../../src/storage/errors";
+
+const TEST_DIR = path.resolve(process.cwd(), ".test_uploads");
+
+describe("Local Storage Adapter", () => {
+  const adapter = createLocalAdapter({
+    uploadDir: TEST_DIR,
+    publicUrl: "/media",
+  });
+
+  const mockBuffer = Buffer.from("fake image data");
+  const mockFile = {
+    filename: "test-image.jpg",
+    original_filename: "test-image.jpg",
+    mime_type: "image/jpeg",
+    filesize: mockBuffer.length,
+    buffer: mockBuffer,
+  };
+
+  beforeAll(async () => {
+    await fs.mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  test("successfully writes a file to disk and returns correct URL", async () => {
+    const result = await adapter.upload(mockFile);
+
+    expect(result.filename).toBe("test-image.jpg");
+    expect(result.url).toBe("/media/test-image.jpg");
+
+    const fileExists = await adapter.exists!("test-image.jpg");
+    expect(fileExists).toBe(true);
+
+    const content = await fs.readFile(path.join(TEST_DIR, "test-image.jpg"));
+    expect(content.toString()).toBe("fake image data");
+  });
+
+  test("successfully deletes a file from disk", async () => {
+    await adapter.upload({ ...mockFile, filename: "to-delete.png" });
+    expect(await adapter.exists!("to-delete.png")).toBe(true);
+
+    await adapter.delete("to-delete.png");
+
+    expect(await adapter.exists!("to-delete.png")).toBe(false);
+  });
+
+  test("generates unique filenames to prevent collisions", async () => {
+    const options = { generateUniqueName: true };
+    const result1 = await adapter.upload(mockFile, options);
+    const result2 = await adapter.upload(mockFile, options);
+
+    expect(result1.filename).not.toBe(result2.filename);
+    expect(result1.filename).toMatch(/^test-image-[a-z0-9-]+\.jpg$/);
+  });
+
+  test("enforces maxFileSize limit", async () => {
+    const options = { maxFileSize: 5 }; // Very small limit
+    expect(adapter.upload(mockFile, options)).rejects.toBeInstanceOf(FileTooLargeError);
+  });
+
+  test("enforces mime_type limit", async () => {
+    const options = { allowedmime_types: ["image/png"] };
+    expect(adapter.upload(mockFile, options)).rejects.toBeInstanceOf(Invalidmime_typeError);
+  });
+});

package/test/storage/s3.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, mock, test } from "bun:test";
+import { createS3Adapter } from "../../src/storage/adapters/s3";
+import { FileTooLargeError, Invalidmime_typeError } from "../../src/storage/errors";
+
+// Mock the AWS SDK
+mock.module("@aws-sdk/client-s3", () => {
+  return {
+    S3Client: mock().mockImplementation(() => ({
+      send: mock().mockResolvedValue({}), // Simulate a successful HTTP response
+    })),
+    PutObjectCommand: mock(),
+    DeleteObjectCommand: mock(),
+    GetObjectCommand: mock(),
+    HeadObjectCommand: mock(),
+  };
+});
+
+describe("S3 Storage Adapter", () => {
+  const config = {
+    region: "us-east-1",
+    bucket: "test-bucket",
+    credentials: { accessKeyId: "test", secretAccessKey: "test" },
+  };
+  const adapter = createS3Adapter(config);
+
+  const mockFile = {
+    filename: "test.jpg",
+    original_filename: "test.jpg",
+    mime_type: "image/jpeg",
+    filesize: 1024,
+    buffer: Buffer.from("fake image data"),
+  };
+
+  test("throws FileTooLargeError if file exceeds maxFileSize limit", async () => {
+    const options = { maxFileSize: 500 }; // Limit is 500 bytes
+    expect(adapter.upload(mockFile, options)).rejects.toBeInstanceOf(FileTooLargeError);
+  });
+
+  test("throws Invalidmime_typeError if mime type is not allowed", async () => {
+    const options = { allowedmime_types: ["image/png"] }; // Only allow PNG
+    expect(adapter.upload(mockFile, options)).rejects.toBeInstanceOf(Invalidmime_typeError);
+  });
+
+  test("generates a unique filename if generateUniqueName is true", async () => {
+    const options = { generateUniqueName: true };
+    const result = await adapter.upload(mockFile, options);
+
+    expect(result.filename).not.toBe("test.jpg");
+    expect(result.filename).toMatch(/^test-[a-z0-9-]+\.jpg$/);
+  });
+
+  test("applies the prefix correctly to the generated URL", async () => {
+    const prefixedAdapter = createS3Adapter({ ...config, prefix: "uploads/images" });
+    const result = await prefixedAdapter.upload(mockFile);
+
+    expect(result.url).toBe(
+      "https://test-bucket.s3.us-east-1.amazonaws.com/uploads/images/test.jpg",
+    );
+  });
+});

package/test/structural-data.test.ts

@@ -0,0 +1,100 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { BunSQLiteAdapter } from "../src/db/bun-sqlite";
+import type { Collection } from "../src/types";
+
+describe("BunSQLiteAdapter Structural Data", () => {
+  let db: BunSQLiteAdapter;
+
+  const complexCollection: Collection = {
+    slug: "complex_docs",
+    fields: [
+      { name: "title", type: "text" },
+      {
+        name: "seo",
+        type: "group",
+        fields: [
+          { name: "title", type: "text" },
+          { name: "desc", type: "text" },
+        ],
+      },
+      {
+        name: "contentBlocks",
+        type: "blocks",
+        blocks: [
+          {
+            slug: "hero",
+            fields: [{ name: "headline", type: "text" }],
+          },
+          {
+            slug: "text",
+            fields: [{ name: "body", type: "text" }],
+          },
+        ],
+      },
+    ],
+  };
+
+  beforeAll(async () => {
+    db = new BunSQLiteAdapter(":memory:", { push: true });
+    await db.connect();
+    await db.migrate([complexCollection]);
+  });
+
+  afterAll(async () => {
+    await db.disconnect();
+  });
+
+  it("should create and retrieve a document with group fields and nested blocks properly", async () => {
+    const data = {
+      title: "Main Title",
+      seo: { title: "SEO Title", desc: "SEO Desc" },
+      contentBlocks: [
+        { blockType: "hero", headline: "Welcome" },
+        { blockType: "text", body: "Some body text" },
+      ],
+    };
+
+    const created = await db.create("complex_docs", data);
+
+    expect(created).toBeDefined();
+    expect((created as any).title).toBe("Main Title");
+    expect((created as any).seo).toEqual({ title: "SEO Title", desc: "SEO Desc" });
+    expect((created as any).contentBlocks).toHaveLength(2);
+    expect((created as any).contentBlocks[0].blockType).toBe("hero");
+    expect((created as any).contentBlocks[0].headline).toBe("Welcome");
+
+    const found = await db.findOne("complex_docs", { id: (created as any).id });
+    expect((found as any).seo).toEqual({ title: "SEO Title", desc: "SEO Desc" });
+    expect((found as any).contentBlocks).toHaveLength(2);
+  });
+
+  it("should update a document with group fields and nested blocks properly", async () => {
+    const created = await db.create("complex_docs", {
+      title: "Old Title",
+      seo: { title: "Old SEO", desc: "Old Desc" },
+      contentBlocks: [{ blockType: "text", body: "Old text" }],
+    });
+
+    const updated = await db.update(
+      "complex_docs",
+      { id: (created as any).id },
+      {
+        title: "New Title",
+        seo: { title: "New SEO", desc: "New Desc" },
+        contentBlocks: [
+          { blockType: "hero", headline: "New Hero" },
+          { blockType: "text", body: "New Text" },
+        ],
+      },
+    );
+
+    expect((updated as any).title).toBe("New Title");
+    expect((updated as any).seo.title).toBe("New SEO");
+    expect((updated as any).contentBlocks).toHaveLength(2);
+    expect((updated as any).contentBlocks[0].blockType).toBe("hero");
+
+    const found = await db.findOne("complex_docs", { id: (created as any).id });
+    expect((found as any).seo).toEqual({ title: "New SEO", desc: "New Desc" });
+    expect((found as any).contentBlocks).toHaveLength(2);
+  });
+});

package/test/test-setup.ts

@@ -0,0 +1,11 @@
+import { mock } from "bun:test";
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+
+GlobalRegistrator.register();
+
+// Mock Cloudflare workers for tests so @hono-rate-limiter/cloudflare doesn't crash
+mock.module("cloudflare:workers", () => {
+  return {
+    DurableObject: class {},
+  };
+});