elysia-rack 0.1.1

package/dist/rack/models/drizzle.d.ts

@@ -0,0 +1,4 @@
+export interface CrudDrizzleModel {
+    db: unknown;
+    table: unknown;
+}

package/dist/rack/models/index.d.ts

@@ -0,0 +1,24 @@
+export type { CrudDrizzleModel } from "./drizzle";
+export type { CrudPrismaModel } from "./prisma";
+import type { CrudDrizzleModel } from "./drizzle";
+import type { CrudPrismaModel } from "./prisma";
+/**
+ * ORM model/resource configuration.
+ *
+ * Union so a single resource cannot accidentally
+ * hold two ORMs at once.
+ *
+ * @example
+ * ```ts
+ * model: {
+ *   drizzle: { db, table: products }
+ * }
+ * ```
+ */
+export type CrudModel = {
+    drizzle: CrudDrizzleModel;
+    prisma?: never;
+} | {
+    prisma: CrudPrismaModel;
+    drizzle?: never;
+};

package/dist/rack/models/prisma.d.ts

@@ -0,0 +1,4 @@
+export interface CrudPrismaModel {
+    client: unknown;
+    model: unknown;
+}

package/dist/rack/openapi.d.ts

@@ -0,0 +1,6 @@
+import type { Rack } from "./types";
+/**
+ * Merge resource-level `options.openapi` with per-operation overrides
+ * into an Elysia `detail` hook.
+ */
+export declare function detailFor(options: Rack.CrudOptions, operation: Rack.CrudOperation): Record<string, unknown>;

package/dist/rack/page.d.ts

@@ -0,0 +1,33 @@
+import type { FieldDescriptor } from "./adapters/index";
+import type { Rack } from "./types";
+/**
+ * Registry key shared with `ReactRack.PAGE` (src/react/types.ts).
+ * `Symbol.for` makes both sides resolve to the same symbol
+ * without a runtime dependency from rack to react.
+ * Must stay in sync.
+ */
+export declare const PANEL_PAGE_KEY = "@elysia-panel/react";
+export interface PanelPageProps {
+    resource: string;
+    metadata?: Rack.CrudMetadata;
+    query?: Rack.CrudQueryOptions;
+    operations?: Rack.CrudOperationsOptions;
+    primaryKey?: string;
+    params?: Record<string, unknown>;
+    queryUrl?: string;
+    fields?: FieldDescriptor[];
+    deletedAtField?: string;
+    load?: (input: Record<string, unknown>) => Promise<{
+        data: unknown[];
+        total: number;
+    }>;
+}
+/**
+ * Build a page descriptor for the React panel,
+ * equivalent to `page(path, props)` from `elysia-rack/react`.
+ */
+export declare function panelPage(path: string, props: PanelPageProps): {
+    [x: symbol]: true;
+    path: string;
+    props: PanelPageProps;
+};

package/dist/rack/query.d.ts

@@ -0,0 +1,22 @@
+import type { Rack } from "./types";
+/**
+ * Normalized list query produced by {@link parseListQuery}.
+ */
+export type ParsedListQuery = ReturnType<typeof parseListQuery>;
+/**
+ * Parse raw URL/body input into a normalized list query,
+ * honoring `CrudQueryOptions` whitelists and pagination.
+ */
+export declare function parseListQuery(raw: Record<string, unknown>, queryOptions?: Rack.CrudQueryOptions): {
+    search: {
+        value: string;
+        fields: readonly string[];
+    } | undefined;
+    filters: Record<string, unknown>;
+    sort: {
+        field: string;
+        direction: import("./types/query").CrudSortDirection;
+    } | undefined;
+    page: number;
+    limit: number;
+};

package/dist/rack/registry.d.ts

@@ -0,0 +1,20 @@
+import type { Rack } from "./types";
+export interface RackRegistration {
+    /** Mount path, e.g. `/catalog/products`. */
+    path: string;
+    /** Resolved metadata (`id` defaults to path). */
+    metadata: Rack.CrudMetadata & {
+        id: string;
+    };
+    /** Resolved operations (all default `true`). */
+    operations: Required<Rack.CrudOperationsOptions>;
+}
+/**
+ * Register a rack resource. Called automatically by `rack()`.
+ * Re-registering the same path replaces the previous entry.
+ */
+export declare function registerRack(reg: RackRegistration): void;
+/** List all registered rack resources in registration order. */
+export declare function listRacks(): RackRegistration[];
+/** Clear the registry (mainly for tests). */
+export declare function clearRacks(): void;

package/dist/rack/types/authorization.d.ts

@@ -0,0 +1,16 @@
+export type CrudOperation = "list" | "detail" | "create" | "replace" | "update" | "delete";
+export type CrudAuthorizationRule = boolean | string | ((context: CrudAuthorizationContext) => boolean | Promise<boolean>);
+export interface CrudAuthorizationContext {
+    operation: CrudOperation;
+    request: Request;
+    id?: string;
+    resource: unknown;
+}
+export interface CrudAuthorizationOptions {
+    list?: CrudAuthorizationRule;
+    detail?: CrudAuthorizationRule;
+    create?: CrudAuthorizationRule;
+    replace?: CrudAuthorizationRule;
+    update?: CrudAuthorizationRule;
+    delete?: CrudAuthorizationRule;
+}

package/dist/rack/types/idempotency.d.ts

@@ -0,0 +1,46 @@
+export type Awaitable<T> = T | Promise<T>;
+export interface CrudIdempotencyRecord {
+    status: number;
+    body: unknown;
+}
+/**
+ * Pluggable idempotency store.
+ *
+ * Keys are already scoped per resource (`<resource>::<key>`).
+ * Implementations must honor `ttlSeconds` when provided.
+ */
+export interface CrudIdempotencyStore {
+    get(key: string): Awaitable<CrudIdempotencyRecord | undefined>;
+    set(key: string, record: CrudIdempotencyRecord, ttlSeconds?: number): Awaitable<void>;
+}
+export interface CrudIdempotencyOptions {
+    /**
+     * Enable idempotency for POST create.
+     *
+     * Default: true.
+     */
+    enabled?: boolean;
+    /**
+     * Reject POST without an idempotency key.
+     *
+     * Default: true (idempotency key is mandatory for POST).
+     */
+    required?: boolean;
+    /**
+     * Header carrying the client-generated key.
+     *
+     * Default: 'Idempotency-Key'.
+     */
+    header?: string;
+    /**
+     * How long a stored response is replayed, in seconds.
+     *
+     * Default: 86400 (24h).
+     */
+    ttl?: number;
+    /**
+     * Custom store. Defaults to an in-memory store (per rack instance).
+     * Use a shared store (e.g. Redis) when running multiple instances.
+     */
+    store?: CrudIdempotencyStore;
+}

package/dist/rack/types/index.d.ts

@@ -0,0 +1,89 @@
+import type { CrudAuthorizationContext as _CrudAuthorizationContext, CrudAuthorizationOptions as _CrudAuthorizationOptions, CrudAuthorizationRule as _CrudAuthorizationRule, CrudOperation as _CrudOperation } from "./authorization";
+import type { CrudMetadata as _CrudMetadata } from "./metadata";
+import type { CrudOpenAPIOperation as _CrudOpenAPIOperation, CrudOpenAPIOptions as _CrudOpenAPIOptions } from "./openapi";
+import type { CrudOperationsOptions as _CrudOperationsOptions } from "./operations";
+import type { CrudPageOptions as _CrudPageOptions, CrudSettings as _CrudSettings } from "./page";
+import type { CrudPaginationOptions as _CrudPaginationOptions, CrudQueryOptions as _CrudQueryOptions, CrudSortDirection as _CrudSortDirection } from "./query";
+import type { CrudValidationOptions as _CrudValidationOptions } from "./validation";
+import type { Awaitable as _Awaitable, CrudIdempotencyOptions as _CrudIdempotencyOptions, CrudIdempotencyRecord as _CrudIdempotencyRecord, CrudIdempotencyStore as _CrudIdempotencyStore } from "./idempotency";
+import type { CrudDrizzleModel as _CrudDrizzleModel, CrudModel as _CrudModel, CrudPrismaModel as _CrudPrismaModel } from "../models";
+export declare namespace Rack {
+    type CrudDrizzleModel = _CrudDrizzleModel;
+    type CrudPrismaModel = _CrudPrismaModel;
+    type CrudModel = _CrudModel;
+    type CrudOperation = _CrudOperation;
+    type CrudAuthorizationRule = _CrudAuthorizationRule;
+    type CrudAuthorizationContext = _CrudAuthorizationContext;
+    type CrudAuthorizationOptions = _CrudAuthorizationOptions;
+    type CrudSortDirection = _CrudSortDirection;
+    type CrudQueryOptions = _CrudQueryOptions;
+    type CrudPaginationOptions = _CrudPaginationOptions;
+    type CrudOperationsOptions = _CrudOperationsOptions;
+    type CrudMetadata = _CrudMetadata;
+    type CrudOpenAPIOptions = _CrudOpenAPIOptions;
+    type CrudOpenAPIOperation = _CrudOpenAPIOperation;
+    type CrudValidationOptions = _CrudValidationOptions;
+    type CrudPageOptions = _CrudPageOptions;
+    type CrudSettings = _CrudSettings;
+    type Awaitable<T> = _Awaitable<T>;
+    type CrudIdempotencyRecord = _CrudIdempotencyRecord;
+    type CrudIdempotencyStore = _CrudIdempotencyStore;
+    type CrudIdempotencyOptions = _CrudIdempotencyOptions;
+    interface CrudOptions<TModel extends CrudModel = CrudModel> {
+        /**
+         * ORM model/resource configuration.
+         *
+         * Example:
+         * model: {
+         *   drizzle: { db, table: products }
+         * }
+         */
+        model: TModel;
+        /**
+         * Validation for CRUD operations.
+         */
+        validation?: CrudValidationOptions;
+        /**
+         * Authorization rules for each operation.
+         */
+        authorization?: CrudAuthorizationOptions;
+        /**
+         * Configure list/query capabilities.
+         */
+        query?: CrudQueryOptions;
+        /**
+         * Enable, disable, or configure CRUD operations.
+         */
+        operations?: CrudOperationsOptions;
+        /**
+         * Metadata used by Panel, navigation, breadcrumbs,
+         * registry, and generated UI.
+         */
+        metadata?: CrudMetadata;
+        /**
+         * OpenAPI metadata and operation overrides.
+         */
+        openapi?: CrudOpenAPIOptions;
+        /**
+         * Optional React page configuration.
+         */
+        page?: CrudPageOptions;
+        /**
+         * Arbitrary framework/application settings.
+         *
+         * Avoid using this for core CRUD behavior.
+         */
+        settings?: CrudSettings;
+        /**
+         * Idempotency for POST create.
+         *
+         * The idempotency key header is required by default.
+         */
+        idempotency?: CrudIdempotencyOptions;
+    }
+    /**
+     * Historical alias for the `rack(path, options)` signature.
+     * Same as `CrudOptions`.
+     */
+    type RackOptions<TModel extends CrudModel = CrudModel> = CrudOptions<TModel>;
+}

package/dist/rack/types/metadata.d.ts

@@ -0,0 +1,36 @@
+export interface CrudMetadata {
+    /**
+     * Internal unique resource ID.
+     */
+    id?: string;
+    /**
+     * Human-readable singular label.
+     */
+    label?: string;
+    /**
+     * Human-readable plural label.
+     */
+    pluralLabel?: string;
+    /**
+     * Navigation group.
+     *
+     * Example: 'Catalog'
+     */
+    group?: string;
+    /**
+     * Parent resource/navigation ID.
+     */
+    parent?: string;
+    /**
+     * Icon identifier.
+     */
+    icon?: string;
+    /**
+     * Sidebar order.
+     */
+    order?: number;
+    /**
+     * Hide from generated sidebar.
+     */
+    hidden?: boolean;
+}

package/dist/rack/types/openapi.d.ts

@@ -0,0 +1,22 @@
+import type { CrudOperation } from "./authorization";
+export interface CrudOpenAPIOptions {
+    /**
+     * Common metadata applied to all generated operations.
+     */
+    tags?: readonly string[];
+    /**
+     * Resource-level description.
+     */
+    description?: string;
+    /**
+     * Operation-specific OpenAPI metadata.
+     */
+    operations?: Partial<Record<CrudOperation, CrudOpenAPIOperation>>;
+}
+export interface CrudOpenAPIOperation {
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    operationId?: string;
+}

package/dist/rack/types/operations.d.ts

@@ -0,0 +1,14 @@
+export interface CrudOperationsOptions {
+    list?: boolean;
+    detail?: boolean;
+    create?: boolean;
+    /**
+     * PUT
+     */
+    replace?: boolean;
+    /**
+     * PATCH
+     */
+    update?: boolean;
+    delete?: boolean;
+}

package/dist/rack/types/page.d.ts

@@ -0,0 +1,41 @@
+export interface CrudPageOptions {
+    /**
+     * Custom page path handled by react().
+     *
+     * Example: '/products'
+     */
+    path?: string;
+    /**
+     * Disable generated HTML page.
+     */
+    enabled?: boolean;
+    /**
+     * Custom page for this resource.
+     */
+    component?: string;
+}
+export interface CrudSettings {
+    /**
+     * Primary key field.
+     *
+     * Default should be resolved by the ORM adapter.
+     */
+    primaryKey?: string;
+    /**
+     * Soft delete support.
+     *
+     * When enabled, deletes set a timestamp column instead of
+     * removing the row, and reads skip soft-deleted rows.
+     */
+    softDelete?: boolean;
+    /**
+     * Column used for soft deletes.
+     *
+     * Default: 'deletedAt'.
+     */
+    deletedAtField?: string;
+    /**
+     * Return representation after mutation.
+     */
+    returning?: boolean;
+}

package/dist/rack/types/query.d.ts

@@ -0,0 +1,30 @@
+export type CrudSortDirection = "asc" | "desc";
+export interface CrudQueryOptions {
+    /**
+     * Fields allowed for full-text/search query.
+     */
+    searchable?: readonly string[];
+    /**
+     * Fields allowed for filtering.
+     */
+    filterable?: readonly string[];
+    /**
+     * Fields allowed for sorting.
+     */
+    sortable?: readonly string[];
+    /**
+     * Default sort.
+     */
+    defaultSort?: {
+        field: string;
+        direction?: CrudSortDirection;
+    };
+    /**
+     * Pagination configuration.
+     */
+    pagination?: CrudPaginationOptions;
+}
+export interface CrudPaginationOptions {
+    default?: number;
+    max?: number;
+}

package/dist/rack/types/validation.d.ts

@@ -0,0 +1,19 @@
+export interface CrudValidationOptions {
+    create?: unknown;
+    /**
+     * PUT: full replacement.
+     */
+    replace?: unknown;
+    /**
+     * PATCH: partial update.
+     */
+    update?: unknown;
+    /**
+     * Validate resource ID.
+     */
+    params?: unknown;
+    /**
+     * Validate QUERY body/query definition.
+     */
+    query?: unknown;
+}

package/dist/react/index.d.ts

@@ -0,0 +1,64 @@
+import Elysia from "elysia";
+import { ReactRack } from "./types";
+export declare function page<Props = Record<string, never>>(path: string, props?: Props): ReactRack.PageDescriptor<Props>;
+export declare const pages: ReactRack.PageRegistry;
+export declare function reactPlugin(options: ReactRack.ReactPluginOptions): Elysia<"", {
+    decorator: {
+        react: {
+            render: (path: string, props: unknown) => Promise<Response>;
+        };
+    };
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    __rack: {
+        ":name": {
+            get: {
+                body: unknown;
+                params: {
+                    name: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    404: "Panel asset not built. Run `bun run build:assets`." | "Panel asset not found";
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/react/index.js

@@ -0,0 +1,126 @@
+import {
+  __require
+} from "../index-37x76zdn.js";
+
+// src/react/index.ts
+import Elysia from "elysia";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/react/render.tsx
+import { renderToReadableStream } from "react-dom/server";
+import { jsxDEV } from "react/jsx-dev-runtime";
+function pageTitle(path, props) {
+  const metadata = props?.metadata;
+  return metadata?.pluralLabel ?? metadata?.label ?? path;
+}
+function createRenderer(pages) {
+  return async function render(path, props) {
+    const loader = pages[path];
+    if (!loader) {
+      return new Response("Page Not Found", {
+        status: 404
+      });
+    }
+    const module = await loader();
+    const Component = module.default;
+    const stream = await renderToReadableStream(/* @__PURE__ */ jsxDEV(Component, {
+      ...props
+    }, undefined, false, undefined, this));
+    const head = `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${pageTitle(path, props)}</title><link rel="stylesheet" href="/__rack/panel.css"><script type="module" src="/__rack/panel-theme.js"></script></head><body>`;
+    const encoder = new TextEncoder;
+    const combined = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(encoder.encode(head));
+        const reader = stream.getReader();
+        try {
+          for (;; ) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            controller.enqueue(value);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        controller.enqueue(encoder.encode("</body></html>"));
+        controller.close();
+      }
+    });
+    return new Response(combined, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8"
+      }
+    });
+  };
+}
+
+// src/react/types.ts
+var ReactRack;
+((ReactRack) => {
+  ReactRack.PAGE = Symbol.for("@elysia-panel/react");
+})(ReactRack ||= {});
+
+// src/react/index.ts
+var PANEL_ASSETS = {
+  "panel.css": "text/css; charset=utf-8",
+  "panel-theme.js": "text/javascript; charset=utf-8",
+  "panel-app.js": "text/javascript; charset=utf-8"
+};
+function resolveDistDir() {
+  const candidates = [
+    join(process.cwd(), "dist"),
+    join(fileURLToPath(new URL(".", import.meta.url)), "..")
+  ];
+  for (const dir of candidates) {
+    try {
+      if (existsSync(join(dir, "panel-app.js")))
+        return dir;
+    } catch {}
+  }
+  return null;
+}
+function page(path, props) {
+  return {
+    [ReactRack.PAGE]: true,
+    path,
+    props
+  };
+}
+var pages = {
+  "/dashboard": () => import("../Dashboard-xpstr7fr.js"),
+  "/panel": () => import("../Panel-fbp3wrsw.js")
+};
+function reactPlugin(options) {
+  const render = createRenderer(options.pages);
+  return new Elysia({ name: "@elysia-rack/react" }).decorate("react", { render }).get("/__rack/:name", async ({ params, status }) => {
+    const type = PANEL_ASSETS[params.name];
+    const dir = resolveDistDir();
+    if (!type || !dir)
+      return status(404, "Panel asset not built. Run `bun run build:assets`.");
+    try {
+      const data = await readFile(join(dir, params.name));
+      return new Response(data, {
+        headers: {
+          "Content-Type": type,
+          "Cache-Control": "public, max-age=3600"
+        }
+      });
+    } catch {
+      return status(404, "Panel asset not found");
+    }
+  }).onAfterHandle({ as: "scoped" }, async ({ responseValue }) => {
+    if (typeof responseValue !== "object" || responseValue === null || !(ReactRack.PAGE in responseValue)) {
+      return;
+    }
+    const descriptor = responseValue;
+    return render(descriptor.path, descriptor.props);
+  });
+}
+export {
+  reactPlugin,
+  pages,
+  page
+};

package/dist/react/page/Dashboard.d.ts

@@ -0,0 +1,7 @@
+import { type RackRegistration } from "../../rack/registry";
+export interface DashboardProps {
+    name?: string;
+    resource?: string;
+    racks?: RackRegistration[];
+}
+export default function Dashboard(props: DashboardProps): Promise<import("react").JSX.Element>;

package/dist/react/page/Panel.d.ts

@@ -0,0 +1,36 @@
+import type { FieldDescriptor } from "../../rack/adapters/index";
+export interface PanelProps {
+    resource?: string;
+    metadata?: {
+        label?: string;
+        pluralLabel?: string;
+        group?: string;
+    };
+    operations?: {
+        list?: boolean;
+        detail?: boolean;
+        create?: boolean;
+        replace?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    };
+    primaryKey?: string;
+    query?: {
+        searchable?: readonly string[];
+        filterable?: readonly string[];
+        sortable?: readonly string[];
+        pagination?: {
+            default?: number;
+            max?: number;
+        };
+    };
+    params?: Record<string, unknown>;
+    queryUrl?: string;
+    fields?: FieldDescriptor[];
+    deletedAtField?: string;
+    load?: (input: Record<string, unknown>) => Promise<{
+        data: unknown[];
+        total: number;
+    }>;
+}
+export default function Panel(props: PanelProps): Promise<import("react").JSX.Element>;

package/dist/react/page/client/panel.d.ts

@@ -0,0 +1 @@
+export {};