opacacms 0.1.0

package/test/cli-integration.test.ts

@@ -0,0 +1,146 @@
+import { afterAll, beforeAll, describe, expect, it, spyOn } from "bun:test";
+import fs from "node:fs";
+import { resolve } from "node:path";
+import { initCommand } from "../src/cli/commands/init";
+import { migrateCreateCommand, migrateRunCommand, migrateStatusCommand } from "../src/cli/commands/migrate-commands";
+import { seedCommand } from "../src/cli/commands/seed-command";
+import { loadConfig } from "../src/cli/index";
+
+const TEST_DIR = resolve("packages/opacacms/test/integration-tmp");
+
+// Helper to capture console output
+function captureConsole() {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const logSpy = spyOn(console, "log").mockImplementation((...args) => logs.push(args.join(" ")));
+  const infoSpy = spyOn(console, "info").mockImplementation((...args) => logs.push(args.join(" ")));
+  const errorSpy = spyOn(console, "error").mockImplementation((...args) => errors.push(args.join(" ")));
+
+  return {
+    get logs() { return logs.join("\n"); },
+    get errors() { return errors.join("\n"); },
+    restore: () => {
+      logSpy.mockRestore();
+      infoSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  };
+}
+
+describe("CLI Integration Tests (Direct Calls)", () => {
+  beforeAll(() => {
+    if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+    // Change CWD to TEST_DIR for the duration of tests
+    process.chdir(TEST_DIR);
+  });
+
+  afterAll(() => {
+    // Restore CWD
+    process.chdir(resolve("../../.."));
+  });
+
+  describe("init command", () => {
+    it("should initialize a new project from boilerplate", async () => {
+      const consoleC = captureConsole();
+      try {
+        await initCommand("my-test-app", "");
+        expect(fs.existsSync(resolve("my-test-app", "opacacms.config.ts"))).toBe(true);
+        expect(fs.existsSync(resolve("my-test-app", "package.json"))).toBe(true);
+      } finally {
+        consoleC.restore();
+      }
+    });
+
+    it("should initialize a new project from an example", async () => {
+      const consoleC = captureConsole();
+      try {
+        await initCommand("my-sqlite-app", "sqlite-basic");
+        expect(fs.existsSync(resolve("my-sqlite-app", "opacacms.config.ts"))).toBe(true);
+        const configContent = fs.readFileSync(resolve("my-sqlite-app", "opacacms.config.ts"), "utf-8");
+        expect(configContent).toContain("Opaca Blog (SQLite)");
+      } finally {
+        consoleC.restore();
+      }
+    });
+  });
+
+  describe("database commands", () => {
+    let opaca: any;
+    const appDir = resolve(TEST_DIR, "db-app");
+
+    beforeAll(async () => {
+      await initCommand("db-app", "sqlite-basic");
+      process.chdir(appDir);
+
+      // FIX: Overwrite config for tests to use relative imports
+      const testConfig = `
+import { defineConfig } from "../../../src/index";
+import { createBunSQLiteAdapter } from "../../../src/db/bun-sqlite";
+import { Field } from "../../../src/schema/index";
+
+export default defineConfig({
+  appName: "Test App",
+  db: createBunSQLiteAdapter(":memory:"), // Use memory for speed
+  collections: [
+    {
+      slug: "posts",
+      fields: [Field.text("title").required()]
+    }
+  ]
+});`;
+      fs.writeFileSync("opacacms.config.ts", testConfig);
+
+      // We need to load the config.
+      opaca = await loadConfig(resolve("opacacms.config.ts"));
+    });
+
+    afterAll(() => {
+      process.chdir(TEST_DIR);
+    });
+
+    it("should create a migration", async () => {
+      const consoleC = captureConsole();
+      try {
+        await migrateCreateCommand(opaca, "initial", "");
+        const migrationsDir = resolve("migrations");
+        expect(fs.existsSync(migrationsDir)).toBe(true);
+        const files = fs.readdirSync(migrationsDir);
+        expect(files.some(f => f.endsWith("_initial.ts"))).toBe(true);
+      } finally {
+        consoleC.restore();
+      }
+    });
+
+    it("should run migrations", async () => {
+      const consoleC = captureConsole();
+      try {
+        await migrateRunCommand(opaca.db);
+        expect(consoleC.logs).toContain("Migrations applied successfully");
+      } finally {
+        consoleC.restore();
+      }
+    });
+
+    it("should show migration status", async () => {
+      const consoleC = captureConsole();
+      try {
+        await migrateStatusCommand(opaca);
+        expect(consoleC.logs).toContain("Checking migration status");
+        expect(consoleC.logs).toContain("initial.ts");
+      } finally {
+        consoleC.restore();
+      }
+    });
+
+    it("should seed the database", async () => {
+      const consoleC = captureConsole();
+      try {
+        await seedCommand(opaca, 5, true, "collections");
+        expect(consoleC.logs).toContain("Seeding completed successfully");
+      } finally {
+        consoleC.restore();
+      }
+    });
+  });
+});

package/test/cli.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it, mock, spyOn } from "bun:test";
+import { execSync } from "child_process";
+import fs from "fs";
+import { resolve } from "path";
+
+describe("CLI Tool", () => {
+  it("should output usage if no command is provided", () => {
+    try {
+      execSync("bun ./src/cli/index.ts", { encoding: "utf-8", cwd: process.cwd() });
+    } catch (e: any) {
+      expect(e.stdout || e.stderr || e.message).toContain("Usage: opacacms <command> [options]");
+    }
+  });
+
+  it("should fail if config is not found", () => {
+    try {
+      execSync("bun ./src/cli/index.ts migrate:create -c missing.ts", {
+        encoding: "utf-8",
+        cwd: process.cwd(),
+      });
+    } catch (e: any) {
+      expect(e.stderr || e.stdout || e.message).toContain("Config file not found");
+    }
+  });
+});

package/test/db/postgres.test.ts

@@ -0,0 +1,95 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { PostgresAdapter } from "../../src/db/postgres";
+import type { Collection } from "../../src/types";
+
+// These tests require a running Postgres instance (e.g. via docker compose up -d)
+// We skip if connection fails to avoid breaking CI environments without Docker
+describe("PostgresAdapter", () => {
+  let db: PostgresAdapter;
+  let isConnected = false;
+  const testCollection: Collection = {
+    slug: "test_posts",
+    fields: [
+      { name: "title", type: "text" },
+      { name: "views", type: "number" },
+      { name: "published", type: "boolean" },
+    ],
+    timestamps: true,
+  };
+
+  const config = {
+    host: "localhost",
+    port: 5433,
+    database: "opacacms",
+    username: "postgres",
+    password: "postgres",
+  };
+
+  beforeAll(async () => {
+    db = new PostgresAdapter(config, { push: true });
+    try {
+      await db.connect();
+      // Try to run a simple query to see if it's really connected
+      await (db as any).sql`SELECT 1`;
+      await db.migrate([testCollection]);
+      isConnected = true;
+    } catch (e) {
+      console.warn("Postgres connection failed, skipping tests.");
+    }
+  });
+
+  afterAll(async () => {
+    if (db && isConnected) {
+      await db.disconnect();
+    }
+  });
+
+  it("should create and retrieve a document", async () => {
+    if (!isConnected) return;
+    const data = { title: "Hello Postgres", views: 42, published: true };
+    const created = await db.create("test_posts", data);
+
+    expect(created).toBeDefined();
+    expect((created as any).id).toBeDefined();
+    expect((created as any).title).toBe("Hello Postgres");
+
+    const found = await db.findOne("test_posts", { id: (created as any).id });
+    expect(found).toMatchObject(data);
+  });
+
+  it("should update a document", async () => {
+    if (!isConnected) return;
+    const created = await db.create("test_posts", { title: "Old Title", views: 5 });
+    const id = (created as any).id;
+
+    const updated = await db.update("test_posts", { id }, { title: "New Title" });
+    expect((updated as any).title).toBe("New Title");
+
+    const found = await db.findOne("test_posts", { id });
+    expect((found as any).title).toBe("New Title");
+    expect((found as any).views).toBe(5);
+  });
+
+  it("should delete a document", async () => {
+    if (!isConnected) return;
+    const created = await db.create("test_posts", { title: "To Delete" });
+    const id = (created as any).id;
+
+    const success = await db.delete("test_posts", { id });
+    expect(success).toBe(true);
+
+    const found = await db.findOne("test_posts", { id });
+    expect(found).toBeNull();
+  });
+
+  it("should find documents with query operators", async () => {
+    if (!isConnected) return;
+    await db.create("test_posts", { title: "Low", views: 10 });
+    await db.create("test_posts", { title: "Medium", views: 50 });
+    await db.create("test_posts", { title: "High", views: 100 });
+
+    const result = await db.find("test_posts", { views: { gt: 40 } });
+    expect(result.docs.length).toBeGreaterThanOrEqual(2);
+    expect(result.totalDocs).toBeGreaterThanOrEqual(2);
+  });
+});

package/test/db/sqlite-filter.test.ts

@@ -0,0 +1,53 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { BunSQLiteAdapter } from "../../src/db/bun-sqlite";
+import type { Collection } from "../../src/types";
+
+const db = new BunSQLiteAdapter(":memory:", { push: true });
+
+beforeAll(async () => {
+  await db.connect();
+  await db.migrate([
+    {
+      slug: "test_users",
+      fields: [
+        { name: "name", type: "text" },
+        { name: "age", type: "number" },
+      ],
+    },
+  ]);
+
+  await db.create("test_users", { name: "Alice", age: 25 });
+  await db.create("test_users", { name: "Bob", age: 30 });
+  await db.create("test_users", { name: "Charlie", age: 35 });
+});
+
+afterAll(async () => {
+  await db.disconnect();
+});
+
+test("SQLite find - simple equality", async () => {
+  const result = await db.find<{ name: string; age: number }>("test_users", { name: "Alice" });
+  expect(result.docs.length).toBe(1);
+  expect(result.docs[0]?.name).toBe("Alice");
+});
+
+test("SQLite find - advanced operators (gt)", async () => {
+  const result = await db.find<{ name: string; age: number }>("test_users", { age: { gt: 28 } });
+  expect(result.docs.length).toBe(2);
+});
+
+test("SQLite find - advanced operators (like)", async () => {
+  const result = await db.find<{ name: string; age: number }>("test_users", {
+    name: { like: "%li%" },
+  });
+  expect(result.docs.length).toBe(2); // Alice, Charlie
+});
+
+test("SQLite find - multiple conditions", async () => {
+  const result = await db.find<{ name: string; age: number }>("test_users", {
+    name: { like: "%li%" },
+    age: { gt: 30 },
+  });
+  expect(result.docs.length).toBe(1);
+  expect(result.docs[0]?.name).toBe("Charlie");
+});

package/test/db/sqlite.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { BunSQLiteAdapter } from "../../src/db/bun-sqlite";
+import type { Collection } from "../../src/types";
+
+describe("BunSQLiteAdapter", () => {
+  let db: BunSQLiteAdapter;
+  const testCollection: Collection = {
+    slug: "posts",
+    fields: [
+      { name: "title", type: "text" },
+      { name: "views", type: "number" },
+      { name: "published", type: "boolean" },
+    ],
+    timestamps: true,
+  };
+
+  beforeEach(async () => {
+    db = new BunSQLiteAdapter(":memory:", { push: true });
+    await db.migrate([testCollection]);
+  });
+
+  afterEach(async () => {
+    await db.disconnect();
+  });
+
+  interface TestPost {
+    id: number;
+    title: string;
+    views?: number;
+    published?: boolean;
+  }
+
+  it("should create and retrieve a document", async () => {
+    const data = { title: "Hello World", views: 10, published: true };
+    const created = (await db.create("posts", data)) as unknown as TestPost;
+
+    expect(created).toBeDefined();
+    expect(created.id).toBeDefined();
+    expect(created.title).toBe("Hello World");
+
+    const found = await db.findOne("posts", { id: created.id });
+    expect(found).toEqual(created as unknown as typeof found);
+  });
+
+  it("should update a document", async () => {
+    const created = (await db.create("posts", {
+      title: "Old Title",
+      views: 5,
+    })) as unknown as TestPost;
+
+    const updated = (await db.update(
+      "posts",
+      { id: created.id },
+      { title: "New Title" },
+    )) as unknown as TestPost;
+    expect(updated.title).toBe("New Title");
+
+    const found = (await db.findOne("posts", { id: created.id })) as unknown as TestPost;
+    expect(found?.title).toBe("New Title");
+    expect(found?.views).toBe(5);
+  });
+
+  it("should delete a document", async () => {
+    const created = (await db.create("posts", { title: "To Delete" })) as unknown as TestPost;
+
+    const success = await db.delete("posts", { id: created.id });
+    expect(success).toBe(true);
+
+    const found = await db.findOne("posts", { id: created.id });
+    expect(found).toBeNull();
+  });
+
+  it("should find documents with query", async () => {
+    await db.create("posts", { title: "Post 1", published: true });
+    await db.create("posts", { title: "Post 2", published: false });
+    await db.create("posts", { title: "Post 3", published: true });
+
+    const result = await db.find("posts", { published: 1 }); // SQLite boolean is 0/1
+    expect(result.docs).toHaveLength(2);
+    expect(result.totalDocs).toBe(2);
+  });
+});

package/test/engine-features.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, mock, test } from "bun:test";
+import { Collection, Field } from "../src/schema";
+import { hydrateDoc } from "../src/server/handlers";
+
+describe("Engine Features Runtime", () => {
+  test("hydrateDoc should correctly filter localized fields based on locale query", async () => {
+    const fields = [Field.text("title").localized().build(), Field.text("description").build()];
+
+    const doc = {
+      title: { en: "Hello", pt: "Olá" },
+      description: "Non-localized",
+    };
+
+    const mockContext = {
+      req: {
+        query: (key: string) => (key === "locale" ? "pt" : null),
+        header: () => null,
+      },
+      get: () => null,
+    } as any;
+
+    const mockConfig = {
+      i18n: { defaultLocale: "en" },
+    } as any;
+
+    const result = await (hydrateDoc as any)(doc, fields, mockContext, mockConfig);
+
+    expect(result.title).toBe("Olá");
+    expect(result.description).toBe("Non-localized");
+  });
+
+  test("hydrateDoc should fallback to default locale if requested locale is missing", async () => {
+    const fields = [Field.text("title").localized().build()];
+
+    const doc = {
+      title: { en: "Hello", pt: "Olá" },
+    };
+
+    const mockContext = {
+      req: {
+        query: () => "fr", // French missing
+        header: () => null,
+      },
+      get: () => null,
+    } as any;
+
+    const mockConfig = {
+      i18n: { defaultLocale: "en" },
+    } as any;
+
+    const result = await (hydrateDoc as any)(doc, fields, mockContext, mockConfig);
+
+    expect(result.title).toBe("Hello");
+  });
+
+  test("hydrateDoc should return all locales if locale=all is passed", async () => {
+    const fields = [Field.text("title").localized().build()];
+
+    const doc = {
+      title: { en: "Hello", pt: "Olá" },
+    };
+
+    const mockContext = {
+      req: {
+        query: () => "all",
+        header: () => null,
+      },
+      get: () => null,
+    } as any;
+
+    const mockConfig = {
+      i18n: { defaultLocale: "en" },
+    } as any;
+
+    const result = await (hydrateDoc as any)(doc, fields, mockContext, mockConfig);
+
+    expect(result.title).toEqual({ en: "Hello", pt: "Olá" });
+  });
+});

package/test/globals.test.ts

@@ -0,0 +1,74 @@
+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: [],
+    globals: [
+      {
+        slug: "settings",
+        fields: [
+          { name: "siteName", type: "text", required: true },
+          { name: "maintenanceMode", type: "boolean", defaultValue: false },
+        ],
+      },
+    ],
+  });
+
+  app = new Hono();
+  // Don't nest inside /api again, createAPIRouter already handles /api
+  app.route("/", createAPIRouter(config));
+
+  // ensure tables are created
+  await db.connect();
+  await db.migrate(config.collections, config.globals);
+});
+
+afterAll(async () => {
+  await db.disconnect();
+});
+
+test("GET /api/globals/settings should return 404 initially (or empty JSON if null)", async () => {
+  const res = await app.request("/api/globals/settings");
+  expect(res.status).toBe(404);
+});
+
+test("POST /api/globals/settings should create the global", async () => {
+  const res = await app.request("/api/globals/settings", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ siteName: "My Website" }),
+  });
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as any;
+  expect(data.siteName).toBe("My Website");
+  // SQLite might return 0, better to just check falsy or explicitly
+  expect(!!data.maintenanceMode).toBe(false);
+});
+
+test("PATCH /api/globals/settings should update the global", async () => {
+  const res = await app.request("/api/globals/settings", {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ maintenanceMode: true }),
+  });
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as any;
+  expect(data.siteName).toBe("My Website"); // Unchanged
+  expect(!!data.maintenanceMode).toBe(true);
+});
+
+test("GET /api/globals/settings should return the global", async () => {
+  const res = await app.request("/api/globals/settings");
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as any;
+  expect(data.siteName).toBe("My Website");
+});

package/test/integration-tmp/db-app/opacacms.config.ts

@@ -0,0 +1,15 @@
+
+import { defineConfig } from "../../../src/index";
+import { createBunSQLiteAdapter } from "../../../src/db/bun-sqlite";
+import { Field } from "../../../src/schema/index";
+
+export default defineConfig({
+  appName: "Test App",
+  db: createBunSQLiteAdapter(":memory:"), // Use memory for speed
+  collections: [
+    {
+      slug: "posts",
+      fields: [Field.text("title").required()]
+    }
+  ]
+});

package/test/integration-tmp/my-sqlite-app/opacacms.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from "opacacms";
+import { createSQLiteAdapter } from 'opacacms/db/sqlite';
+import { Field } from 'opacacms/schema';
+
+export default defineConfig({
+  appName: 'Opaca Blog (SQLite)',
+  db: createSQLiteAdapter('blog.db'),
+  collections: [
+    {
+      slug: 'posts',
+      fields: [
+        Field.text('title').required(),
+        Field.textarea('content'),
+        Field.relationship('author').to('users'),
+      ],
+    },
+    {
+      slug: 'users',
+      fields: [
+        Field.text('name').required(),
+        Field.text('email').required(),
+      ],
+    },
+  ],
+});

package/test/integration-tmp/my-test-app/index.ts

@@ -0,0 +1,8 @@
+import { Hono } from 'hono';
+import { createAPIRouter } from 'opacacms/server';
+import config from './opacacms.config';
+
+const app = new Hono();
+app.route('/api', createAPIRouter(config));
+
+export default app;

package/test/integration-tmp/my-test-app/opacacms.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'opacacms';
+import { createSQLiteAdapter } from 'opacacms/db/sqlite';
+
+export default defineConfig({
+  appName: "My OpacaCMS App",
+  db: createSQLiteAdapter('local.db'),
+  collections: [
+    {
+      slug: 'posts',
+      fields: [
+        { name: 'title', type: 'text', required: true },
+        { name: 'content', type: 'text' }
+      ]
+    }
+  ]
+});

package/test/integration-tmp/my-test-app/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "my-test-app",
+  "type": "module",
+  "scripts": {
+    "start": "bun run index.ts",
+    "dev": "bun run --watch index.ts"
+  },
+  "dependencies": {
+    "opacacms": "latest",
+    "hono": "^4.0.0"
+  }
+}