@rawdash/hono 0.13.0

package/README.md

@@ -0,0 +1,147 @@
+# @rawdash/hono
+
+[![npm version](https://img.shields.io/npm/v/@rawdash/hono)](https://www.npmjs.com/package/@rawdash/hono)
+[![license](https://img.shields.io/npm/l/@rawdash/hono)](https://github.com/rawdash/rawdash/blob/main/LICENSE)
+
+Hono adapter for rawdash. Mounts [`@rawdash/server`](https://www.npmjs.com/package/@rawdash/server) handlers as Hono routers — runtime-agnostic, so it works in Cloudflare Workers, Node, Bun, Deno, or anywhere Hono runs.
+
+## What it is
+
+A thin wrapper around `@rawdash/server`'s pure handlers. Each factory returns a `Hono` app you mount with `app.route('/path', router)`. You provide:
+
+- **`getConfig(c)`** and **`getStorage(c)`** — per-request functions that the adapter calls to obtain the `DashboardConfig` and `ServerStorage` for the request. Return constants for the simple case, or derive values from `c` (path params, auth headers, env bindings) when each request needs its own config or storage.
+- **`before`** middleware — typically auth and authorization checks.
+
+No business logic lives here — every router delegates to a `@rawdash/server` handler and translates `RawdashError` into structured HTTP responses.
+
+## Install
+
+```sh
+npm install @rawdash/hono hono
+```
+
+Hono is a peer dependency.
+
+## Quick start
+
+The `mountEngine` helper builds a fully-wired Hono app for the simple case (one config, one storage):
+
+```ts
+import { createClient } from '@libsql/client';
+import { LibsqlStorage } from '@rawdash/adapter-libsql';
+import { mountEngine } from '@rawdash/hono';
+
+const storage = new LibsqlStorage({
+  client: createClient({ url: 'file:rawdash.db' }),
+});
+const { app } = mountEngine(config, { storage });
+
+// Cloudflare Worker / Bun / Deno: export the app
+export default app;
+
+// Node: use @hono/node-server
+// import { serve } from '@hono/node-server';
+// serve({ fetch: app.fetch, port: 8080 });
+```
+
+This mounts:
+
+| Path                                     | Method | Source                  |
+| ---------------------------------------- | ------ | ----------------------- |
+| `/health`                                | GET    | `createHealthRouter`    |
+| `/sync/state`                            | GET    | `createSyncStateRouter` |
+| `/sync`                                  | POST   | `createSyncRouter`      |
+| `/dashboards/:dashboardId/widgets[/...]` | GET    | `createWidgetsRouter`   |
+| `/retention/retain`                      | POST   | `createRetentionRouter` |
+
+`mountEngine` also starts a background retention loop on long-lived runtimes; pass `{ startRetention: false }` on serverless and trigger retention via your platform's scheduler instead.
+
+## Per-request config and storage — compose factories directly
+
+For deployments that need auth or that look up config / storage per request, skip `mountEngine` and compose the factories. Each factory accepts `before` middleware that runs before the handler, plus the `getConfig` / `getStorage` callbacks:
+
+```ts
+import {
+  createHealthRouter,
+  createSyncRouter,
+  createSyncStateRouter,
+  createWidgetsRouter,
+} from '@rawdash/hono';
+import { Hono } from 'hono';
+
+import { assertScope, requireAuth } from './my-auth';
+import { loadConfig, loadStorage } from './my-loaders';
+
+const app = new Hono();
+
+app.route('/health', createHealthRouter()); // public liveness probe
+
+const authedApp = new Hono();
+authedApp.use('*', requireAuth);
+
+authedApp.route(
+  '/dashboards',
+  createWidgetsRouter({
+    before: [assertScope('widgets:read')],
+    getConfig: (c) => loadConfig(c),
+    getStorage: (c) => loadStorage(c),
+  }),
+);
+
+authedApp.route(
+  '/sync',
+  createSyncRouter({
+    before: [assertScope('widgets:write')],
+    getConfig: (c) => loadConfig(c),
+    getStorage: (c) => loadStorage(c),
+  }),
+);
+
+authedApp.route(
+  '/sync/state',
+  createSyncStateRouter({
+    before: [assertScope('widgets:read')],
+    getStorage: (c) => loadStorage(c),
+  }),
+);
+
+app.route('/', authedApp);
+export default app;
+```
+
+The pure handlers in `@rawdash/server` do all the work; this package only translates HTTP. Adapters in other frameworks (Express, NestJS, etc.) would be a parallel thin layer over the same handlers.
+
+## Running on Node
+
+`@rawdash/hono` does **not** depend on `@hono/node-server` — the package stays runtime-agnostic so a Workers bundle doesn't pull Node-specific code. To run on Node, add `@hono/node-server` yourself:
+
+```sh
+npm install @hono/node-server
+```
+
+```ts
+import { serve } from '@hono/node-server';
+import { mountEngine } from '@rawdash/hono';
+
+const { app } = mountEngine(config);
+serve({ fetch: app.fetch, port: 8080 });
+```
+
+## Error mapping
+
+Handler errors translate to JSON:
+
+- `RawdashError` → `{ error: message, code }` at `err.status` (e.g. 404 `{error:'Dashboard not found', code:'DASHBOARD_NOT_FOUND'}`).
+- Other errors propagate to Hono's `onError` for you to handle.
+
+## Links
+
+- [rawdash docs](https://rawdash.dev)
+- [`@rawdash/server`](../server) — pure handlers + engine (the package this wraps)
+- [`@rawdash/client`](../client) — typed HTTP client (speaks the same wire contract)
+- [GitHub](https://github.com/rawdash/rawdash)
+- [Issues](https://github.com/rawdash/rawdash/issues)
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { DashboardConfig, ServerStorage } from '@rawdash/server';
+import { Context, MiddlewareHandler, Hono } from 'hono';
+
+/**
+ * Common options accepted by every `@rawdash/hono` router factory.
+ *
+ * `getConfig` / `getStorage` are invoked per-request with the Hono
+ * `Context`, so adapters can derive the config or storage from request
+ * state (e.g. a path parameter, an id attached by an auth middleware, or
+ * environment bindings).
+ *
+ * `before` middleware runs before any handler — typically auth/scope
+ * checks.
+ */
+interface HonoRouterOptions {
+    getConfig: (c: Context) => DashboardConfig | Promise<DashboardConfig>;
+    getStorage: (c: Context) => ServerStorage | Promise<ServerStorage>;
+    before?: MiddlewareHandler[];
+}
+interface HonoStorageRouterOptions {
+    getStorage: (c: Context) => ServerStorage | Promise<ServerStorage>;
+    before?: MiddlewareHandler[];
+}
+
+/**
+ * Liveness probe — returns `{status:'ok'}` synchronously, no storage
+ * access. Mount at `/health` (or wherever your platform's probe expects).
+ */
+declare function createHealthRouter(): Hono;
+
+/**
+ * `POST /` — triggers a sync, returning immediately with
+ * `{queued: true|false}`. The sync runs in the background.
+ *
+ * Mount at `/sync`.
+ */
+declare function createSyncRouter(opts: HonoRouterOptions): Hono;
+/**
+ * `GET /` — returns the current `SyncState`. Mount at `/sync/state`.
+ */
+declare function createSyncStateRouter(opts: HonoStorageRouterOptions): Hono;
+
+/**
+ * - `GET /:dashboardId/widgets` → `WidgetsListResponse`
+ * - `GET /:dashboardId/widgets/:widgetId` → `CachedWidget`
+ *
+ * Mount at `/dashboards`.
+ */
+declare function createWidgetsRouter(opts: HonoRouterOptions): Hono;
+
+/**
+ * `POST /retain` — runs the retention policy once. Coalesces concurrent
+ * calls so multiple requests during an in-flight run share the same
+ * promise.
+ *
+ * Mount at `/retention`.
+ */
+declare function createRetentionRouter(opts: HonoRouterOptions): Hono;
+interface RetentionLoopOptions {
+    getConfig: () => DashboardConfig | Promise<DashboardConfig>;
+    getStorage: () => ServerStorage | Promise<ServerStorage>;
+    intervalMs?: number;
+}
+/**
+ * Start a background loop that periodically runs the retention policy.
+ * Returns a `stop()` function that clears the interval.
+ *
+ * Only useful on long-lived runtimes (Node, Bun, Deno). In serverless
+ * runtimes (Workers, Lambda) use the platform's native scheduler
+ * (Cron Triggers, CloudWatch Events) to call `POST /retention/retain`.
+ */
+declare function startRetentionLoop(opts: RetentionLoopOptions): () => void;
+
+interface MountEngineOptions {
+    storage?: ServerStorage;
+    /** Set false to skip the background retention timer (e.g. on serverless). */
+    startRetention?: boolean;
+}
+interface MountEngineResult {
+    app: Hono;
+    stop(): void;
+}
+/**
+ * Convenience wrapper for the common case: builds a Hono app with all
+ * standard rawdash routes mounted at their canonical paths, backed by
+ * one `DashboardConfig` and one `ServerStorage` (defaults to
+ * `InMemoryStorage`).
+ *
+ * For deployments that need auth or that look up config / storage per
+ * request, skip this and compose the router factories directly with
+ * per-request `getConfig` / `getStorage` and `before` middleware.
+ */
+declare function mountEngine(config: DashboardConfig, options?: MountEngineOptions): MountEngineResult;
+
+export { type HonoRouterOptions, type HonoStorageRouterOptions, type MountEngineOptions, type MountEngineResult, type RetentionLoopOptions, createHealthRouter, createRetentionRouter, createSyncRouter, createSyncStateRouter, createWidgetsRouter, mountEngine, startRetentionLoop };

package/dist/index.js

@@ -0,0 +1,212 @@
+// src/health.ts
+import { getHealth } from "@rawdash/server";
+import { Hono } from "hono";
+function createHealthRouter() {
+  const app = new Hono();
+  app.get("/", (c) => c.json(getHealth()));
+  return app;
+}
+
+// src/sync.ts
+import { getSyncStateHandler, triggerSync } from "@rawdash/server";
+import { Hono as Hono2 } from "hono";
+
+// src/shared.ts
+import { isRawdashError } from "@rawdash/server";
+function makeEngineContext(c, opts) {
+  return {
+    getConfig: () => opts.getConfig(c),
+    getStorage: () => opts.getStorage(c)
+  };
+}
+function applyBefore(app, before) {
+  if (!before) {
+    return;
+  }
+  for (const mw of before) {
+    app.use("*", mw);
+  }
+}
+function mapError(c, err) {
+  if (isRawdashError(err)) {
+    return c.json(
+      { error: err.message, code: err.code },
+      err.status
+    );
+  }
+  throw err;
+}
+
+// src/sync.ts
+function createSyncRouter(opts) {
+  const app = new Hono2();
+  applyBefore(app, opts.before);
+  app.post("/", async (c) => {
+    try {
+      return c.json(await triggerSync(makeEngineContext(c, opts)));
+    } catch (err) {
+      return mapError(c, err);
+    }
+  });
+  return app;
+}
+function createSyncStateRouter(opts) {
+  const app = new Hono2();
+  applyBefore(app, opts.before);
+  app.get("/", async (c) => {
+    try {
+      return c.json(
+        await getSyncStateHandler({
+          getConfig: () => {
+            throw new Error("getConfig should not be called by sync-state");
+          },
+          getStorage: () => opts.getStorage(c)
+        })
+      );
+    } catch (err) {
+      return mapError(c, err);
+    }
+  });
+  return app;
+}
+
+// src/widgets.ts
+import { getWidget, listWidgets } from "@rawdash/server";
+import { Hono as Hono3 } from "hono";
+function createWidgetsRouter(opts) {
+  const app = new Hono3();
+  applyBefore(app, opts.before);
+  app.get("/:dashboardId/widgets", async (c) => {
+    try {
+      return c.json(
+        await listWidgets(
+          makeEngineContext(c, opts),
+          c.req.param("dashboardId")
+        )
+      );
+    } catch (err) {
+      return mapError(c, err);
+    }
+  });
+  app.get("/:dashboardId/widgets/:widgetId", async (c) => {
+    try {
+      return c.json(
+        await getWidget(
+          makeEngineContext(c, opts),
+          c.req.param("dashboardId"),
+          c.req.param("widgetId")
+        )
+      );
+    } catch (err) {
+      return mapError(c, err);
+    }
+  });
+  return app;
+}
+
+// src/retention.ts
+import {
+  DEFAULT_RETENTION_INTERVAL_MS,
+  hasPruningPolicy,
+  runRetention,
+  runRetentionOnce
+} from "@rawdash/server";
+import { Hono as Hono4 } from "hono";
+function createRetentionRouter(opts) {
+  const app = new Hono4();
+  applyBefore(app, opts.before);
+  let inFlight = null;
+  app.post("/retain", async (c) => {
+    try {
+      if (!inFlight) {
+        const ctx = makeEngineContext(c, opts);
+        inFlight = runRetentionOnce(ctx).finally(() => {
+          inFlight = null;
+        });
+      }
+      await inFlight;
+      return c.json({ triggered: true });
+    } catch (err) {
+      console.error("retention run failed", err);
+      return mapError(c, err);
+    }
+  });
+  return app;
+}
+function startRetentionLoop(opts) {
+  let stopped = false;
+  let inFlight = null;
+  let timer = null;
+  const tick = async () => {
+    if (inFlight || stopped) {
+      return;
+    }
+    const config = await opts.getConfig();
+    if (!config.retention || !hasPruningPolicy(config.retention)) {
+      return;
+    }
+    const storage = await opts.getStorage();
+    inFlight = runRetention(config, storage).finally(() => {
+      inFlight = null;
+    });
+    try {
+      await inFlight;
+    } catch (err) {
+      console.error("retention run failed", err);
+    }
+  };
+  void (async () => {
+    const config = await opts.getConfig();
+    if (!config.retention || !hasPruningPolicy(config.retention)) {
+      return;
+    }
+    const intervalMs = opts.intervalMs ?? config.retention.intervalMs ?? DEFAULT_RETENTION_INTERVAL_MS;
+    timer = setInterval(() => {
+      void tick();
+    }, intervalMs);
+  })();
+  return () => {
+    stopped = true;
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+}
+
+// src/mount.ts
+import { InMemoryStorage, ROUTES } from "@rawdash/server";
+import { Hono as Hono5 } from "hono";
+function mountEngine(config, options = {}) {
+  const storage = options.storage ?? new InMemoryStorage();
+  const getConfig = () => config;
+  const getStorage = () => storage;
+  const app = new Hono5();
+  app.route("/dashboards", createWidgetsRouter({ getConfig, getStorage }));
+  app.route(ROUTES.sync, createSyncRouter({ getConfig, getStorage }));
+  app.route(ROUTES.syncState, createSyncStateRouter({ getStorage }));
+  app.route("/retention", createRetentionRouter({ getConfig, getStorage }));
+  app.route(ROUTES.health, createHealthRouter());
+  let stopRetention = null;
+  if (options.startRetention !== false) {
+    stopRetention = startRetentionLoop({ getConfig, getStorage });
+  }
+  return {
+    app,
+    stop() {
+      if (stopRetention) {
+        stopRetention();
+      }
+    }
+  };
+}
+export {
+  createHealthRouter,
+  createRetentionRouter,
+  createSyncRouter,
+  createSyncStateRouter,
+  createWidgetsRouter,
+  mountEngine,
+  startRetentionLoop
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/health.ts","../src/sync.ts","../src/shared.ts","../src/widgets.ts","../src/retention.ts","../src/mount.ts"],"sourcesContent":["import { getHealth } from '@rawdash/server';\nimport { Hono } from 'hono';\n\n/**\n * Liveness probe — returns `{status:'ok'}` synchronously, no storage\n * access. Mount at `/health` (or wherever your platform's probe expects).\n */\nexport function createHealthRouter(): Hono {\n  const app = new Hono();\n  app.get('/', (c) => c.json(getHealth()));\n  return app;\n}\n","import { getSyncStateHandler, triggerSync } from '@rawdash/server';\nimport { Hono } from 'hono';\n\nimport type { HonoRouterOptions, HonoStorageRouterOptions } from './shared';\nimport { applyBefore, makeEngineContext, mapError } from './shared';\n\n/**\n * `POST /` — triggers a sync, returning immediately with\n * `{queued: true|false}`. The sync runs in the background.\n *\n * Mount at `/sync`.\n */\nexport function createSyncRouter(opts: HonoRouterOptions): Hono {\n  const app = new Hono();\n  applyBefore(app, opts.before);\n  app.post('/', async (c) => {\n    try {\n      return c.json(await triggerSync(makeEngineContext(c, opts)));\n    } catch (err) {\n      return mapError(c, err);\n    }\n  });\n  return app;\n}\n\n/**\n * `GET /` — returns the current `SyncState`. Mount at `/sync/state`.\n */\nexport function createSyncStateRouter(opts: HonoStorageRouterOptions): Hono {\n  const app = new Hono();\n  applyBefore(app, opts.before);\n  app.get('/', async (c) => {\n    try {\n      // sync-state only needs storage, but reuse the EngineContext shape\n      // for handler uniformity. getConfig is a no-op here.\n      return c.json(\n        await getSyncStateHandler({\n          getConfig: () => {\n            throw new Error('getConfig should not be called by sync-state');\n          },\n          getStorage: () => opts.getStorage(c),\n        }),\n      );\n    } catch (err) {\n      return mapError(c, err);\n    }\n  });\n  return app;\n}\n","import type { EngineContext } from '@rawdash/server';\nimport type { DashboardConfig, ServerStorage } from '@rawdash/server';\nimport { isRawdashError } from '@rawdash/server';\nimport type { Context, MiddlewareHandler } from 'hono';\nimport { Hono } from 'hono';\n\n/**\n * Common options accepted by every `@rawdash/hono` router factory.\n *\n * `getConfig` / `getStorage` are invoked per-request with the Hono\n * `Context`, so adapters can derive the config or storage from request\n * state (e.g. a path parameter, an id attached by an auth middleware, or\n * environment bindings).\n *\n * `before` middleware runs before any handler — typically auth/scope\n * checks.\n */\nexport interface HonoRouterOptions {\n  getConfig: (c: Context) => DashboardConfig | Promise<DashboardConfig>;\n  getStorage: (c: Context) => ServerStorage | Promise<ServerStorage>;\n  before?: MiddlewareHandler[];\n}\n\nexport interface HonoStorageRouterOptions {\n  getStorage: (c: Context) => ServerStorage | Promise<ServerStorage>;\n  before?: MiddlewareHandler[];\n}\n\nexport function makeEngineContext(\n  c: Context,\n  opts: HonoRouterOptions,\n): EngineContext {\n  return {\n    getConfig: () => opts.getConfig(c),\n    getStorage: () => opts.getStorage(c),\n  };\n}\n\nexport function applyBefore(app: Hono, before?: MiddlewareHandler[]): void {\n  if (!before) {\n    return;\n  }\n  for (const mw of before) {\n    app.use('*', mw);\n  }\n}\n\n/**\n * Translate a thrown error into a Hono JSON response. `RawdashError`\n * becomes a structured `{error, code}` body at the carried status; any\n * other error is re-thrown for Hono's own error handling.\n */\nexport function mapError(c: Context, err: unknown): Response {\n  if (isRawdashError(err)) {\n    return c.json(\n      { error: err.message, code: err.code },\n      err.status as Parameters<typeof c.json>[1],\n    );\n  }\n  throw err;\n}\n","import { getWidget, listWidgets } from '@rawdash/server';\nimport { Hono } from 'hono';\n\nimport type { HonoRouterOptions } from './shared';\nimport { applyBefore, makeEngineContext, mapError } from './shared';\n\n/**\n * - `GET /:dashboardId/widgets` → `WidgetsListResponse`\n * - `GET /:dashboardId/widgets/:widgetId` → `CachedWidget`\n *\n * Mount at `/dashboards`.\n */\nexport function createWidgetsRouter(opts: HonoRouterOptions): Hono {\n  const app = new Hono();\n  applyBefore(app, opts.before);\n\n  app.get('/:dashboardId/widgets', async (c) => {\n    try {\n      return c.json(\n        await listWidgets(\n          makeEngineContext(c, opts),\n          c.req.param('dashboardId'),\n        ),\n      );\n    } catch (err) {\n      return mapError(c, err);\n    }\n  });\n\n  app.get('/:dashboardId/widgets/:widgetId', async (c) => {\n    try {\n      return c.json(\n        await getWidget(\n          makeEngineContext(c, opts),\n          c.req.param('dashboardId'),\n          c.req.param('widgetId'),\n        ),\n      );\n    } catch (err) {\n      return mapError(c, err);\n    }\n  });\n\n  return app;\n}\n","import type { DashboardConfig, ServerStorage } from '@rawdash/server';\nimport {\n  DEFAULT_RETENTION_INTERVAL_MS,\n  hasPruningPolicy,\n  runRetention,\n  runRetentionOnce,\n} from '@rawdash/server';\nimport { Hono } from 'hono';\n\nimport type { HonoRouterOptions } from './shared';\nimport { applyBefore, makeEngineContext, mapError } from './shared';\n\n/**\n * `POST /retain` — runs the retention policy once. Coalesces concurrent\n * calls so multiple requests during an in-flight run share the same\n * promise.\n *\n * Mount at `/retention`.\n */\nexport function createRetentionRouter(opts: HonoRouterOptions): Hono {\n  const app = new Hono();\n  applyBefore(app, opts.before);\n\n  let inFlight: Promise<void> | null = null;\n\n  app.post('/retain', async (c) => {\n    try {\n      if (!inFlight) {\n        const ctx = makeEngineContext(c, opts);\n        inFlight = runRetentionOnce(ctx).finally(() => {\n          inFlight = null;\n        });\n      }\n      await inFlight;\n      return c.json({ triggered: true });\n    } catch (err) {\n      console.error('retention run failed', err);\n      return mapError(c, err);\n    }\n  });\n\n  return app;\n}\n\nexport interface RetentionLoopOptions {\n  getConfig: () => DashboardConfig | Promise<DashboardConfig>;\n  getStorage: () => ServerStorage | Promise<ServerStorage>;\n  intervalMs?: number;\n}\n\n/**\n * Start a background loop that periodically runs the retention policy.\n * Returns a `stop()` function that clears the interval.\n *\n * Only useful on long-lived runtimes (Node, Bun, Deno). In serverless\n * runtimes (Workers, Lambda) use the platform's native scheduler\n * (Cron Triggers, CloudWatch Events) to call `POST /retention/retain`.\n */\nexport function startRetentionLoop(opts: RetentionLoopOptions): () => void {\n  let stopped = false;\n  let inFlight: Promise<void> | null = null;\n  let timer: ReturnType<typeof setInterval> | null = null;\n\n  const tick = async (): Promise<void> => {\n    if (inFlight || stopped) {\n      return;\n    }\n    const config = await opts.getConfig();\n    if (!config.retention || !hasPruningPolicy(config.retention)) {\n      return;\n    }\n    const storage = await opts.getStorage();\n    inFlight = runRetention(config, storage).finally(() => {\n      inFlight = null;\n    });\n    try {\n      await inFlight;\n    } catch (err) {\n      console.error('retention run failed', err);\n    }\n  };\n\n  void (async () => {\n    const config = await opts.getConfig();\n    if (!config.retention || !hasPruningPolicy(config.retention)) {\n      return;\n    }\n    const intervalMs =\n      opts.intervalMs ??\n      config.retention.intervalMs ??\n      DEFAULT_RETENTION_INTERVAL_MS;\n    timer = setInterval(() => {\n      void tick();\n    }, intervalMs);\n  })();\n\n  return () => {\n    stopped = true;\n    if (timer !== null) {\n      clearInterval(timer);\n      timer = null;\n    }\n  };\n}\n","import type { DashboardConfig, ServerStorage } from '@rawdash/server';\nimport { InMemoryStorage, ROUTES } from '@rawdash/server';\nimport { Hono } from 'hono';\n\nimport { createHealthRouter } from './health';\nimport { createRetentionRouter, startRetentionLoop } from './retention';\nimport { createSyncRouter, createSyncStateRouter } from './sync';\nimport { createWidgetsRouter } from './widgets';\n\nexport interface MountEngineOptions {\n  storage?: ServerStorage;\n  /** Set false to skip the background retention timer (e.g. on serverless). */\n  startRetention?: boolean;\n}\n\nexport interface MountEngineResult {\n  app: Hono;\n  stop(): void;\n}\n\n/**\n * Convenience wrapper for the common case: builds a Hono app with all\n * standard rawdash routes mounted at their canonical paths, backed by\n * one `DashboardConfig` and one `ServerStorage` (defaults to\n * `InMemoryStorage`).\n *\n * For deployments that need auth or that look up config / storage per\n * request, skip this and compose the router factories directly with\n * per-request `getConfig` / `getStorage` and `before` middleware.\n */\nexport function mountEngine(\n  config: DashboardConfig,\n  options: MountEngineOptions = {},\n): MountEngineResult {\n  const storage: ServerStorage = options.storage ?? new InMemoryStorage();\n  const getConfig = (): DashboardConfig => config;\n  const getStorage = (): ServerStorage => storage;\n\n  const app = new Hono();\n  app.route('/dashboards', createWidgetsRouter({ getConfig, getStorage }));\n  app.route(ROUTES.sync, createSyncRouter({ getConfig, getStorage }));\n  app.route(ROUTES.syncState, createSyncStateRouter({ getStorage }));\n  app.route('/retention', createRetentionRouter({ getConfig, getStorage }));\n  app.route(ROUTES.health, createHealthRouter());\n\n  let stopRetention: (() => void) | null = null;\n  if (options.startRetention !== false) {\n    stopRetention = startRetentionLoop({ getConfig, getStorage });\n  }\n\n  return {\n    app,\n    stop() {\n      if (stopRetention) {\n        stopRetention();\n      }\n    },\n  };\n}\n"],"mappings":"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","names":["Hono","Hono","Hono","Hono","Hono","Hono","Hono","Hono"]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rawdash/hono",
+  "version": "0.13.0",
+  "description": "Hono adapter for rawdash — router factories and helpers that mount @rawdash/server handlers onto a Hono app. Runtime-agnostic (Workers, Node, Bun, Deno).",
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rawdash/rawdash.git",
+    "directory": "packages/hono"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "@rawdash/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "hono": "^4.0.0"
+  },
+  "dependencies": {
+    "@rawdash/core": "workspace:*",
+    "@rawdash/server": "workspace:*"
+  },
+  "devDependencies": {
+    "hono": "^4.7.7",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.2",
+    "vitest": "^4.1.4"
+  }
+}