opacacms 0.1.1 → 0.1.2

package/test/populate.test.ts

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

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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-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 {},
-  };
-});