gorsee 0.2.3 → 0.2.5

package/dist-pkg/plugins/drizzle.js

@@ -0,0 +1,50 @@
+import { definePlugin } from "./index.js";
+let drizzleInstance = null;
+export function getDrizzle() {
+  if (!drizzleInstance)
+    throw Error("Drizzle not initialized. Did you register drizzlePlugin?");
+  return drizzleInstance;
+}
+export function drizzleMiddleware(instance) {
+  return async (ctx, next) => {
+    ctx.locals.db = instance;
+    return next();
+  };
+}
+export function generateDrizzleConfig(config) {
+  const dbCredentials = config.dialect === "sqlite" ? `{ url: "${config.connectionUrl ?? "./data.db"}" }` : `{ connectionString: "${config.connectionUrl ?? ""}" }`;
+  return `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "${config.schema}",
+  out: "${config.out}",
+  dialect: "${config.dialect}",
+  dbCredentials: ${dbCredentials},
+})
+`;
+}
+export function drizzlePlugin(config) {
+  return definePlugin({
+    name: "gorsee-drizzle",
+    capabilities: ["db"],
+    async setup(app) {
+      if (config.dialect === "sqlite") {
+        const { Database } = await import("bun:sqlite"), db = new Database(config.connectionUrl ?? "./data.db");
+        db.exec("PRAGMA journal_mode=WAL");
+        try {
+          const { drizzle } = await import("drizzle-orm/bun-sqlite");
+          drizzleInstance = drizzle(db);
+        } catch {
+          drizzleInstance = db;
+        }
+      } else
+        drizzleInstance = { dialect: config.dialect, url: config.connectionUrl };
+      app.addMiddleware(drizzleMiddleware(drizzleInstance));
+    },
+    async teardown() {
+      if (drizzleInstance && typeof drizzleInstance.close === "function")
+        drizzleInstance.close();
+      drizzleInstance = null;
+    }
+  });
+}

package/dist-pkg/plugins/index.d.ts

@@ -0,0 +1,62 @@
+import type { MiddlewareFn, Context } from "../server/middleware.js";
+import type { BuildRuntimeTarget, FrameworkBuildPlugin } from "../build/plugin.js";
+export { defineBuildPlugin, resolveBuildPluginsForTarget, type BuildRuntimeTarget, type FrameworkBuildPlugin, } from "../build/plugin.js";
+export type PluginPhase = "runtime" | "dev" | "build" | "test";
+export type PluginCapability = "middleware" | "routes" | "build" | "runtime" | "dev" | "test" | "auth" | "db" | "storage" | "payments" | "email" | "styling";
+export interface PluginConfigValidationIssue {
+    path: string;
+    message: string;
+}
+export interface PluginLifecycleContext extends PluginContext {
+    phase: PluginPhase;
+    plugin: PluginDescriptor;
+}
+export interface PluginLifecycle {
+    runtime?: (app: PluginLifecycleContext) => void | Promise<void>;
+    dev?: (app: PluginLifecycleContext) => void | Promise<void>;
+    build?: (app: PluginLifecycleContext) => void | Promise<void>;
+    test?: (app: PluginLifecycleContext) => void | Promise<void>;
+}
+export interface GorseePlugin {
+    name: string;
+    version?: string;
+    capabilities?: PluginCapability[];
+    dependsOn?: string[];
+    order?: {
+        before?: string[];
+        after?: string[];
+    };
+    configSchema?: (config: Record<string, unknown>) => PluginConfigValidationIssue[] | void;
+    setup?: (app: PluginContext) => void | Promise<void>;
+    middleware?: MiddlewareFn;
+    buildPlugins?: () => FrameworkBuildPlugin[];
+    teardown?: () => void | Promise<void>;
+    lifecycle?: PluginLifecycle;
+}
+export interface PluginDescriptor {
+    name: string;
+    version?: string;
+    capabilities: PluginCapability[];
+    dependsOn: string[];
+    before: string[];
+    after: string[];
+}
+export interface PluginContext {
+    addMiddleware(mw: MiddlewareFn): void;
+    addRoute(path: string, handler: (ctx: Context) => Promise<Response>): void;
+    config: Record<string, unknown>;
+    getConfig?<T extends Record<string, unknown> = Record<string, unknown>>(): T;
+}
+export declare function definePlugin<T extends GorseePlugin>(plugin: T): T;
+export interface PluginRunner {
+    register(plugin: GorseePlugin): void;
+    setupAll(): Promise<void>;
+    runPhase(phase: PluginPhase): Promise<void>;
+    teardownAll(): Promise<void>;
+    getMiddlewares(): MiddlewareFn[];
+    getBuildPlugins(target?: BuildRuntimeTarget): FrameworkBuildPlugin[];
+    getRoutes(): Map<string, (ctx: Context) => Promise<Response>>;
+    getPluginDescriptors(): PluginDescriptor[];
+    getCapabilities(): PluginCapability[];
+}
+export declare function createPluginRunner(config?: Record<string, unknown>): PluginRunner;

package/dist-pkg/plugins/index.js

@@ -0,0 +1,147 @@
+export {
+  defineBuildPlugin,
+  resolveBuildPluginsForTarget
+} from "../build/plugin.js";
+export function definePlugin(plugin) {
+  return plugin;
+}
+function normalizeCapabilities(plugin) {
+  const capabilities = new Set(plugin.capabilities ?? []);
+  if (plugin.middleware)
+    capabilities.add("middleware");
+  if (plugin.buildPlugins)
+    capabilities.add("build");
+  if (plugin.lifecycle?.build)
+    capabilities.add("build");
+  if (plugin.lifecycle?.dev)
+    capabilities.add("dev");
+  if (plugin.lifecycle?.runtime || plugin.setup)
+    capabilities.add("runtime");
+  if (plugin.lifecycle?.test)
+    capabilities.add("test");
+  return [...capabilities].sort();
+}
+function describePlugin(plugin) {
+  return {
+    name: plugin.name,
+    version: plugin.version,
+    capabilities: normalizeCapabilities(plugin),
+    dependsOn: [...plugin.dependsOn ?? []],
+    before: [...plugin.order?.before ?? []],
+    after: [...plugin.order?.after ?? []]
+  };
+}
+function validatePluginConfig(plugin, config) {
+  const issues = plugin.configSchema?.(config) ?? [];
+  if (!issues.length)
+    return;
+  const rendered = issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
+  throw Error(`Plugin "${plugin.name}" config validation failed: ${rendered}`);
+}
+function sortPlugins(plugins) {
+  const byName = new Map(plugins.map((plugin) => [plugin.name, plugin])), edges = new Map, incoming = new Map;
+  for (const plugin of plugins) {
+    edges.set(plugin.name, new Set);
+    incoming.set(plugin.name, 0);
+  }
+  function addEdge(from, to) {
+    if (!byName.has(from) || !byName.has(to) || from === to)
+      return;
+    const targets = edges.get(from);
+    if (targets.has(to))
+      return;
+    targets.add(to);
+    incoming.set(to, (incoming.get(to) ?? 0) + 1);
+  }
+  for (const plugin of plugins) {
+    for (const dependency of plugin.dependsOn ?? []) {
+      if (!byName.has(dependency))
+        throw Error(`Plugin "${plugin.name}" depends on missing plugin "${dependency}"`);
+      addEdge(dependency, plugin.name);
+    }
+    for (const after of plugin.order?.after ?? []) {
+      if (!byName.has(after))
+        throw Error(`Plugin "${plugin.name}" declares unknown order.after target "${after}"`);
+      addEdge(after, plugin.name);
+    }
+    for (const before of plugin.order?.before ?? []) {
+      if (!byName.has(before))
+        throw Error(`Plugin "${plugin.name}" declares unknown order.before target "${before}"`);
+      addEdge(plugin.name, before);
+    }
+  }
+  const queue = [...plugins].filter((plugin) => (incoming.get(plugin.name) ?? 0) === 0).sort((left, right) => left.name.localeCompare(right.name)), ordered = [];
+  while (queue.length > 0) {
+    const plugin = queue.shift();
+    ordered.push(plugin);
+    for (const target of edges.get(plugin.name) ?? []) {
+      incoming.set(target, (incoming.get(target) ?? 1) - 1);
+      if ((incoming.get(target) ?? 0) === 0) {
+        queue.push(byName.get(target));
+        queue.sort((left, right) => left.name.localeCompare(right.name));
+      }
+    }
+  }
+  if (ordered.length !== plugins.length)
+    throw Error("Plugin ordering contains a cycle.");
+  return ordered;
+}
+export function createPluginRunner(config = {}) {
+  const plugins = [], middlewares = [], routes = new Map, pluginCtx = {
+    addMiddleware: (mw) => middlewares.push(mw),
+    addRoute: (path, handler) => routes.set(path, handler),
+    config,
+    getConfig() {
+      return config;
+    }
+  };
+  async function runPluginPhase(plugin, phase) {
+    const descriptor = describePlugin(plugin), ctx = { ...pluginCtx, phase, plugin: descriptor };
+    if (phase === "runtime" && plugin.setup)
+      await plugin.setup(pluginCtx);
+    const hook = plugin.lifecycle?.[phase];
+    if (hook)
+      await hook(ctx);
+  }
+  function getOrderedPlugins() {
+    return sortPlugins(plugins);
+  }
+  return {
+    register(plugin) {
+      if (plugins.some((entry) => entry.name === plugin.name))
+        throw Error(`Plugin "${plugin.name}" is already registered.`);
+      validatePluginConfig(plugin, config);
+      plugins.push(plugin);
+      if (plugin.middleware)
+        middlewares.push(plugin.middleware);
+    },
+    async setupAll() {
+      for (const plugin of getOrderedPlugins())
+        await runPluginPhase(plugin, "runtime");
+    },
+    async runPhase(phase) {
+      for (const plugin of getOrderedPlugins())
+        await runPluginPhase(plugin, phase);
+    },
+    async teardownAll() {
+      for (const plugin of [...getOrderedPlugins()].reverse())
+        if (plugin.teardown)
+          await plugin.teardown();
+    },
+    getMiddlewares: () => [...middlewares],
+    getBuildPlugins(_target) {
+      const result = [];
+      for (const plugin of getOrderedPlugins())
+        if (plugin.buildPlugins)
+          result.push(...plugin.buildPlugins());
+      return result;
+    },
+    getRoutes: () => new Map(routes),
+    getPluginDescriptors() {
+      return getOrderedPlugins().map((plugin) => describePlugin(plugin));
+    },
+    getCapabilities() {
+      return [...new Set(getOrderedPlugins().flatMap((plugin) => describePlugin(plugin).capabilities))].sort();
+    }
+  };
+}

package/dist-pkg/plugins/lucia.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from "../server/middleware.js";
+import type { GorseePlugin } from "./index.js";
+export interface LuciaPluginConfig {
+    adapter: "sqlite" | "prisma" | "drizzle";
+    sessionTable?: string;
+    userTable?: string;
+}
+interface LuciaInstance {
+    validateSession(sessionId: string): Promise<{
+        session: unknown;
+        user: unknown;
+    } | null>;
+    createSession(userId: string, attributes?: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    invalidateSession(sessionId: string): Promise<void>;
+}
+/** Returns the Lucia instance (available after setup) */
+export declare function getLucia(): LuciaInstance;
+/** Extracts current session from context (set by middleware) */
+export declare function getSession(ctx: Context): unknown | null;
+/** Extracts current user from context (set by middleware) */
+export declare function getUser(ctx: Context): unknown | null;
+/** Creates a Lucia auth integration plugin */
+export declare function luciaPlugin(config: LuciaPluginConfig): GorseePlugin;
+export {};

package/dist-pkg/plugins/lucia.js

@@ -0,0 +1,63 @@
+import { definePlugin } from "./index.js";
+let luciaInstance = null;
+export function getLucia() {
+  if (!luciaInstance)
+    throw Error("Lucia not initialized. Did you register luciaPlugin?");
+  return luciaInstance;
+}
+export function getSession(ctx) {
+  return ctx.locals.session ?? null;
+}
+export function getUser(ctx) {
+  return ctx.locals.user ?? null;
+}
+function createSessionMiddleware() {
+  return async (ctx, next) => {
+    ctx.locals.session = null;
+    ctx.locals.user = null;
+    const sessionId = ctx.cookies.get("auth_session") ?? ctx.request.headers.get("Authorization")?.replace("Bearer ", "") ?? null;
+    if (sessionId && luciaInstance)
+      try {
+        const result = await luciaInstance.validateSession(sessionId);
+        if (result) {
+          ctx.locals.session = result.session;
+          ctx.locals.user = result.user;
+        }
+      } catch {}
+    return next();
+  };
+}
+export function luciaPlugin(config) {
+  return definePlugin({
+    name: "gorsee-lucia",
+    capabilities: ["auth"],
+    async setup() {
+      try {
+        const { Lucia } = await import("lucia");
+        let adapter;
+        if (config.adapter === "sqlite") {
+          const { BunSQLiteAdapter } = await import("@lucia-auth/adapter-sqlite"), { Database } = await import("bun:sqlite"), db = new Database("./data.db");
+          adapter = new BunSQLiteAdapter(db, {
+            session: config.sessionTable ?? "session",
+            user: config.userTable ?? "user"
+          });
+        } else if (config.adapter === "prisma") {
+          const { PrismaAdapter } = await import("@lucia-auth/adapter-prisma"), { PrismaClient } = await import("@prisma/client");
+          adapter = new PrismaAdapter(new PrismaClient, {
+            session: config.sessionTable ?? "session",
+            user: config.userTable ?? "user"
+          });
+        } else
+          adapter = null;
+        if (adapter)
+          luciaInstance = new Lucia(adapter);
+      } catch {
+        luciaInstance = null;
+      }
+    },
+    middleware: createSessionMiddleware(),
+    async teardown() {
+      luciaInstance = null;
+    }
+  });
+}

package/dist-pkg/plugins/prisma.d.ts

@@ -0,0 +1,14 @@
+import type { MiddlewareFn } from "../server/middleware.js";
+import type { GorseePlugin } from "./index.js";
+export interface PrismaPluginConfig {
+    schemaPath?: string;
+    datasourceUrl?: string;
+}
+/** Returns the current Prisma client (available after setup) */
+export declare function getPrisma<T = unknown>(): T;
+/** Middleware that attaches prisma to ctx.locals.prisma */
+export declare function prismaMiddleware(client: unknown): MiddlewareFn;
+/** Generates a basic schema.prisma content string */
+export declare function generatePrismaSchema(config: PrismaPluginConfig): string;
+/** Creates a Prisma integration plugin */
+export declare function prismaPlugin(config?: PrismaPluginConfig): GorseePlugin;

package/dist-pkg/plugins/prisma.js

@@ -0,0 +1,57 @@
+import { definePlugin } from "./index.js";
+let prismaClient = null;
+export function getPrisma() {
+  if (!prismaClient)
+    throw Error("Prisma not initialized. Did you register prismaPlugin?");
+  return prismaClient;
+}
+export function prismaMiddleware(client) {
+  return async (ctx, next) => {
+    ctx.locals.prisma = client;
+    return next();
+  };
+}
+export function generatePrismaSchema(config) {
+  const url = config.datasourceUrl ?? "file:./dev.db";
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${url.startsWith("file:") ? "sqlite" : url.startsWith("postgres") ? "postgresql" : "mysql"}"
+  url      = "${url}"
+}
+
+// Add your models below
+// model User {
+//   id    Int     @id @default(autoincrement())
+//   email String  @unique
+//   name  String?
+// }
+`;
+}
+export function prismaPlugin(config = {}) {
+  return definePlugin({
+    name: "gorsee-prisma",
+    capabilities: ["db"],
+    async setup(app) {
+      try {
+        const { PrismaClient } = await import("@prisma/client");
+        prismaClient = new PrismaClient({
+          datasourceUrl: config.datasourceUrl
+        });
+      } catch {
+        prismaClient = {
+          _placeholder: !0,
+          _message: "Run `bunx prisma generate` to create the client"
+        };
+      }
+      app.addMiddleware(prismaMiddleware(prismaClient));
+    },
+    async teardown() {
+      if (prismaClient && typeof prismaClient.$disconnect === "function")
+        await prismaClient.$disconnect();
+      prismaClient = null;
+    }
+  });
+}

package/dist-pkg/plugins/resend.d.ts

@@ -0,0 +1,21 @@
+import type { GorseePlugin } from "./index.js";
+export interface ResendPluginConfig {
+    apiKey: string;
+    from?: string;
+}
+export interface SendEmailOptions {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    from?: string;
+}
+export interface Mailer {
+    send(options: SendEmailOptions): Promise<{
+        id: string;
+    }>;
+}
+/** Returns the mailer instance (available after setup) */
+export declare function getMailer(): Mailer;
+/** Creates a Resend email plugin */
+export declare function resendPlugin(config: ResendPluginConfig): GorseePlugin;

package/dist-pkg/plugins/resend.js

@@ -0,0 +1,45 @@
+import { definePlugin } from "./index.js";
+const RESEND_API = "https://api.resend.com";
+let mailerInstance = null;
+export function getMailer() {
+  if (!mailerInstance)
+    throw Error("Resend not initialized. Did you register resendPlugin?");
+  return mailerInstance;
+}
+function createMailer(config) {
+  return {
+    async send(options) {
+      const body = {
+        from: options.from ?? config.from ?? "onboarding@resend.dev",
+        to: Array.isArray(options.to) ? options.to : [options.to],
+        subject: options.subject,
+        ...options.html ? { html: options.html } : {},
+        ...options.text ? { text: options.text } : {}
+      }, res = await fetch(`${RESEND_API}/emails`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const err = await res.text();
+        throw Error(`Resend API error (${res.status}): ${err}`);
+      }
+      return await res.json();
+    }
+  };
+}
+export function resendPlugin(config) {
+  return definePlugin({
+    name: "gorsee-resend",
+    capabilities: ["email"],
+    async setup() {
+      mailerInstance = createMailer(config);
+    },
+    async teardown() {
+      mailerInstance = null;
+    }
+  });
+}

package/dist-pkg/plugins/s3.d.ts

@@ -0,0 +1,18 @@
+import type { GorseePlugin } from "./index.js";
+export interface S3PluginConfig {
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+}
+export interface StorageClient {
+    upload(key: string, body: ArrayBuffer | ReadableStream | string, contentType?: string): Promise<string>;
+    download(key: string): Promise<Response>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<string[]>;
+}
+/** Returns the storage client (available after setup) */
+export declare function getStorage(): StorageClient;
+/** Creates an S3-compatible storage plugin */
+export declare function s3Plugin(config: S3PluginConfig): GorseePlugin;

package/dist-pkg/plugins/s3.js

@@ -0,0 +1,63 @@
+import { definePlugin } from "./index.js";
+let storageClient = null;
+export function getStorage() {
+  if (!storageClient)
+    throw Error("S3 not initialized. Did you register s3Plugin?");
+  return storageClient;
+}
+function buildEndpoint(config) {
+  if (config.endpoint)
+    return config.endpoint.replace(/\/$/, "");
+  const region = config.region ?? "us-east-1";
+  return `https://${config.bucket}.s3.${region}.amazonaws.com`;
+}
+function createStorageClient(config) {
+  const baseUrl = buildEndpoint(config), headers = {};
+  if (config.accessKeyId)
+    headers["x-amz-access-key"] = config.accessKeyId;
+  return {
+    async upload(key, body, contentType) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`, ct = contentType ?? "application/octet-stream", fetchBody = body instanceof ArrayBuffer ? new Blob([body], { type: ct }) : body, res = await fetch(url, {
+        method: "PUT",
+        headers: { ...headers, "Content-Type": ct },
+        body: fetchBody
+      });
+      if (!res.ok)
+        throw Error(`S3 upload failed: ${res.status} ${res.statusText}`);
+      return url;
+    },
+    async download(key) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`, res = await fetch(url, { headers });
+      if (!res.ok)
+        throw Error(`S3 download failed: ${res.status} ${res.statusText}`);
+      return res;
+    },
+    async delete(key) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`, res = await fetch(url, { method: "DELETE", headers });
+      if (!res.ok)
+        throw Error(`S3 delete failed: ${res.status} ${res.statusText}`);
+    },
+    async list(prefix) {
+      const params = prefix ? `?list-type=2&prefix=${encodeURIComponent(prefix)}` : "?list-type=2", res = await fetch(`${baseUrl}${params}`, { headers });
+      if (!res.ok)
+        throw Error(`S3 list failed: ${res.status} ${res.statusText}`);
+      const xml = await res.text(), keys = [], regex = /<Key>([^<]+)<\/Key>/g;
+      let match;
+      while ((match = regex.exec(xml)) !== null)
+        keys.push(match[1]);
+      return keys;
+    }
+  };
+}
+export function s3Plugin(config) {
+  return definePlugin({
+    name: "gorsee-s3",
+    capabilities: ["storage"],
+    async setup() {
+      storageClient = createStorageClient(config);
+    },
+    async teardown() {
+      storageClient = null;
+    }
+  });
+}

package/dist-pkg/plugins/stripe.d.ts

@@ -0,0 +1,32 @@
+import type { GorseePlugin } from "./index.js";
+export interface StripePluginConfig {
+    secretKey: string;
+    webhookSecret?: string;
+}
+export interface CheckoutSessionOptions {
+    lineItems: Array<{
+        price: string;
+        quantity: number;
+    }>;
+    mode?: "payment" | "subscription";
+    successUrl: string;
+    cancelUrl: string;
+}
+export interface StripeEvent {
+    id: string;
+    type: string;
+    data: {
+        object: Record<string, unknown>;
+    };
+}
+export interface StripeClient {
+    createCheckoutSession(options: CheckoutSessionOptions): Promise<{
+        url: string;
+        id: string;
+    }>;
+    verifyWebhook(request: Request): Promise<StripeEvent>;
+}
+/** Returns the Stripe client (available after setup) */
+export declare function getStripe(): StripeClient;
+/** Creates a Stripe payments plugin */
+export declare function stripePlugin(config: StripePluginConfig): GorseePlugin;

package/dist-pkg/plugins/stripe.js

@@ -0,0 +1,69 @@
+import { definePlugin } from "./index.js";
+const STRIPE_API = "https://api.stripe.com/v1";
+let stripeClient = null;
+export function getStripe() {
+  if (!stripeClient)
+    throw Error("Stripe not initialized. Did you register stripePlugin?");
+  return stripeClient;
+}
+function createStripeClient(config) {
+  const authHeader = `Basic ${btoa(config.secretKey + ":")}`;
+  return {
+    async createCheckoutSession(options) {
+      const params = new URLSearchParams;
+      params.set("mode", options.mode ?? "payment");
+      params.set("success_url", options.successUrl);
+      params.set("cancel_url", options.cancelUrl);
+      options.lineItems.forEach((item, i) => {
+        params.set(`line_items[${i}][price]`, item.price);
+        params.set(`line_items[${i}][quantity]`, String(item.quantity));
+      });
+      const res = await fetch(`${STRIPE_API}/checkout/sessions`, {
+        method: "POST",
+        headers: { Authorization: authHeader, "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString()
+      });
+      if (!res.ok) {
+        const err = await res.text();
+        throw Error(`Stripe API error (${res.status}): ${err}`);
+      }
+      const data = await res.json();
+      return { url: data.url, id: data.id };
+    },
+    async verifyWebhook(request) {
+      const body = await request.text(), sig = request.headers.get("stripe-signature") ?? "";
+      if (!config.webhookSecret)
+        throw Error("Webhook secret not configured");
+      const encoder = new TextEncoder, timestamp = sig.split(",").find((s) => s.startsWith("t="))?.slice(2) ?? "", v1Sig = sig.split(",").find((s) => s.startsWith("v1="))?.slice(3) ?? "", payload = `${timestamp}.${body}`, key = await crypto.subtle.importKey("raw", encoder.encode(config.webhookSecret), { name: "HMAC", hash: "SHA-256" }, !1, ["sign"]), signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+      if (Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("") !== v1Sig)
+        throw Error("Invalid webhook signature");
+      return JSON.parse(body);
+    }
+  };
+}
+export function stripePlugin(config) {
+  const capabilities = ["payments"];
+  if (config.webhookSecret)
+    capabilities.push("routes");
+  return definePlugin({
+    name: "gorsee-stripe",
+    capabilities,
+    async setup(app) {
+      stripeClient = createStripeClient(config);
+      if (config.webhookSecret)
+        app.addRoute("/api/stripe/webhook", async (ctx) => {
+          try {
+            const event = await stripeClient.verifyWebhook(ctx.request);
+            return new Response(JSON.stringify({ received: !0, type: event.type }), {
+              headers: { "Content-Type": "application/json" }
+            });
+          } catch (err) {
+            return new Response(JSON.stringify({ error: String(err) }), { status: 400 });
+          }
+        });
+    },
+    async teardown() {
+      stripeClient = null;
+    }
+  });
+}