opacacms 0.1.0 → 0.1.2

package/test/cli-integration.test.ts

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

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

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

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

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

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

@@ -1,74 +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: [],
-    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

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

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

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

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

@@ -1,12 +0,0 @@
-{
-  "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"
-  }
-}