@voilabs/plugins 0.0.1-beta.0

package/README.md

@@ -0,0 +1,634 @@
+# @voilabs/plugins
+
+A framework-agnostic plugin system for Node.js applications. The core package runs on the standard Fetch API, while Next.js, Elysia, and React integrations are provided as optional adapters.
+
+## Features
+
+- `Plugin` model with field validation, route manifests, UI component slots, meta tags, permissions, events, webhooks, lifecycle hooks, and injection points.
+- `PluginManager` with local plugin registration, automatic GitHub marketplace sync, install/update/enable/disable/uninstall flows, and tenant-aware storage.
+- HTTP runtime for `/plugins`, `/plugins/:id/install`, `/plugins/:id/config`, and custom plugin routes.
+- WordPress-like injection support: plugins can inject `script`, `style`, `html`, `meta`, `link`, and `noscript` into placements such as `head`, `body:end`, `admin:head`, and `public:footer`.
+- Elysia and Next.js adapters that use structural typing and do not require hard dependencies.
+- React integration through a fetch client and hook factory without making React a peer dependency.
+- GitHub marketplace support through `<plugin-id>.plugin`, `marketplace.json`, `plugins.json`, and `index.json`.
+
+## Installation
+
+```bash
+bun add @voilabs/plugins
+# or
+npm install @voilabs/plugins
+```
+
+The package is ESM-only and targets Node.js 18+ or any modern Fetch-compatible runtime.
+
+## Local Plugin Definition
+
+```ts
+import { Plugin } from "@voilabs/plugins";
+
+const LUMINA_API_KEY_ID =
+  "^voi_([a-fA-F0-9]{8})(-([a-fA-F0-9]{4})){3}-([a-fA-F0-9]{12})$";
+
+export const luminaAIPlugin = new Plugin({
+  id: "voidigital-lumina",
+  name: "Lumina",
+  summary: "Generate articles with Lumina AI.",
+  category: "content",
+  provider: "voidigital",
+  iconUrl: "https://www.google.com/s2/favicons?domain=voidigital.com&sz=128",
+  sidebarHref: "/admin/lumina",
+  needEncryption: true,
+  fields: [
+    {
+      key: "apiKey",
+      label: "API Key",
+      type: "secret",
+      required: true,
+      pattern: LUMINA_API_KEY_ID,
+      encrypt: true,
+    },
+    {
+      key: "email",
+      label: "Email Address",
+      type: "email",
+      required: true,
+    },
+  ],
+  routes: [
+    {
+      method: "POST",
+      path: "/articles",
+      summary: "Creates an article generation request.",
+      handler: async ({ body, config }) => ({
+        status: 202,
+        body: { queued: true, email: config.email, request: body },
+      }),
+    },
+  ],
+  frontend: {
+    components: [
+      {
+        key: "lumina-settings-row",
+        slot: "settings-row",
+        label: "Lumina settings",
+        component: { type: "registry", name: "LuminaSettingsRow" },
+      },
+    ],
+  },
+  additionalMetaTags: [
+    { key: "lumina-generator", name: "generator", content: "Lumina AI" },
+  ],
+  injections: [
+    {
+      key: "lumina-public-style",
+      type: "style",
+      placement: "head",
+      content: ".lumina-badge{font:500 12px system-ui}",
+      condition: { area: "public" },
+    },
+    {
+      key: "lumina-widget",
+      type: "html",
+      placement: "body:end",
+      content: '<div class="lumina-badge">Lumina active</div>',
+      condition: {
+        area: "public",
+        excludePaths: ["/admin/*"],
+      },
+    },
+    {
+      key: "lumina-admin-script",
+      type: "script",
+      placement: "admin:footer",
+      defer: true,
+      content: "window.__LUMINA_PLUGIN__={enabled:true};",
+      condition: { area: "admin" },
+    },
+  ],
+});
+```
+
+When you create a plugin locally with `new Plugin()`, `provider` is required and the exact value you provide is used. For GitHub-loaded `.plugin` files, `provider` and `iconUrl` from the file are ignored.
+
+Ready-to-use example: `@voilabs/plugins/examples/lumina`.
+
+## Plugin Manager
+
+```ts
+import { MemoryPluginDatabase, PluginManager } from "@voilabs/plugins";
+import { luminaAIPlugin } from "@voilabs/plugins/examples/lumina";
+
+export const plugins = new PluginManager({
+  plugins: [luminaAIPlugin],
+  marketplaces: ["https://github.com/voilabs/plugins-marketplace"],
+  database: new MemoryPluginDatabase(),
+  encryption: {
+    encrypt: async (value) => value,
+    decrypt: async (value) => value,
+  },
+});
+
+const list = await plugins.get({ page: 1, limit: 10 });
+
+await plugins.install("voidigital-lumina", {
+  apiKey: "voi_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  email: "hello@voidigital.com",
+});
+```
+
+When `marketplaces` are provided, GitHub plugins are pulled automatically. The manager prepares itself before the first `get`, `install`, `updateConfig`, `enable`, `disable`, `uninstall`, or HTTP request. To force a refresh:
+
+```ts
+await plugins.syncMarketplaces({ force: true });
+```
+
+Supported GitHub sources:
+
+```ts
+const plugins = new PluginManager({
+  marketplaces: [
+    "https://github.com/voilabs/plugins-marketplace",
+    "voilabs/plugins-marketplace",
+    {
+      github: "voilabs/private-plugins",
+      branch: "main",
+      token: process.env.GITHUB_TOKEN,
+      files: ["marketplace.json", "plugins.json"],
+      pluginFileExtensions: [".plugin"],
+    },
+    {
+      github: "voilabs/plugins-marketplace",
+      path: "marketplaces/default",
+    },
+  ],
+  marketplaceRefreshIntervalMs: 5 * 60 * 1000,
+});
+```
+
+By default, a GitHub repository is read from two sources:
+
+- `*.plugin` files discovered through the repository tree. File names usually follow `<plugin-id>.plugin`.
+- `marketplace.json`, `plugins.json`, and `index.json` marketplace manifests.
+
+If no branch is configured, `main` and `master` are tried. If you provide a GitHub `blob` URL, that exact JSON file is used.
+
+## GitHub `.plugin` Files
+
+A `.plugin` file contains one plugin manifest as JSON. For GitHub-loaded plugins:
+
+- `provider` is always the repository owner.
+- `iconUrl` is always generated from the repository owner avatar: `https://github.com/<owner>.png?size=128`.
+- Any `provider` or `iconUrl` inside the `.plugin` file is ignored.
+
+```json
+{
+  "id": "voidigital-lumina",
+  "name": "Lumina",
+  "summary": "Generate articles with Lumina AI.",
+  "category": "content",
+  "fields": [
+    {
+      "key": "apiKey",
+      "label": "API Key",
+      "type": "secret",
+      "required": true
+    }
+  ],
+  "routes": [
+    {
+      "id": "create-article",
+      "method": "POST",
+      "path": "/articles",
+      "summary": "Creates an article through Lumina.",
+      "proxy": {
+        "url": "https://api.lumina.example/v1/articles",
+        "method": "POST",
+        "headers": {
+          "authorization": "Bearer {{config.apiKey}}",
+          "content-type": "application/json"
+        },
+        "body": {
+          "title": "{{body.title}}",
+          "email": "{{config.email}}"
+        }
+      }
+    }
+  ],
+  "injections": [
+    {
+      "key": "lumina-widget",
+      "type": "html",
+      "placement": "body:end",
+      "content": "<div data-lumina-widget></div>"
+    }
+  ]
+}
+```
+
+Example repository:
+
+```text
+plugins-marketplace/
+  voidigital-lumina.plugin
+  analytics-pixel.plugin
+  commerce/iyzico.plugin
+```
+
+If you set `path`, only `.plugin` files under that folder are read.
+
+GitHub-loaded plugins support the same manifest surface as local plugins: routes, frontend components, injections, meta tags, assets, permissions, webhooks, and more. Since JSON cannot carry JavaScript functions, remote plugin routes use declarative actions:
+
+```json
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/status",
+      "response": {
+        "status": 200,
+        "body": {
+          "ok": true,
+          "plugin": "remote"
+        }
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/articles",
+      "proxy": {
+        "url": "https://api.example.com/articles",
+        "method": "POST",
+        "headers": {
+          "authorization": "Bearer {{config.apiKey}}"
+        },
+        "forwardBody": true
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/docs",
+      "redirect": {
+        "to": "https://docs.example.com/plugins/{{params.id}}",
+        "status": 302
+      }
+    }
+  ]
+}
+```
+
+Route template variables:
+
+- `{{params.id}}`
+- `{{query.page}}`
+- `{{body.title}}`
+- `{{config.apiKey}}`
+- `{{tenantId}}`
+- `{{locals.userId}}`
+
+Declarative routes run only when the plugin is installed and enabled by default. Override this per route with `requiresInstallation` and `requiresEnabled`.
+
+## Custom Database Adapter
+
+```ts
+const plugins = new PluginManager({
+  database: {
+    load: async (pluginId, scope) => null,
+    save: async (installation) => installation,
+    update: async (pluginId, patch, scope) => undefined,
+    delete: async (pluginId, scope) => undefined,
+  },
+});
+```
+
+## Elysia Adapter
+
+```ts
+import { Elysia } from "elysia";
+import { elysiaPluginRoutes } from "@voilabs/plugins/adapters/elysia";
+import { plugins } from "./plugins";
+
+new Elysia()
+  .use(elysiaPluginRoutes(plugins, { prefix: "/plugins" }))
+  .listen(3000);
+```
+
+Example endpoints:
+
+- `GET /plugins?page=1&limit=10`
+- `GET /plugins/voidigital-lumina`
+- `POST /plugins/voidigital-lumina/install`
+- `PATCH /plugins/voidigital-lumina/config`
+- `POST /plugins/voidigital-lumina/articles`
+- `GET /plugins/injections?area=public&placement=head`
+
+## Script and HTML Injection
+
+Plugins can define static or dynamic injections:
+
+```ts
+const analyticsPlugin = new Plugin({
+  id: "analytics-pixel",
+  name: "Analytics Pixel",
+  summary: "Adds a tracking script to the site.",
+  category: "analytics",
+  provider: "voilabs",
+  fields: [
+    { key: "pixelId", label: "Pixel ID", type: "text", required: true },
+  ],
+  injections: [
+    {
+      key: "pixel-script",
+      type: "script",
+      placement: "public:footer",
+      async: true,
+      render: ({ config }) => `
+        window.pixelId=${JSON.stringify(config.pixelId)};
+        console.log("pixel loaded");
+      `,
+    },
+    {
+      key: "verify-meta",
+      type: "meta",
+      placement: "head",
+      attributes: {
+        name: "analytics-verification",
+        content: "abc123",
+      },
+    },
+  ],
+});
+```
+
+Inject into a full SSR HTML document:
+
+```ts
+const html = await renderPage();
+
+return await plugins.injectHtml(html, {
+  area: "public",
+  url: "https://example.com/blog/hello",
+  nonce: cspNonce,
+});
+```
+
+Render only a specific placement:
+
+```ts
+const headHtml = await plugins.renderInjections({
+  area: "public",
+  placement: "head",
+  nonce: cspNonce,
+});
+```
+
+Only installed and enabled plugins can inject by default. To include marketplace plugins that are not installed:
+
+```ts
+await plugins.renderInjections({
+  area: "public",
+  installedOnly: false,
+  enabledOnly: false,
+});
+```
+
+## Next.js App Router Adapter
+
+```ts
+// app/api/plugins/[...voilabs]/route.ts
+import { createNextPluginRouteHandlers } from "@voilabs/plugins/adapters/next";
+import { plugins } from "@/server/plugins";
+
+export const { GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD } =
+  createNextPluginRouteHandlers(plugins, {
+    prefix: "/api/plugins",
+  });
+```
+
+## React Integration
+
+React is not imported by the package. Pass your app's React object into the integration factory.
+
+```tsx
+import * as React from "react";
+import { createPluginReactIntegration } from "@voilabs/plugins/react";
+
+const { PluginProvider, usePlugins } = createPluginReactIntegration(React, {
+  baseUrl: "/api/plugins",
+});
+
+function PluginList() {
+  const { data, loading, error } = usePlugins({ page: 1, limit: 10 });
+
+  if (loading) return <div>Loading</div>;
+  if (error) return <div>Something went wrong</div>;
+
+  return (
+    <ul>
+      {data?.data.map((plugin) => (
+        <li key={plugin.id}>{plugin.name}</li>
+      ))}
+    </ul>
+  );
+}
+
+export function App() {
+  return (
+    <PluginProvider>
+      <PluginList />
+    </PluginProvider>
+  );
+}
+```
+
+## Marketplace JSON Format
+
+Marketplace JSON can be either an array or an object:
+
+```json
+{
+  "name": "Voilabs Plugins",
+  "plugins": [
+    {
+      "id": "voidigital-lumina",
+      "name": "Lumina",
+      "summary": "Generate articles with Lumina AI.",
+      "category": "content",
+      "fields": []
+    }
+  ]
+}
+```
+
+When a GitHub repository URL is provided, `<plugin-id>.plugin` files are discovered first. `marketplace.json`, `plugins.json`, and `index.json` are also tried.
+
+## Integration Prompts
+
+Use one of the following prompts inside the target project when you want a coding agent to integrate `@voilabs/plugins`.
+
+### Prompt: Next.js + Elysia.js
+
+```text
+Integrate @voilabs/plugins into this project using Next.js for the frontend/admin UI and Elysia.js for the plugin API runtime.
+
+Goals:
+- Use GitHub marketplace repositories as the plugin source.
+- Automatically discover <plugin-id>.plugin files from the configured GitHub repo.
+- Treat the GitHub repo owner as the provider for remote plugins.
+- Use the GitHub owner avatar as the plugin icon.
+- Ignore provider and iconUrl values inside remote .plugin files.
+- Support plugin fields, install/update/enable/disable/uninstall, declarative routes, proxy routes, redirects, frontend component manifests, and HTML/script/style injections.
+
+Backend/Elysia work:
+1. Create a singleton plugin manager, for example in src/server/plugins.ts:
+   - import { PluginManager, MemoryPluginDatabase } from "@voilabs/plugins"
+   - configure marketplaces: ["<github-owner>/<plugins-repo>"]
+   - use MemoryPluginDatabase initially if no persistent storage exists
+   - add an encryption provider placeholder, but keep the API ready for production encryption
+2. Mount the plugin API into Elysia:
+   - import { elysiaPluginRoutes } from "@voilabs/plugins/adapters/elysia"
+   - use elysiaPluginRoutes(plugins, { prefix: "/plugins" })
+3. Make sure the Elysia server exposes:
+   - GET /plugins
+   - GET /plugins/:pluginId
+   - POST /plugins/:pluginId/install
+   - PATCH /plugins/:pluginId/config
+   - POST /plugins/:pluginId/enable
+   - POST /plugins/:pluginId/disable
+   - DELETE /plugins/:pluginId
+   - custom plugin routes such as /plugins/:pluginId/articles
+   - GET /plugins/injections?area=public&placement=head
+4. If Next.js and Elysia run on different ports, proxy /api/plugins/* from Next.js to the Elysia /plugins/* API.
+
+Next.js/React work:
+1. Add createPluginReactIntegration from @voilabs/plugins/react.
+2. Create a PluginProvider bound to the Elysia API base URL, usually /api/plugins.
+3. Build or wire an admin plugin screen:
+   - list plugins with iconUrl, name, provider, summary, category, installed/enabled state
+   - generate config forms from plugin.fields
+   - support secret fields without echoing plain secret values back into the UI
+   - install, update config, enable, disable, and uninstall plugins
+4. Render frontend component manifests through a local component registry:
+   - support component.type === "registry"
+   - ignore unknown registry components safely
+5. Add injection support:
+   - head injections: render via the API or server helper and place into the document head
+   - body/footer injections: provide slots in the app layout
+   - pass CSP nonce if this project uses CSP
+
+Verification:
+- Run TypeScript checks and the project build.
+- Verify GitHub .plugin discovery with at least one plugin that does not define provider or iconUrl.
+- Confirm the UI shows provider as the GitHub owner and icon as the GitHub avatar.
+- Confirm install + enable works.
+- Confirm a declarative route using response/proxy/redirect works.
+- Confirm script/style/html injections render only for installed and enabled plugins by default.
+```
+
+### Prompt: Native Next.js
+
+```text
+Integrate @voilabs/plugins into this native Next.js project.
+
+Goals:
+- Use Next.js App Router API routes for the plugin runtime.
+- Use React integration for the admin/plugin UI.
+- Load remote plugins from GitHub marketplace repositories and <plugin-id>.plugin files.
+- Remote plugin provider must always be the GitHub repo owner.
+- Remote plugin iconUrl must always be the GitHub owner avatar.
+- Ignore provider and iconUrl fields inside GitHub-loaded plugin files.
+
+Server work:
+1. Create src/server/plugins.ts:
+   - instantiate PluginManager from @voilabs/plugins
+   - configure marketplaces: ["<github-owner>/<plugins-repo>"]
+   - use MemoryPluginDatabase as a temporary adapter if no DB adapter exists
+   - add encryption provider hooks for secret fields
+2. Create app/api/plugins/[...voilabs]/route.ts:
+   - import createNextPluginRouteHandlers from @voilabs/plugins/adapters/next
+   - export GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD from createNextPluginRouteHandlers(plugins, { prefix: "/api/plugins" })
+3. Ensure the following routes work:
+   - GET /api/plugins
+   - GET /api/plugins/:pluginId
+   - POST /api/plugins/:pluginId/install
+   - PATCH /api/plugins/:pluginId/config
+   - POST /api/plugins/:pluginId/enable
+   - POST /api/plugins/:pluginId/disable
+   - custom plugin routes under /api/plugins/:pluginId/*
+
+React/admin work:
+1. Create a plugin React integration module:
+   - import * as React from "react"
+   - import { createPluginReactIntegration } from "@voilabs/plugins/react"
+   - set baseUrl to "/api/plugins"
+2. Wrap the admin app or layout with PluginProvider.
+3. Build or integrate an admin Plugins page:
+   - use usePlugins({ page: 1, limit: 20 })
+   - show icon, name, provider, summary, category, installed/enabled status
+   - generate install/config forms from plugin.fields
+   - handle secret fields carefully and do not display stored secrets as plain text
+   - wire install, updateConfig, enable, disable, uninstall
+4. Add support for plugin frontend manifests:
+   - resolve frontend.components with a local registry map
+   - render known registry components in their slots
+5. Add injection support:
+   - for server layouts, call plugins.renderInjections({ area: "public", placement: "head", nonce })
+   - create safe body/footer slots for public and admin injections
+   - ensure injections are rendered only for installed and enabled plugins by default
+
+Verification:
+- Run lint/typecheck/build.
+- Test a GitHub .plugin file without provider/iconUrl.
+- Confirm provider is GitHub owner and iconUrl is https://github.com/<owner>.png?size=128.
+- Confirm declarative response, proxy, and redirect routes work.
+- Confirm plugin injections render in the expected placements.
+```
+
+### Prompt: Native Elysia.js
+
+```text
+Integrate @voilabs/plugins into this native Elysia.js project.
+
+Goals:
+- Use Elysia as the plugin API runtime.
+- Load plugins from GitHub marketplace repositories and <plugin-id>.plugin files.
+- GitHub-loaded plugin provider must be the GitHub repo owner.
+- GitHub-loaded plugin iconUrl must be the GitHub owner avatar.
+- Ignore provider and iconUrl fields inside remote .plugin files.
+- Support install/config/enable/disable/uninstall, declarative routes, proxy routes, redirects, and injection rendering endpoints.
+
+Implementation:
+1. Create a plugin manager singleton:
+   - import { PluginManager, MemoryPluginDatabase } from "@voilabs/plugins"
+   - configure marketplaces: ["<github-owner>/<plugins-repo>"]
+   - use MemoryPluginDatabase if no persistent DB exists yet
+   - add an encryption provider placeholder for secret fields
+2. Mount routes in Elysia:
+   - import { elysiaPluginRoutes } from "@voilabs/plugins/adapters/elysia"
+   - new Elysia().use(elysiaPluginRoutes(plugins, { prefix: "/plugins" }))
+3. Verify standard endpoints:
+   - GET /plugins
+   - GET /plugins/:pluginId
+   - POST /plugins/:pluginId/install
+   - PATCH /plugins/:pluginId/config
+   - POST /plugins/:pluginId/enable
+   - POST /plugins/:pluginId/disable
+   - DELETE /plugins/:pluginId
+   - GET /plugins/injections?area=public&placement=head
+4. Support custom remote plugin routes:
+   - response
+   - proxy
+   - redirect
+   - template variables like {{config.apiKey}}, {{body.title}}, {{query.page}}, {{params.id}}
+5. If this project serves HTML from Elysia:
+   - call await plugins.injectHtml(html, { area: "public", url: request.url, nonce })
+   - use plugins.renderInjections for specific head/body/footer slots when full HTML post-processing is not appropriate
+
+Verification:
+- Run typecheck/build/tests.
+- Mock or use a real GitHub marketplace with at least one <plugin-id>.plugin file.
+- Confirm provider and iconUrl are derived from the GitHub repo owner.
+- Install and enable the plugin.
+- Confirm declarative response/proxy/redirect routes work.
+- Confirm injections are available through /plugins/injections and render only for installed/enabled plugins by default.
+```

package/dist/adapters/elysia.d.ts

@@ -0,0 +1,31 @@
+import type { PluginHttpHandlerOptions } from "../http.js";
+import type { PluginManager } from "../manager.js";
+export interface ElysiaLike {
+    get?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    post?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    put?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    patch?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    delete?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    options?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    head?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+    all?: (path: string, handler: (context: {
+        request: Request;
+    }) => unknown) => this;
+}
+export declare function mountElysiaPluginRoutes<TApp extends ElysiaLike>(app: TApp, manager: PluginManager, options?: PluginHttpHandlerOptions): TApp;
+export declare function elysiaPluginRoutes(manager: PluginManager, options?: PluginHttpHandlerOptions): <TApp extends ElysiaLike>(app: TApp) => TApp;
+//# sourceMappingURL=elysia.d.ts.map

package/dist/adapters/elysia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elysia.d.ts","sourceRoot":"","sources":["../../src/adapters/elysia.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IAClF,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IACnF,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IAClF,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IACpF,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IACrF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IACtF,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;IACnF,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,KAAK,IAAI,CAAC;CACnF;AAED,wBAAgB,uBAAuB,CAAC,IAAI,SAAS,UAAU,EAC7D,GAAG,EAAE,IAAI,EACT,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,wBAA6B,GACrC,IAAI,CAqBN;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,wBAA6B,IAE9B,IAAI,SAAS,UAAU,EAAE,KAAK,IAAI,KAAG,IAAI,CAElD"}

package/dist/adapters/elysia.js

@@ -0,0 +1,28 @@
+import { createPluginHttpHandler } from "../http.js";
+export function mountElysiaPluginRoutes(app, manager, options = {}) {
+    const prefix = normalizePrefix(options.prefix ?? "/plugins");
+    const handler = createPluginHttpHandler(manager, {
+        ...options,
+        prefix,
+    });
+    const handle = ({ request }) => handler(request);
+    if (app.all) {
+        app.all(prefix, handle);
+        app.all(`${prefix}/*`, handle);
+        return app;
+    }
+    const methods = ["get", "post", "put", "patch", "delete", "options", "head"];
+    for (const method of methods) {
+        app[method]?.(prefix, handle);
+        app[method]?.(`${prefix}/*`, handle);
+    }
+    return app;
+}
+export function elysiaPluginRoutes(manager, options = {}) {
+    return (app) => mountElysiaPluginRoutes(app, manager, options);
+}
+function normalizePrefix(prefix) {
+    const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+    return normalized.length > 1 ? normalized.replace(/\/+$/, "") : normalized;
+}
+//# sourceMappingURL=elysia.js.map