opacacms 0.1.1 → 0.1.2

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

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

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

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

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

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