opacacms 0.1.0

package/dist/schema/global.d.ts

@@ -0,0 +1,82 @@
+import type { AccessConfig, Global as GlobalType, IconName } from "../types";
+import { type FieldBuilder } from "./fields";
+import type { InferFields } from "./infer";
+export type Global = GlobalType;
+/**
+ * A Fluent API Builder for defining OpacaCMS Globals.
+ */
+export declare class GlobalBuilder<TFields extends Record<string, any> = {}> {
+    protected config: Partial<Global>;
+    protected _fields: FieldBuilder<any, any>[];
+    constructor(slug: string);
+    /**
+     * Enables or disables timestamps (createdAt, updatedAt) for this global.
+     * Defaults to true.
+     */
+    timestamps(enabled?: boolean | {
+        createdAt?: string;
+        updatedAt?: string;
+    }): this;
+    /**
+     * Sets the label for this global in the Admin UI.
+     */
+    label(label: string): this;
+    /**
+     * Sets the Lucide icon for this global.
+     */
+    icon(iconName: IconName): this;
+    /**
+     * Defines the fields for this global schema.
+     */
+    fields<T extends readonly any[]>(fields: [...T]): GlobalBuilder<InferFields<T>>;
+    /**
+     * Configuration for who can read and update this global.
+     */
+    access(rules: AccessConfig): this;
+    /**
+     * Defines a virtual/computed field with full type inference of the current global data.
+     */
+    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";
+    }): GlobalBuilder<TFields & {
+        [K in TName]: TReturn;
+    }>;
+    /**
+     * Alias for .virtual()
+     */
+    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";
+    }): GlobalBuilder<TFields & {
+        [K in TName]: TReturn;
+    }>;
+    /**
+     * Extends the global with arbitrary configuration.
+     */
+    extend(opts: Record<string, any>): this;
+    /**
+     * Compiles the builder down into the raw Global object expected by OpacaCMS.
+     */
+    build(): Global;
+}
+/**
+ * Singleton factory for creating Globals.
+ */
+export declare const Global: {
+    create: (slug: string) => GlobalBuilder<{}>;
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,4 @@
+export { Collection, CollectionBuilder } from "./collection";
+export { Field, FieldBuilder } from "./fields/index";
+export { Global, GlobalBuilder } from "./global";
+export type { AccessRules, InferFields } from "./infer";

package/dist/schema/infer.d.ts

@@ -0,0 +1,55 @@
+import type { FieldBuilder } from "./fields/base";
+/**
+ * Helper to convert a union of types into an intersection.
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Extracts the TName and TValue from a single FieldBuilder.
+ */
+export type InferField<T extends FieldBuilder<any, any, any, any>> = T extends FieldBuilder<any, any, infer TValue, any> ? TValue : any;
+/**
+ * Internal helper to distribute over a union of FieldBuilders.
+ * Matches against the class generics for maximum reliability.
+ */
+type ProcessField<F> = F extends FieldBuilder<"group", infer N, any, infer Sub> ? N extends string ? {
+    [K in N]: Sub extends readonly any[] ? InferFields<Sub> : unknown;
+} : {} : F extends FieldBuilder<"array", infer N, any, infer Sub> ? N extends string ? {
+    [K in N]: Sub extends readonly any[] ? InferFields<Sub>[] : unknown[];
+} : {} : F extends FieldBuilder<"row" | "collapsible", any, any, infer Sub> ? Sub extends readonly any[] ? InferFields<Sub> : {} : F extends FieldBuilder<"tabs", any, any, infer Sub> ? Sub extends readonly any[] ? UnionToIntersection<Sub[number] extends {
+    fields: infer S;
+} ? S extends readonly any[] ? InferFields<S> : {} : {}> : {} : F extends FieldBuilder<any, infer N, infer V, any> ? N extends string ? N extends "" ? {} : {
+    [K in N]: V;
+} : {} : {};
+/**
+ * Magically maps an array of FieldBuilders into a recursive object type representation.
+ *
+ * Performance Optimized:
+ * - Uses ProcessField helper for guaranteed union distribution.
+ * - UnionToIntersection merges individual field objects into a clean intersection.
+ */
+export type InferFields<T extends readonly any[]> = Flatten<UnionToIntersection<ProcessField<T[number]>>>;
+/**
+ * Access rules with strongly typed hooks.
+ */
+export interface AccessRules<TFields extends Record<string, any>> {
+    read?: (args: {
+        user: any;
+        data?: TFields;
+    }) => boolean | Promise<boolean>;
+    create?: (args: {
+        user: any;
+        data: TFields;
+    }) => boolean | Promise<boolean>;
+    update?: (args: {
+        user: any;
+        data: TFields;
+    }) => boolean | Promise<boolean>;
+    delete?: (args: {
+        user: any;
+        data?: TFields;
+    }) => boolean | Promise<boolean>;
+}
+export {};

package/dist/server/admin-router.d.ts

@@ -0,0 +1,9 @@
+import { Hono } from "hono";
+import type { Auth } from "../auth";
+import type { OpacaConfig } from "../types";
+import type { ApiContextVariables } from "./router";
+export declare function createAdminRouter(config: OpacaConfig, state: {
+    auth: Auth | undefined;
+}): Hono<{
+    Variables: ApiContextVariables;
+}, import("hono/types").BlankSchema, "/">;

package/dist/server/admin.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "hono";
+import type { Auth } from "../auth";
+import type { OpacaConfig } from "../types";
+type AdminHandlers = {
+    getMetadata: (c: Context) => Response;
+    getCollections: (c: Context) => Response;
+    getConfig: (c: Context) => Promise<Response>;
+    getSetupStatus: (c: Context) => Promise<Response>;
+    createApiKey: (c: Context) => Promise<Response>;
+};
+/**
+ * Creates the admin handlers for the OpacaCMS.
+ * @param config The OpacaCMS configuration.
+ * @param getAuth A function that returns the authentication instance.
+ * @returns An object containing the admin handlers for hono integration.
+ */
+export declare function createAdminHandlers(config: OpacaConfig, getAuth: () => Auth | undefined): AdminHandlers;
+export {};

package/dist/server/assets.d.ts

@@ -0,0 +1,47 @@
+import type { Context } from "hono";
+import type { OpacaConfig } from "../types";
+export declare function createAssetsHandlers(config: OpacaConfig): {
+    upload(c: Context): Promise<(Response & import("hono").TypedResponse<any, 201, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 500, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<{
+        error: any;
+    }, 400, "json">)>;
+    list(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        error: string;
+    }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        docs: any[];
+        folders: {
+            name: string;
+            buckets: string[];
+        }[];
+        totalDocs: number;
+        limit: number;
+        page: number;
+        totalPages: number;
+    }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+        error: any;
+    }, 500, "json">)>;
+    presign(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        error: string;
+    }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 400, "json">) | (Response & import("hono").TypedResponse<{
+        uploadUrl: any;
+        filename: any;
+    }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+        error: any;
+    }, 500, "json">)>;
+    serve(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        error: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 400, "json">) | (Response & import("hono").TypedResponse<any, import("hono/utils/http-status").ContentfulStatusCode, "body">) | (Response & import("hono").TypedResponse<{
+        error: any;
+    }, 500, "json">)>;
+};

package/dist/server/collection-router.d.ts

@@ -0,0 +1,14 @@
+import type { Hono } from "hono";
+import type { Auth } from "../auth";
+import type { OpacaConfig } from "../types";
+import type { ApiContextVariables } from "./router";
+export declare function mountCollectionRoutes(router: Hono<{
+    Variables: ApiContextVariables;
+}>, config: OpacaConfig, state: {
+    auth: Auth | undefined;
+}): void;
+export declare function mountGlobalRoutes(router: Hono<{
+    Variables: ApiContextVariables;
+}>, config: OpacaConfig, state: {
+    auth: Auth | undefined;
+}): void;

package/dist/server/handlers.d.ts

@@ -0,0 +1,76 @@
+import type { Context } from "hono";
+import type { Collection, Global, OpacaConfig } from "../types";
+/**
+ * Hydrates a document with virtual fields and nested fields.
+ * @param doc document to hydrate
+ * @param fields fields to hydrate
+ * @param c context
+ * @returns hydrated document
+ */
+export declare const hydrateDoc: (doc: any, fields: any[], c: Context, config: OpacaConfig) => Promise<any>;
+/**
+ * Creates handlers for a collection
+ * @param config opaca config
+ * @param collection collection config
+ * @param getAuth auth function
+ * @returns collection handlers
+ */
+export declare function createHandlers(config: OpacaConfig, collection: Collection, getAuth?: () => any): {
+    find(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        message: string;
+    }, 403, "json">) | (Response & import("hono").TypedResponse<{
+        docs: never[];
+        folders?: string[] | undefined;
+        totalDocs: number;
+        limit: number;
+        totalPages: number;
+        page: number;
+        pagingCounter: number;
+        hasPrevPage: boolean;
+        hasNextPage: boolean;
+        prevPage: number | null;
+        nextPage: number | null;
+    }, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+    findOne(c: Context): Promise<Response & import("hono").TypedResponse<any, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+    create(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        message: string;
+    }, 403, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+        errors: {
+            [x: string]: {
+                [x: string]: any;
+                _errors: string[];
+            } | undefined;
+            _errors: string[];
+        };
+    }, 400, "json">) | (Response & import("hono").TypedResponse<any, 201, "json">)>;
+    update(c: Context): Promise<Response & import("hono").TypedResponse<any, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+    delete(c: Context): Promise<Response & import("hono").TypedResponse<{
+        message: string;
+    }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+    findVersions(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        message: string;
+    }, 403, "json">) | (Response & import("hono").TypedResponse<never, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+        error: any;
+    }, 500, "json">)>;
+    restoreVersion(c: Context): Promise<(Response & import("hono").TypedResponse<{
+        message: string;
+    }, 403, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<never, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+        error: any;
+    }, 500, "json">)>;
+};
+/**
+ * Creates handlers for global collections
+ * @param config opaca config
+ * @param globalConfig global config
+ * @param getAuth auth function
+ * @returns global handlers
+ */
+export declare function createGlobalHandlers(config: OpacaConfig, globalConfig: Global, getAuth?: () => any): {
+    find(c: Context): Promise<Response & import("hono").TypedResponse<any, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+    update(c: Context): Promise<Response & import("hono").TypedResponse<any, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+};

package/dist/server/middlewares/admin.d.ts

@@ -0,0 +1,6 @@
+import type { Context, Next } from "hono";
+export declare const adminMiddleware: (c: Context, next: Next) => Promise<(Response & import("hono").TypedResponse<{
+    message: string;
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    message: string;
+}, 403, "json">) | undefined>;

package/dist/server/middlewares/auth.d.ts

@@ -0,0 +1,16 @@
+import type { Session, User } from "better-auth";
+import type { MiddlewareHandler } from "hono";
+import type { Auth } from "../../auth";
+export type AuthContextVariables = {
+    user: User | null;
+    session: Session | null;
+    apiKey?: {
+        id: string;
+        name: string | null;
+        permissions?: Record<string, string[]> | null;
+        referenceId: string;
+    } | null;
+};
+export declare function createAuthMiddleware(getAuth: () => Auth | undefined): MiddlewareHandler<{
+    Variables: AuthContextVariables;
+}>;

package/dist/server/middlewares/context.d.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareHandler } from "hono";
+import type { OpacaConfig } from "../../types";
+export type OpacaContextVariables = {
+    config: OpacaConfig;
+    db: OpacaConfig["db"];
+};
+export declare function createContextMiddleware(config: OpacaConfig): MiddlewareHandler<{
+    Variables: OpacaContextVariables;
+}>;

package/dist/server/middlewares/cors.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from "hono";
+import type { OpacaConfig } from "../../types";
+export declare function createCorsMiddleware(config: OpacaConfig): MiddlewareHandler;

package/dist/server/middlewares/database-init.d.ts

@@ -0,0 +1,11 @@
+import type { MiddlewareHandler } from "hono";
+import { type Auth } from "../../auth";
+import type { OpacaConfig } from "../../types";
+/**
+ * Middleware for database connection and schema synchronization.
+ * This runs once per server startup via a 'migrated' flag in the shared state.
+ */
+export declare function createDatabaseInitMiddleware(config: OpacaConfig, state: {
+    auth: Auth | undefined;
+    migrated: boolean;
+}): MiddlewareHandler;

package/dist/server/middlewares/rate-limit.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from "hono";
+import type { OpacaConfig } from "../../types";
+export declare function createRateLimitMiddleware(config: OpacaConfig): MiddlewareHandler;

package/dist/server/router.d.ts

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+import type { OpacaConfig } from "../types";
+import { type ApiContextVariables } from "./setup-middlewares";
+export type { ApiContextVariables } from "./setup-middlewares";
+export declare function createAPIRouter(config: OpacaConfig): Hono<{
+    Variables: ApiContextVariables;
+}>;

package/dist/server/setup-middlewares.d.ts

@@ -0,0 +1,17 @@
+import type { Hono } from "hono";
+import type { Auth } from "../auth";
+import type { OpacaConfig } from "../types";
+import { type AuthContextVariables } from "./middlewares/auth";
+import { type OpacaContextVariables } from "./middlewares/context";
+export type ApiContextVariables = OpacaContextVariables & AuthContextVariables;
+export declare function setupMiddlewares(router: Hono<{
+    Variables: ApiContextVariables;
+}>, config: OpacaConfig, state: {
+    auth: Auth | undefined;
+    migrated: boolean;
+}): void;
+export declare function setupAuthMiddlewares(router: Hono<{
+    Variables: ApiContextVariables;
+}>, config: OpacaConfig, state: {
+    auth: Auth | undefined;
+}): void;

package/dist/server/system-router.d.ts

@@ -0,0 +1,9 @@
+import { Hono } from "hono";
+import type { OpacaConfig } from "../types";
+import type { ApiContextVariables } from "./router";
+export declare function createSystemRouter(config: OpacaConfig): Hono<{
+    Variables: ApiContextVariables;
+}, import("hono/types").BlankSchema, "/">;
+export declare function createAssetsServingRouter(config: OpacaConfig): Hono<{
+    Variables: ApiContextVariables;
+}, import("hono/types").BlankSchema, "/">;

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+export * from "./config";
+export * from "./db/adapter";
+export * from "./server/admin";
+export * from "./server/handlers";
+export * from "./server/router";
+export * from "./types";

package/dist/src/admin/index.css

@@ -0,0 +1,47 @@
+/* src/admin/ui/styles/accordion.scss */
+
+
+/* src/admin/ui/styles/button.scss */
+
+
+/* src/admin/ui/styles/collapsible.scss */
+
+
+/* src/admin/ui/styles/dialog.scss */
+
+
+/* src/admin/ui/styles/group.scss */
+
+
+/* src/admin/ui/styles/input.scss */
+
+
+/* src/admin/ui/styles/label.scss */
+
+
+/* src/admin/ui/styles/radio-group.scss */
+
+
+/* src/admin/ui/styles/select.scss */
+
+
+/* src/admin/ui/styles/sheet.scss */
+
+
+/* src/admin/ui/styles/tabs.scss */
+
+
+/* src/admin/ui/styles/index.scss */
+
+
+/* src/admin/ui/styles/asset-manager.scss */
+
+
+/* src/admin/ui/styles/lexical.scss */
+
+
+/* src/admin/ui/styles/data-detail.scss */
+
+
+/* src/admin/ui/styles/media-registry.scss */
+

package/dist/src/admin/index.js

@@ -0,0 +1,176 @@
+import {
+  $config,
+  $hasMetadataError,
+  $isFetchingConfig,
+  $needsInit,
+  $router,
+  AdminClient,
+  AdminLayout,
+  Breadcrumbs,
+  Link,
+  Toast,
+  ToastContainer,
+  createFetcherStore,
+  createMutatorStore,
+  invalidateKeys,
+  mutateCache,
+  revalidateKeys,
+  setConfig,
+  setNeedsInit
+} from "../../chunk-2zm8cy1w.js";
+import"../../chunk-16vgcf3k.js";
+import {
+  $isSidebarCollapsed,
+  $toasts,
+  clearToast,
+  notify,
+  toggleSidebar
+} from "../../chunk-j4d50hrx.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/admin/custom-field.ts
+function defineCustomField(tagName, adapter) {
+  if (typeof window === "undefined")
+    return;
+  if (customElements.get(tagName)) {
+    console.warn(`[OpacaCMS] Custom field tag "${tagName}" is already defined.`);
+    return;
+  }
+
+  class OpacaCustomFieldElement extends HTMLElement {
+    _value;
+    _fieldConfig;
+    _error;
+    _parentData;
+    _isMounted = false;
+    handleChange = (newValue) => {
+      this.dispatchEvent(new CustomEvent("opacachange", {
+        detail: { value: newValue },
+        bubbles: true,
+        composed: true
+      }));
+    };
+    getProps() {
+      return {
+        value: this._value,
+        fieldConfig: this._fieldConfig,
+        disabled: this.getAttribute("data-disabled") === "true",
+        readOnly: this.getAttribute("data-readonly") === "true",
+        error: this._error,
+        parentData: this._parentData,
+        onChange: this.handleChange
+      };
+    }
+    set error(err) {
+      if (this._error !== err) {
+        this._error = err;
+        if (this._isMounted && adapter.update) {
+          adapter.update(this, this.getProps());
+        }
+      }
+    }
+    get error() {
+      return this._error;
+    }
+    set parentData(data) {
+      this._parentData = data;
+      if (this._isMounted && adapter.update) {
+        adapter.update(this, this.getProps());
+      }
+    }
+    get parentData() {
+      return this._parentData;
+    }
+    set value(val) {
+      const oldValue = this._value;
+      this._value = val;
+      if (this._isMounted && adapter.update && oldValue !== val) {
+        adapter.update(this, this.getProps());
+      }
+    }
+    get value() {
+      return this._value;
+    }
+    set fieldConfig(config) {
+      this._fieldConfig = config;
+      if (this._isMounted && adapter.update) {
+        adapter.update(this, this.getProps());
+      }
+    }
+    get fieldConfig() {
+      return this._fieldConfig;
+    }
+    connectedCallback() {
+      if (!this._isMounted) {
+        adapter.mount(this, this.getProps());
+        this._isMounted = true;
+      }
+    }
+    disconnectedCallback() {
+      if (this._isMounted) {
+        if (adapter.unmount) {
+          adapter.unmount(this);
+        }
+        this._isMounted = false;
+      }
+    }
+  }
+  customElements.define(tagName, OpacaCustomFieldElement);
+}
+// src/admin/react.tsx
+import React from "react";
+import { createRoot } from "react-dom/client";
+function defineReactField(tagName, Component) {
+  defineCustomField(tagName, {
+    mount: (container, props) => {
+      const el = container;
+      const root = createRoot(el);
+      el._opacaReactRoot = root;
+      root.render(React.createElement(Component, props));
+    },
+    update: (container, props) => {
+      const el = container;
+      const root = el._opacaReactRoot;
+      if (root) {
+        root.render(React.createElement(Component, props));
+      }
+    },
+    unmount: (container) => {
+      const el = container;
+      const root = el._opacaReactRoot;
+      if (root) {
+        setTimeout(() => {
+          root.unmount();
+          delete el._opacaReactRoot;
+        }, 0);
+      }
+    }
+  });
+}
+export {
+  toggleSidebar,
+  setNeedsInit,
+  setConfig,
+  revalidateKeys,
+  notify,
+  mutateCache,
+  invalidateKeys,
+  defineReactField,
+  defineCustomField,
+  createMutatorStore,
+  createFetcherStore,
+  clearToast,
+  ToastContainer,
+  Toast,
+  Link,
+  Breadcrumbs,
+  AdminLayout,
+  AdminClient,
+  $toasts,
+  $router,
+  $needsInit,
+  $isSidebarCollapsed,
+  $isFetchingConfig,
+  $hasMetadataError,
+  $config
+};

package/dist/src/admin/webcomponent.js

@@ -0,0 +1,19 @@
+import {
+  AdminClient
+} from "../../chunk-2zm8cy1w.js";
+import"../../chunk-16vgcf3k.js";
+import"../../chunk-j4d50hrx.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/admin/webcomponent.tsx
+import r2wc from "@r2wc/react-to-web-component";
+var OpacaAdminWebComponent = r2wc(AdminClient, {
+  props: {
+    serverUrl: "string",
+    config: "json",
+    initialNeedsInit: "boolean"
+  }
+});
+if (typeof window !== "undefined" && !customElements.get("opaca-admin")) {
+  customElements.define("opaca-admin", OpacaAdminWebComponent);
+}