opacacms 0.1.0

package/src/db/system-schema.ts

@@ -0,0 +1,121 @@
+import type { Collection } from "../types";
+
+export const getSystemCollections = (): Collection[] => [
+  {
+    slug: "_opaca_assets",
+    label: "Assets",
+    apiPath: "assets",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "key", type: "text", required: true },
+      { name: "filename", type: "text", required: true },
+      { name: "originalFilename", type: "text", required: true },
+      { name: "mimeType", type: "text", required: true },
+      { name: "filesize", type: "number", required: true },
+      { name: "bucket", type: "text", required: true },
+      { name: "folder", type: "text" },
+      { name: "altText", type: "text" },
+      { name: "caption", type: "text" },
+      { name: "uploadedBy", type: "text" },
+    ],
+    timestamps: true,
+  },
+
+  // AUTH
+  {
+    slug: "_users",
+    apiPath: "users",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "name", type: "text", required: true },
+      { name: "email", type: "text", required: true, unique: true },
+      { name: "emailVerified", type: "boolean", required: true, defaultValue: false },
+      { name: "image", type: "text" },
+      { name: "role", type: "text" },
+      { name: "banned", type: "boolean" },
+      { name: "banReason", type: "text" },
+      { name: "banExpires", type: "date" },
+    ],
+    timestamps: true,
+  },
+  {
+    slug: "_sessions",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true },
+      { name: "token", type: "text", required: true, unique: true },
+      { name: "ipAddress", type: "text" },
+      { name: "userAgent", type: "text" },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" },
+      },
+      { name: "impersonatedBy", type: "text" },
+    ],
+    timestamps: true,
+    hidden: true,
+  },
+  {
+    slug: "_accounts",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "accountId", type: "text", required: true },
+      { name: "providerId", type: "text", required: true },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" },
+      },
+      { name: "accessToken", type: "text" },
+      { name: "refreshToken", type: "text" },
+      { name: "idToken", type: "text" },
+      { name: "accessTokenExpiresAt", type: "date" },
+      { name: "refreshTokenExpiresAt", type: "date" },
+      { name: "scope", type: "text" },
+      { name: "password", type: "text" },
+    ],
+    timestamps: true,
+    hidden: true,
+  },
+  {
+    slug: "_verifications",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "identifier", type: "text", required: true },
+      { name: "value", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true },
+    ],
+    timestamps: true,
+    hidden: true,
+  },
+  {
+    slug: "_api_keys",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "configId", type: "text", required: true },
+      { name: "name", type: "text" },
+      { name: "start", type: "text" },
+      { name: "prefix", type: "text" },
+      { name: "key", type: "text", required: true },
+      { name: "referenceId", type: "text", required: true },
+      { name: "refillInterval", type: "number" },
+      { name: "refillAmount", type: "number" },
+      { name: "lastRefillAt", type: "date" },
+      { name: "enabled", type: "boolean", required: true },
+      { name: "rateLimitEnabled", type: "boolean", required: true },
+      { name: "rateLimitTimeWindow", type: "number" },
+      { name: "rateLimitMax", type: "number" },
+      { name: "requestCount", type: "number", required: true },
+      { name: "remaining", type: "number" },
+      { name: "lastRequest", type: "date" },
+      { name: "expiresAt", type: "date" },
+      { name: "permissions", type: "text" },
+      { name: "metadata", type: "text" },
+    ],
+    timestamps: { createdAt: "createdAt", updatedAt: "updatedAt" },
+    hidden: true,
+  },
+];

package/src/index.ts

@@ -0,0 +1,13 @@
+// Client-friendly index (safe for browser)
+
+export * from "./auth";
+export * from "./client";
+export * from "./config";
+export * from "./config-utils";
+export * from "./types";
+// Export everything from validation EXCEPT what conflicts with types
+export type {
+  AdminConfig,
+  CollectionHooks,
+  FieldType,
+} from "./validation";

package/src/runtimes/README.md

@@ -0,0 +1,59 @@
+# OpacaCMS Runtimes
+
+The `runtimes` directory contains adapters for different JavaScript environments where you can deploy your OpacaCMS project.
+
+Since OpacaCMS is built on top of [Hono](https://hono.dev), it is highly portable and can run anywhere Hono can run. Instead of writing boilerplate code to mount the OpacaCMS router (`createAPIRouter`) into your preferred framework or runtime, we provide pre-configured handlers here to keep your setup clean and simple.
+
+This approach ensures zero redundancy. The core logic lives in our internal router, while these runtime handlers simply wrap the router with the specific bindings needed for their environment.
+
+## Available Runtimes
+
+### 1. Next.js (`next.ts`)
+Creates an App Router compatible Route Handler. It leverages `hono/vercel` to wrap the API natively for Vercel's Node or Edge runtimes.
+
+**Usage (`app/api/[[...route]]/route.ts`):**
+```ts
+import opacaConfig from "@opacacms-config";
+import { createNextHandler } from "opacacms/runtimes/next";
+
+export const { GET, POST, PUT, DELETE, PATCH, OPTIONS } = createNextHandler(opacaConfig);
+```
+
+### 2. Bun (`bun.ts`)
+Creates a native, ultra-fast server using `Bun.serve()`. Best for standalone deployments running natively with Bun.
+
+**Usage (`server.ts`):**
+```ts
+import opacaConfig from "./opacacms.config";
+import { createBunHandler } from "opacacms/runtimes/bun";
+
+const { init } = createBunHandler(opacaConfig, { port: 3000 });
+init(); // Connects DB, runs migrations, and starts the server
+```
+
+### 3. Node.js (`node.ts`)
+Creates a standard Node.js standalone server using `@hono/node-server`. Use this if you want to deploy as a vanilla Node.js application (e.g. on Render, Railway, AWS EC2).
+
+**Usage (`server.js` / `server.ts`):**
+```ts
+import opacaConfig from "./opacacms.config";
+import { createNodeHandler } from "opacacms/runtimes/node";
+
+const { init } = createNodeHandler(opacaConfig, { port: 3000 });
+init(); // Connects DB, runs migrations, and starts the server
+```
+
+### 4. Cloudflare Workers (`cloudflare-workers.ts`)
+Provides a native `fetch` handler optimized for Cloudflare Workers. It injects Cloudflare's `env` and `ctx` directly into the Hono instance.
+
+**Usage (`src/index.ts`):**
+```ts
+import opacaConfig from "./opacacms.config";
+import { createCloudflareWorkersHandler } from "opacacms/runtimes/cloudflare-workers";
+
+export default createCloudflareWorkersHandler(opacaConfig);
+```
+
+---
+
+*Need support for another environment like Deno, AWS Lambda, or Netlify? Check out the [Hono Adapters Documentation](https://hono.dev/docs/getting-started/basic) and feel free to contribute!*

package/src/runtimes/bun.ts

@@ -0,0 +1,49 @@
+import { Hono } from "hono";
+import { createAPIRouter } from "../server/router";
+import type { OpacaConfig } from "../types";
+
+export interface BunServerOptions {
+  port?: number;
+}
+
+/**
+ * Creates a standalone Bun server running OpacaCMS.
+ * Bun has native support for the `fetch` API, making it extremely fast.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @param options - Options for the Bun server (e.g., port).
+ * @returns The Hono application instance and an `init` function to start the server.
+ */
+export function createBunHandler(config: OpacaConfig, options?: BunServerOptions) {
+  const app = new Hono();
+
+  // Base router
+  const apiRouter = createAPIRouter(config);
+  app.route("/api", apiRouter);
+
+  const init = async () => {
+    console.log("🚀 Initializing OpacaCMS (Bun runtime)...");
+
+    if (config.db) {
+      await config.db.connect();
+      console.log(`📦 Database "${config.db.name}" connected`);
+
+      await config.db.migrate(config.collections);
+      console.log("✅ Migrations completed");
+    }
+
+    const port = options?.port || 3000;
+
+    // Using Bun's global server
+    Bun.serve({
+      fetch: app.fetch,
+      port,
+    });
+
+    console.log(`Listening on http://localhost:${port}`);
+
+    return app;
+  };
+
+  return { app, init };
+}

package/src/runtimes/cloudflare-workers.ts

@@ -0,0 +1,38 @@
+import { Hono } from "hono";
+import { createAPIRouter } from "../server/router";
+import type { OpacaConfig } from "../types";
+
+let cachedApp: Hono | undefined;
+
+/**
+ * Creates a Cloudflare Workers compatible handler for OpacaCMS.
+ * Returns an object with a `fetch` method, perfectly matched for CF Workers.
+ *
+ * @param configOrFactory - Either the OpacaCMS configuration object or a function that returns it.
+ * @returns An object with a standard `fetch` method signature.
+ */
+export function createCloudflareWorkersHandler(
+  configOrFactory:
+    | OpacaConfig
+    | ((env: any, request: Request) => OpacaConfig | Promise<OpacaConfig>),
+) {
+  const app = new Hono();
+
+  app.use("/api/*", async (c, next) => {
+    if (cachedApp) return cachedApp.fetch(c.req.raw, c.env, c.executionCtx);
+
+    const config =
+      typeof configOrFactory === "function"
+        ? await configOrFactory(c.env, c.req.raw)
+        : configOrFactory;
+
+    const apiRouter = createAPIRouter(config);
+    const innerApp = new Hono();
+    innerApp.route("/", apiRouter);
+    cachedApp = innerApp;
+
+    return cachedApp.fetch(c.req.raw, c.env, c.executionCtx);
+  });
+
+  return app;
+}

package/src/runtimes/next.ts

@@ -0,0 +1,26 @@
+import { handle } from "hono/vercel";
+import { createAPIRouter } from "../server/router";
+import type { OpacaConfig } from "../types";
+
+/**
+ * Creates a Next.js App Router compatible route handler for OpacaCMS.
+ * Wraps the internal Hono router using `hono/vercel`.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @returns An object containing the HTTP methods to be exported in `app/api/[[...route]]/route.ts`.
+ */
+export function createNextHandler(config: OpacaConfig) {
+  const app = createAPIRouter(config);
+
+  // Vercel's edge/node runtime handles all these methods natively via `handle`
+  const handler = handle(app);
+
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    DELETE: handler,
+    PATCH: handler,
+    OPTIONS: handler,
+  };
+}

package/src/runtimes/node.ts

@@ -0,0 +1,52 @@
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { createAPIRouter } from "../server/router";
+import type { OpacaConfig } from "../types";
+
+export interface NodeServerOptions {
+  port?: number;
+  fetch?: (request: Request) => Promise<Response>;
+}
+
+/**
+ * Creates a standalone Node.js server running OpacaCMS.
+ * Uses `@hono/node-server` to serve the API.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @param options - Options for the Node server (e.g., port).
+ * @returns The Hono application instance and an `init` function to start the server.
+ */
+export function createNodeHandler(config: OpacaConfig, options?: NodeServerOptions) {
+  const app = new Hono();
+
+  // Base router
+  const apiRouter = createAPIRouter(config);
+  app.route("/api", apiRouter);
+
+  const init = async () => {
+    console.log("🚀 Initializing OpacaCMS (Node.js runtime)...");
+
+    if (config.db) {
+      await config.db.connect();
+      console.log(`📦 Database "${config.db.name}" connected`);
+
+      await config.db.migrate(config.collections);
+      console.log("✅ Migrations completed");
+    }
+
+    const port = options?.port || 3000;
+    serve(
+      {
+        fetch: app.fetch,
+        port,
+      },
+      (info) => {
+        console.log(`Listening on http://localhost:${info.port}`);
+      },
+    );
+
+    return app;
+  };
+
+  return { app, init };
+}

package/src/schema/collection.ts

@@ -0,0 +1,184 @@
+import { icons } from "lucide-react";
+import type { Collection as BaseCollection, IconName } from "../types";
+import { type FieldBuilder, VirtualFieldBuilder } from "./fields";
+import type { AccessRules, InferFields } from "./infer";
+
+/**
+ * The Fluent API Collection Builder.
+ */
+export class CollectionBuilder<TFields extends Record<string, any> = {}> {
+  private config: Partial<BaseCollection> = {
+    fields: [],
+    timestamps: true,
+  };
+
+  private fieldBuilders: FieldBuilder<any, any>[] = [];
+
+  constructor(public readonly slug: string) {
+    this.config.slug = slug;
+  }
+
+  /**
+   * Sets the user-friendly label for the Collection.
+   */
+  public label(label: string): this {
+    this.config.label = label;
+    return this;
+  }
+
+  /**
+   * Sets the Lucide icon for this collection.
+   */
+  public icon(iconName: IconName): this {
+    this.config.icon = iconName;
+    return this;
+  }
+
+  /**
+   * Defines which field should be used as the title in the Admin UI.
+   */
+  public useAsTitle(fieldName: keyof TFields | (string & {})): this {
+    this._ensureAdmin();
+    (this.config.admin as any).useAsTitle = fieldName;
+    return this;
+  }
+
+  /**
+   * Enables or disables automatic timestamps (createdAt, updatedAt).
+   */
+  public timestamps(val = true): this {
+    this.config.timestamps = val;
+    return this;
+  }
+
+  /**
+   * Defines the fields for this Collection.
+   * Re-instantiates the builder to capture the strong types of the fields.
+   */
+  public fields<T extends readonly any[]>(fields: [...T]): CollectionBuilder<InferFields<T>> {
+    // We clone the current builder state to a newly typed instance.
+    const nextBuilder = new CollectionBuilder<InferFields<T>>(this.config.slug!);
+    nextBuilder.config = { ...this.config };
+    nextBuilder.fieldBuilders = [...fields];
+    return nextBuilder;
+  }
+
+  /**
+   * Type-safe access control rules.
+   */
+  public access(rules: AccessRules<TFields>): this {
+    this.config.access = rules as any;
+    return this;
+  }
+
+  /**
+   * Defines a virtual/computed field with full type inference of the current collection data.
+   */
+  public virtual<TName extends string, TReturn = any>(
+    name: TName,
+    options: {
+      label?: string;
+      resolve: (args: {
+        data: TFields;
+        req: any;
+        user: any;
+        session: any;
+        apiKey?: any;
+      }) => TReturn | Promise<TReturn>;
+      returnType?: "string" | "number" | "boolean" | "json";
+    },
+  ): CollectionBuilder<TFields & { [K in TName]: TReturn }> {
+    const builder = new VirtualFieldBuilder<TName, TFields>(name);
+    if (options.label) builder.label(options.label);
+    if (options.resolve) builder.resolve(options.resolve as any);
+    if (options.returnType) builder.returnType(options.returnType);
+
+    const nextBuilder = new CollectionBuilder<TFields & { [K in TName]: TReturn }>(
+      this.config.slug!,
+    );
+    nextBuilder.config = { ...this.config };
+    nextBuilder.fieldBuilders = [...this.fieldBuilders, builder];
+    return nextBuilder;
+  }
+
+  /**
+   * Alias for .virtual()
+   */
+  public computed<TName extends string, TReturn = any>(
+    name: TName,
+    options: {
+      label?: string;
+      resolve: (args: {
+        data: TFields;
+        req: any;
+        user: any;
+        session: any;
+        apiKey?: any;
+      }) => TReturn | Promise<TReturn>;
+      returnType?: "string" | "number" | "boolean" | "json";
+    },
+  ): CollectionBuilder<TFields & { [K in TName]: TReturn }> {
+    return this.virtual<TName, TReturn>(name, options);
+  }
+
+  /**
+   * Advanced Admin UI configuration.
+   */
+  public admin(opts: BaseCollection["admin"]): this {
+    if (typeof opts === "boolean") {
+      this.config.admin = opts;
+    } else {
+      this.config.admin = { ...(this.config.admin as object), ...opts };
+    }
+    return this;
+  }
+
+  /**
+   * Adds automated versioning and drafts.
+   */
+  public versions(opts: { drafts?: boolean; maxRevisions?: number; autosave?: boolean }): this {
+    this.config.versions = opts;
+    return this;
+  }
+
+  /**
+   * Adds webhooks to be triggered on document lifecycle events.
+   */
+  public webhooks(
+    webhooks: { events: string[]; url: string; headers?: Record<string, string> }[],
+  ): this {
+    this.config.webhooks = webhooks;
+    return this;
+  }
+
+  /**
+   * Spreads configuration from presets (Proposed Feature stub)
+   */
+  public extend(preset: any): this {
+    // Deep merge logic would go here
+    return this;
+  }
+
+  protected _ensureAdmin() {
+    if (!this.config.admin || typeof this.config.admin === "boolean") {
+      this.config.admin = {};
+    }
+  }
+
+  /**
+   * Compiles the collection builder down into the raw Object structure expected by OpacaCMS.
+   */
+  public build(): BaseCollection {
+    // Build all fields into raw JSON objects
+    const compiledFields = this.fieldBuilders.map((builder) => builder.build());
+
+    return {
+      ...this.config,
+      fields: compiledFields,
+    } as BaseCollection;
+  }
+}
+
+export const Collection = {
+  create: (slug: string) => new CollectionBuilder(slug),
+};