opacacms 0.1.0

package/test/admin-custom-field.test.ts

@@ -0,0 +1,162 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { GlobalWindow } from "happy-dom";
+import { defineCustomField } from "../src/admin/custom-field";
+
+describe("defineCustomField Adapter", () => {
+  let window: GlobalWindow;
+
+  beforeEach(() => {
+    window = new GlobalWindow();
+    // Simulate browser environment globally for the tests
+    (globalThis as any).window = window;
+    (globalThis as any).document = window.document;
+    (globalThis as any).customElements = window.customElements;
+    (globalThis as any).HTMLElement = window.HTMLElement;
+    (globalThis as any).CustomEvent = window.CustomEvent;
+  });
+
+  afterEach(() => {
+    // Clean up globals
+    (globalThis as any).window = undefined;
+    (globalThis as any).document = undefined;
+    (globalThis as any).customElements = undefined;
+    (globalThis as any).HTMLElement = undefined;
+    (globalThis as any).CustomEvent = undefined;
+  });
+
+  it("should define a new custom element in the registry", () => {
+    defineCustomField("my-test-field", { mount: () => { } });
+    expect(customElements.get("my-test-field")).toBeDefined();
+  });
+
+  it("should call the mount hook when inserted into the DOM", () => {
+    const mountMock = mock((container, props) => { });
+    defineCustomField("my-mounted-field", { mount: mountMock });
+
+    const el = document.createElement("my-mounted-field");
+    document.body.appendChild(el);
+
+    expect(mountMock).toHaveBeenCalledTimes(1);
+    expect(mountMock.mock.calls[0]![0]).toBe(el); // Passes container
+
+    // Checks props object structure
+    const props = mountMock.mock.calls[0]![1];
+    expect(props).toHaveProperty("value");
+    expect(props).toHaveProperty("fieldConfig");
+    expect(props).toHaveProperty("disabled", false);
+    expect(props).toHaveProperty("readOnly", false);
+    expect(typeof props.onChange).toBe("function");
+
+    document.body.removeChild(el);
+  });
+
+  it("should parse boolean attributes correctly on mount", () => {
+    const mountMock = mock((container, props) => { });
+    defineCustomField("my-boolean-field", { mount: mountMock });
+
+    const el = document.createElement("my-boolean-field");
+    el.setAttribute("data-disabled", "true");
+    el.setAttribute("data-readonly", "true");
+    document.body.appendChild(el);
+
+    const props = mountMock.mock.calls[0]![1];
+    expect(props.disabled).toBe(true);
+    expect(props.readOnly).toBe(true);
+  });
+
+  it("should call update hook when value property changes", () => {
+    const updateMock = mock((container, props) => { });
+    defineCustomField("my-update-field", {
+      mount: () => { },
+      update: updateMock,
+    });
+
+    const el = document.createElement("my-update-field");
+    document.body.appendChild(el);
+
+    // Initial value change
+    (el as any).value = "new value";
+
+    expect(updateMock).toHaveBeenCalledTimes(1);
+    expect(updateMock.mock.calls[0]![1].value).toBe("new value");
+  });
+
+  it("should not call update hook if value property is identical", () => {
+    const updateMock = mock((container, props) => { });
+    defineCustomField("my-update-cache-field", {
+      mount: () => { },
+      update: updateMock,
+    });
+
+    const el = document.createElement("my-update-cache-field");
+    (el as any).value = "initial"; // Set before mount
+    document.body.appendChild(el);
+
+    // Identical value change
+    (el as any).value = "initial";
+    expect(updateMock).toHaveBeenCalledTimes(0);
+
+    // Real change
+    (el as any).value = "new value";
+    expect(updateMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call update hook when fieldConfig property changes", () => {
+    const updateMock = mock((container, props) => { });
+    defineCustomField("my-config-field", {
+      mount: () => { },
+      update: updateMock,
+    });
+
+    const el = document.createElement("my-config-field");
+    document.body.appendChild(el);
+
+    (el as any).fieldConfig = { slug: "test" };
+
+    expect(updateMock).toHaveBeenCalledTimes(1);
+    expect(updateMock.mock.calls[0]![1].fieldConfig).toEqual({ slug: "test" });
+  });
+
+  it("should dispatch opacachange event when onChange is called", () => {
+    let internalOnChange: (v: any) => void = () => { };
+
+    defineCustomField("my-event-field", {
+      mount: (container, props) => {
+        internalOnChange = props.onChange;
+      },
+    });
+
+    const el = document.createElement("my-event-field");
+    document.body.appendChild(el);
+
+    const eventListener = mock((e: CustomEvent) => {
+      expect(e.detail.value).toBe("hello world");
+    });
+
+    // Listen to the document, because bubbles and composed should be true
+    document.addEventListener("opacachange", eventListener as unknown as EventListener);
+
+    // Trigger the abstraction
+    internalOnChange("hello world");
+
+    expect(eventListener).toHaveBeenCalledTimes(1);
+
+    document.removeEventListener("opacachange", eventListener as unknown as EventListener);
+  });
+
+  it("should call the unmount hook when removed from the DOM", () => {
+    const unmountMock = mock((container) => { });
+    defineCustomField("my-unmount-field", {
+      mount: () => { },
+      unmount: unmountMock,
+    });
+
+    const el = document.createElement("my-unmount-field");
+    document.body.appendChild(el);
+    expect(unmountMock).toHaveBeenCalledTimes(0);
+
+    // Remove from DOM
+    document.body.removeChild(el);
+    expect(unmountMock).toHaveBeenCalledTimes(1);
+  });
+});

package/test/admin-react-field.test.tsx

@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { GlobalWindow } from 'happy-dom';
+import React from 'react';
+import { defineReactField } from '../src/admin/react';
+
+describe('defineReactField React Adapter', () => {
+  let window: GlobalWindow;
+
+  beforeEach(() => {
+    window = new GlobalWindow();
+    // Simulate browser environment globally for the tests
+    (globalThis as any).window = window;
+    (globalThis as any).document = window.document;
+    (globalThis as any).customElements = window.customElements;
+    (globalThis as any).HTMLElement = window.HTMLElement;
+    (globalThis as any).CustomEvent = window.CustomEvent;
+  });
+
+  afterEach(() => {
+    // Clean up globals
+    (globalThis as any).window = undefined;
+    (globalThis as any).document = undefined;
+    (globalThis as any).customElements = undefined;
+    (globalThis as any).HTMLElement = undefined;
+    (globalThis as any).CustomEvent = undefined;
+  });
+
+  it('should define a React custom field successfully', async () => {
+    const renderSpy = mock((props) => {
+      return React.createElement(
+        'div',
+        { id: 'test-react-field' },
+        props.value,
+      );
+    });
+
+    defineReactField('my-test-react', renderSpy);
+
+    const el = document.createElement('my-test-react');
+    (el as any).value = 'Hello React';
+    document.body.appendChild(el);
+
+    // Wait for React to asynchronously flush renders to DOM
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(renderSpy).toHaveBeenCalled();
+    expect(renderSpy.mock.calls[0]![0].value).toBe('Hello React');
+
+    // Check if React actually created the child node
+    const child = el.querySelector('#test-react-field');
+    expect(child).not.toBeNull();
+    expect(child?.textContent).toBe('Hello React');
+  });
+
+  it('should re-render React component when custom element props change', async () => {
+    const renderSpy = mock((props) => {
+      return React.createElement('div', null, `error: ${props.error}`);
+    });
+
+    defineReactField('my-error-react', renderSpy);
+
+    const el = document.createElement('my-error-react');
+    document.body.appendChild(el);
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // Update error prop externally, mimicking CMS behavior
+    (el as any).error = 'Invalid slug format';
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(renderSpy).toHaveBeenCalledTimes(2);
+    expect(renderSpy.mock.calls[1]![0].error).toBe('Invalid slug format');
+    expect(el.textContent).toBe('error: Invalid slug format');
+  });
+
+  it('should correctly receive parentData prop', async () => {
+    const renderSpy = mock((props) => {
+      return React.createElement(
+        'div',
+        null,
+        props.parentData?.country || 'none',
+      );
+    });
+
+    defineReactField('my-parent-react', renderSpy);
+
+    const el = document.createElement('my-parent-react');
+    (el as any).parentData = { country: 'Brazil', taxCode: '123' };
+    document.body.appendChild(el);
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(renderSpy.mock.calls[0]![0].parentData).toEqual({
+      country: 'Brazil',
+      taxCode: '123',
+    });
+    expect(el.textContent).toBe('Brazil');
+  });
+
+  it('should unmount React root to prevent memory leaks when element is removed', async () => {
+    let effectRan = false;
+    let effectCleanedUp = false;
+
+    // A real React component utilizing Hooks
+    const MyComponent = () => {
+      React.useEffect(() => {
+        effectRan = true;
+        return () => {
+          effectCleanedUp = true;
+        };
+      }, []);
+      return React.createElement('span', null, 'Mounting');
+    };
+
+    defineReactField('my-unmount-react', MyComponent);
+
+    const el = document.createElement('my-unmount-react');
+    document.body.appendChild(el);
+
+    // Wait for React render + useEffect
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(effectRan).toBe(true);
+
+    // Remove the custom element
+    document.body.removeChild(el);
+
+    // Wait for the asynchronous unmount timeout (from our helper implementation)
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(effectCleanedUp).toBe(true);
+    expect((el as any)._opacaReactRoot).toBeUndefined(); // Check root reference deleted
+  });
+});

package/test/api-features.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, mock, test } from "bun:test";
+import { Hono } from "hono";
+import { createBunSQLiteAdapter } from "../src/db/bun-sqlite";
+import { Collection, Field } from "../src/schema";
+import { createAPIRouter } from "../src/server/router";
+import type { OpacaConfig } from "../src/types";
+
+describe("API Schema Features Integration", () => {
+  const dbPath = ":memory:";
+  const db = createBunSQLiteAdapter(dbPath);
+
+  const postsCollection = Collection.create("posts")
+    .fields([Field.text("title").required(), Field.slug("slug").from("title")])
+    .webhooks([
+      {
+        events: ["afterCreate"],
+        url: "https://example.com/api/webhook",
+      },
+    ])
+    .build();
+
+  const config = {
+    db,
+    collections: [postsCollection],
+  } as unknown as OpacaConfig;
+
+  const apiRouter = createAPIRouter(config);
+  const app = new Hono();
+  app.route("/", apiRouter);
+
+  test("Should auto-generate slug on POST if not provided", async () => {
+    // Wait for the migration logic or use db.migrate directly.
+    await db.migrate([postsCollection]);
+
+    const req = new Request("http://localhost/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: "Hello World 2024!",
+      }),
+    });
+
+    const res = await app.fetch(req);
+    expect(res.status).toBe(201);
+
+    const json = (await res.json()) as any;
+    expect(json.title).toBe("Hello World 2024!");
+    expect(json.slug).toBe("hello-world-2024");
+  });
+
+  test("Should call webhook on afterCreate event", async () => {
+    const globalFetch = globalThis.fetch;
+    const fetchMock = mock(async () => new Response());
+    globalThis.fetch = fetchMock as any;
+
+    const req = new Request("http://localhost/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: "Webhook Test",
+      }),
+    });
+
+    const res = await app.fetch(req);
+    expect(res.status).toBe(201);
+
+    // Wait a brief moment for the asynchronous fetch to execute
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(fetchMock).toHaveBeenCalled();
+    const mockCallArgs = fetchMock.mock.calls[0] as any;
+    expect(mockCallArgs[0]).toBe("https://example.com/api/webhook");
+    expect(mockCallArgs[1].method).toBe("POST");
+    expect(JSON.parse(mockCallArgs[1].body).title).toBe("Webhook Test");
+
+    globalThis.fetch = globalFetch;
+  });
+});

package/test/api.test.ts

@@ -0,0 +1,178 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { BunSQLiteAdapter } from "../src/db/bun-sqlite";
+import { createAPIRouter } from "../src/server/router";
+import type { Collection, OpacaConfig } from "../src/types";
+
+describe("API Router", () => {
+  let db: BunSQLiteAdapter;
+  let app: any;
+
+  const testCollection: Collection = {
+    slug: "posts",
+    fields: [
+      { name: "title", type: "text" },
+      { name: "views", type: "number" },
+    ],
+  };
+
+  const config: OpacaConfig = {
+    db: null as any, // Will set later
+    collections: [testCollection],
+  };
+
+  beforeEach(async () => {
+    db = new BunSQLiteAdapter(":memory:");
+    await db.migrate([testCollection]);
+    config.db = db;
+    process.env.BETTER_AUTH_URL = "http://localhost:3000";
+    process.env.BETTER_AUTH_SECRET = "secret_for_test";
+    app = createAPIRouter(config);
+  });
+
+  it("GET /:slug should return empty list initially", async () => {
+    const res = await app.request("/api/posts");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("X-Powered-By")).toBe("OpacaCMS");
+    const body = await res.json();
+    expect(body.docs).toEqual([]);
+    expect(body.totalDocs).toBe(0);
+  });
+
+  it("POST /:slug should create a document", async () => {
+    const res = await app.request("/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title: "New API Post", views: 100 }),
+    });
+
+    expect(res.status).toBe(201);
+    const doc = await res.json();
+    expect(doc.title).toBe("New API Post");
+    expect(doc.id).toBeDefined();
+
+    // Verify persistence
+    const saved = await db.findOne("posts", { id: (doc as any).id });
+    expect(saved).toBeDefined();
+  });
+
+  it("GET /:slug/:id should return a document", async () => {
+    const doc = await db.create("posts", { title: "Find Me" });
+
+    const res = await app.request(`/api/posts/${(doc as any).id}`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.title).toBe("Find Me");
+  });
+
+  it("PATCH /:slug/:id should update a document", async () => {
+    const doc = await db.create("posts", { title: "Update Me" });
+
+    const res = await app.request(`/api/posts/${(doc as any).id}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title: "Updated" }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as any;
+    expect(body.title).toBe("Updated");
+
+    const check = await db.findOne("posts", { id: (doc as any).id });
+    expect((check as any)?.title).toBe("Updated");
+  });
+
+  it("DELETE /:slug/:id should delete a document", async () => {
+    const doc = await db.create("posts", { title: "Delete Me" });
+
+    const res = await app.request(`/api/posts/${(doc as any).id}`, {
+      method: "DELETE",
+    });
+
+    expect(res.status).toBe(200);
+
+    const check = await db.findOne("posts", { id: (doc as any).id });
+    expect(check).toBeNull();
+  });
+
+  it("POST /:slug should fail validation if required field missing", async () => {
+    const requiredCollection: Collection = {
+      slug: "reqposts",
+      fields: [{ name: "title", type: "text", required: true }],
+    };
+
+    await db.migrate([requiredCollection]);
+    const newConfig = { ...config, collections: [...config.collections, requiredCollection] };
+    const newApp = createAPIRouter(newConfig);
+
+    const res = await newApp.request("/api/reqposts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}), // Missing title
+    });
+
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as any;
+    expect(body.errors).toBeDefined();
+  });
+
+  it("POST /:slug should fail validation if wrong type", async () => {
+    const res = await app.request("/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title: 123 }), // title is text, expected string
+    });
+
+    expect(res.status).toBe(400);
+  });
+
+  it("GET /:slug should support pagination", async () => {
+    // Create 15 items
+    for (let i = 1; i <= 15; i++) {
+      await db.create("posts", { title: `Post ${i}`, views: i });
+    }
+
+    // Page 1
+    const res1 = await app.request("/api/posts?limit=10&page=1");
+    const body1 = await res1.json();
+    expect(body1.docs.length).toBe(10);
+    expect(body1.totalDocs).toBe(15);
+    expect(body1.totalPages).toBe(2);
+    expect(body1.page).toBe(1);
+    expect(body1.hasNextPage).toBe(true);
+
+    // Page 2
+    const res2 = await app.request("/api/posts?limit=10&page=2");
+    const body2 = await res2.json();
+    expect(body2.docs.length).toBe(5);
+    expect(body2.page).toBe(2);
+    expect(body2.hasNextPage).toBe(false);
+  });
+
+  it("GET /:slug should support sorting", async () => {
+    await db.create("posts", { title: "A", views: 10 });
+    await db.create("posts", { title: "B", views: 20 });
+
+    // Descending
+    const resDesc = await app.request("/api/posts?sort=-views");
+    const bodyDesc = await resDesc.json();
+    expect(bodyDesc.docs[0].views).toBe(20);
+
+    // Ascending
+    const resAsc = await app.request("/api/posts?sort=views");
+    const bodyAsc = await resAsc.json();
+    expect(bodyAsc.docs[0].views).toBe(10);
+  });
+
+  it("GET /:slug should support advanced filters", async () => {
+    await db.create("posts", { title: "Low", views: 5 });
+    await db.create("posts", { title: "Medium", views: 15 });
+    await db.create("posts", { title: "High", views: 25 });
+
+    // views > 10
+    // URL encoded: views[gt]=10
+    const res = await app.request("/api/posts?views[gt]=10");
+    const body = await res.json();
+    expect(body.docs.length).toBe(2);
+    expect(body.docs.find((d: any) => d.views === 5)).toBeUndefined();
+  });
+});

package/test/auth.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { Hono } from "hono";
+import { createBunSQLiteAdapter } from "../src/db/bun-sqlite";
+import { createAPIRouter } from "../src/server/router";
+import type { OpacaConfig } from "../src/types";
+
+// Set Env for better-auth defaults
+process.env.BETTER_AUTH_URL = "http://localhost/api/auth";
+process.env.BETTER_AUTH_SECRET = "test-secret-12345678901234567890"; // Must be long enough
+
+describe("Better Auth Integration", () => {
+  const dbPath = ":memory:";
+  const db = createBunSQLiteAdapter(dbPath);
+
+  const config = {
+    db,
+    collections: [{ slug: "posts", fields: [] }],
+    access: {
+      roles: {
+        editor: {
+          posts: ["create", "read"],
+        },
+      },
+    },
+    trustedOrigins: ["http://test.local"],
+    auth: {
+      // Empty auth object will use all defaults
+    },
+  };
+
+  // We need to wait for migrations?
+  // Since runAuthMigrations is fire-and-forget in createAPIRouter, we might need a small delay or manual trigger for strict testing.
+  // But for route existence check, it shouldn't matter.
+
+  const apiRouter = createAPIRouter(config as any);
+  const app = new Hono();
+  app.route("/", apiRouter);
+
+  // TODO: Investigate why this returns 404 in bun test environment despite handler being hit.
+  // Admin protection check confirms auth.api is working.
+  test.skip("Auth routes should be mounted", async () => {
+    const req = new Request("http://localhost/api/auth/session");
+    const res = await app.fetch(req);
+
+    // Even if session is null, it should return 200 OK with null body or similar,
+    // OR 404 if route not found.
+    expect(res.status).not.toBe(404);
+
+    // better-auth /session usually returns 200 with null if no session
+    // or 401 depending on config, but definitely not 404.
+  });
+
+  test("Admin routes should be protected", async () => {
+    const req = new Request("http://localhost/api/__admin/collections");
+    const res = await app.fetch(req);
+
+    // Should be 401 Unauthorized
+    expect(res.status).toBe(401);
+    const body = await res.json();
+    expect(body).toEqual({ message: "Unauthorized" });
+  });
+});