@frigear-nu/stripe 0.0.0-stage → 0.0.2

package/README.md

@@ -1,3 +1,76 @@
-# Temporary Holding Version
+# @frigear-nu/stripe
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Core Stripe plumbing for the frigear ecosystem. It owns the SDK, the user <-> Stripe customer link and a single
+verified, idempotent webhook that other modules (subscriptions, payments, ...) subscribe to. It contains no product
+logic itself.
+
+## Setup
+
+```ts
+export default defineNuxtConfig({
+  modules: ['@nuxthub/core', '@frigear-nu/users', '@frigear-nu/stripe'],
+  hub: { db: { dialect: 'sqlite', driver: 'libsql' }, kv: true }, // kv is required (webhook idempotency)
+  stripe: { settings: { webhookPath: '/api/stripe/webhook' } }, // optional, this is the default
+})
+```
+
+`unstorage` must be resolvable by the host app (NuxtHub KV needs it).
+
+Environment variables:
+
+| Variable                             | Purpose                                         |
+| ------------------------------------ | ----------------------------------------------- |
+| `NUXT_STRIPE_SECRET_KEY`             | Stripe secret key (`runtimeConfig.stripe.secretKey`) |
+| `NUXT_STRIPE_WEBHOOK_SECRET`         | Webhook signing secret (`whsec_...`)            |
+| `NUXT_STRIPE_API_VERSION`            | Optional override, defaults to the pinned `2026-09-30.endive` |
+| `NUXT_PUBLIC_STRIPE_PUBLISHABLE_KEY` | Publishable key (`runtimeConfig.public.stripe.publishableKey`) |
+
+## Database
+
+Extends the `users` table with a nullable `stripe_customer_id` column. Generate and commit migrations in the host app.
+
+## Server utils (auto-imported in Nitro)
+
+- `useStripe()` - the Stripe SDK, using the fetch HTTP client (Cloudflare Workers compatible).
+- `ensureStripeCustomer(userId)` - returns the user's Stripe customer id: stored id, else a Stripe search by email, else a new customer (persisted).
+- `getStripeCustomerUser(customerId)` - the local user row for a Stripe customer id, or `null`.
+
+## Webhook
+
+`POST /api/stripe/webhook` reads the raw body, verifies the signature (`constructEventAsync` + SubtleCrypto), and
+dispatches to handlers. Processed event ids are stored in NuxtHub KV for 7 days, so duplicates are ignored. If any
+handler throws, the others still run, the response is 500 (Stripe retries) and the event is not marked processed -
+**handlers must be idempotent**. The Nitro hook `stripe:event` is fired for every dispatched event.
+
+## Subscribing to events
+
+From a module (build time, bundled into the server - no runtime scanning):
+
+```ts
+import { registerStripeEventHandler } from '@frigear-nu/stripe/utils'
+
+registerStripeEventHandler(nuxt, {
+  events: ['customer.subscription.updated', 'checkout.session.completed'], // or '*'
+  handler: resolver.resolve('./runtime/server/stripe/subscription-events'),
+  order: 100, // optional, lower runs first
+})
+```
+
+```ts
+// runtime/server/stripe/subscription-events.ts
+import { defineStripeEventHandler } from '@frigear-nu/stripe/utils'
+
+export default defineStripeEventHandler<'customer.subscription.updated' | 'checkout.session.completed'>(
+  async (event, { stripe, userId, event: h3Event }) => {
+    // `event` is narrowed by `event.type`; `userId` is null for unknown customers
+  },
+)
+```
+
+From a host app's Nitro plugin:
+
+```ts
+export default defineNitroPlugin(() => {
+  onStripeEvent('invoice.payment_failed', (event, ctx) => { /* ... */ })
+})
+```

package/dist/module.d.mts

@@ -0,0 +1,74 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import Stripe from 'stripe';
+import { H3Event } from 'h3';
+
+type ModuleOptions = {
+    settings?: {
+        /** Path the Stripe webhook is served on. Defaults to `/api/stripe/webhook`. */
+        webhookPath?: string;
+    };
+};
+/** Private runtime config (`useRuntimeConfig().stripe`), set through `NUXT_STRIPE_*` env vars. */
+type StripeRuntimeConfig = {
+    secretKey: string;
+    webhookSecret: string;
+    apiVersion: string;
+};
+/** Public runtime config (`useRuntimeConfig().public.stripe`). */
+type StripePublicRuntimeConfig = {
+    publishableKey: string;
+};
+/** Every Stripe event type string, e.g. `'customer.subscription.updated'`. */
+type StripeEventType = Stripe.Event['type'];
+/** The `Stripe.Event` for a given event type (or union of event types). */
+type StripeEventOf<T extends StripeEventType = StripeEventType> = Extract<Stripe.Event, {
+    type: T;
+}>;
+type StripeEventHandlerContext = {
+    /** A ready-to-use Stripe SDK instance (see `useStripe`). */
+    stripe: Stripe;
+    /** The local user owning the event's Stripe customer, or `null` if there is none / it is unknown. */
+    userId: number | null;
+    /** The Nitro request event of the webhook call. */
+    event: H3Event;
+};
+type StripeEventHandler<T extends StripeEventType = StripeEventType> = (event: StripeEventOf<T>, ctx: StripeEventHandlerContext) => void | Promise<void>;
+/** A handler registered at build time through `registerStripeEventHandler`. */
+type RegisteredStripeEventHandler = {
+    /** Event types to subscribe to, or `'*'` for every event. */
+    events: string[] | '*';
+    /** Absolute path to a file whose default export is a `defineStripeEventHandler(...)` result. */
+    handler: string;
+    /** Lower runs first. Defaults to `100`. */
+    order?: number;
+};
+
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        stripe?: ModuleOptions;
+    }
+    interface NuxtOptions {
+        stripe?: ModuleOptions & {
+            _handlers?: RegisteredStripeEventHandler[];
+        };
+    }
+    interface RuntimeConfig {
+        stripe: StripeRuntimeConfig;
+    }
+    interface PublicRuntimeConfig {
+        stripe: StripePublicRuntimeConfig;
+    }
+}
+declare module 'nitropack' {
+    interface NitroRuntimeHooks {
+        /** Fired for every verified, not-yet-processed Stripe webhook event, once handlers have been dispatched. */
+        'stripe:event': (event: Stripe.Event, ctx: StripeEventHandlerContext) => void | Promise<void>;
+    }
+}
+/** The Stripe API version this package is written against (matches the pinned `stripe` SDK). */
+declare const STRIPE_API_VERSION = "2026-09-30.endive";
+declare const DEFAULT_WEBHOOK_PATH = "/api/stripe/webhook";
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { DEFAULT_WEBHOOK_PATH, STRIPE_API_VERSION, _default as default };
+export type { ModuleOptions, RegisteredStripeEventHandler, StripeEventHandler, StripeEventHandlerContext, StripeEventOf, StripeEventType, StripePublicRuntimeConfig, StripeRuntimeConfig };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@frigear-nu/stripe",
+  "configKey": "stripe",
+  "version": "0.0.2",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,80 @@
+import { defineNuxtModule, createResolver, addServerHandler, addServerImportsDir, addServerImports, addTypeTemplate, addServerTemplate } from '@nuxt/kit';
+import { registerModule, extendDatabaseTable } from '@frigear-nu/module-kit/utils';
+
+const STRIPE_API_VERSION = "2026-09-30.endive";
+const DEFAULT_WEBHOOK_PATH = "/api/stripe/webhook";
+const DEFAULT_HANDLER_ORDER = 100;
+const module$1 = defineNuxtModule({
+  meta: { name: "@frigear-nu/stripe", configKey: "stripe" },
+  defaults: {
+    settings: { webhookPath: DEFAULT_WEBHOOK_PATH }
+  },
+  moduleDependencies: {
+    "@nuxthub/core": {
+      version: ">=0.10",
+      // The webhook stores processed event ids in NuxtHub KV.
+      defaults: { kv: true }
+    },
+    "@frigear-nu/module-kit": {
+      version: ">=0.0.1"
+    },
+    "@frigear-nu/users": {
+      version: ">=0.0.1"
+    }
+  },
+  async setup(options, nuxt) {
+    registerModule("@frigear-nu/stripe", nuxt);
+    const resolver = createResolver(import.meta.url);
+    const webhookPath = options.settings?.webhookPath || DEFAULT_WEBHOOK_PATH;
+    if (!nuxt.options.hub?.kv) {
+      throw new Error("[@frigear-nu/stripe] NuxtHub KV is required for webhook idempotency. Set `hub: { kv: true }` in your Nuxt config.");
+    }
+    const runtimeConfig = nuxt.options.runtimeConfig;
+    runtimeConfig.stripe = {
+      secretKey: "",
+      webhookSecret: "",
+      apiVersion: STRIPE_API_VERSION,
+      ...runtimeConfig.stripe
+    };
+    runtimeConfig.public.stripe = {
+      publishableKey: "",
+      ...runtimeConfig.public.stripe
+    };
+    addServerHandler({
+      route: webhookPath,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/routes/webhook.post")
+    });
+    addServerImportsDir(resolver.resolve("./runtime/server/utils"));
+    addServerImports([
+      { name: "onStripeEvent", from: resolver.resolve("./runtime/utils/registry") },
+      { name: "defineStripeEventHandler", from: resolver.resolve("./runtime/utils/handlers") }
+    ]);
+    addTypeTemplate({
+      filename: "types/stripe-handlers.d.ts",
+      getContents: () => `declare module '#stripe/handlers' {
+  import type { StripeEventHandler } from ${JSON.stringify(resolver.resolve("./types"))}
+  export const handlers: Array<{ events: string[] | '*', order?: number, handler: StripeEventHandler }>
+}
+`
+    });
+    nuxt.hook("modules:done", () => {
+      const registered = Array.isArray(nuxt.options.stripe?._handlers) ? nuxt.options.stripe._handlers : [];
+      addServerTemplate({
+        filename: "#stripe/handlers",
+        getContents: () => `
+${registered.map((entry, index) => `import handler${index} from ${JSON.stringify(entry.handler)}`).join("\n")}
+export const handlers = [${registered.map(
+          (entry, index) => `{ events: ${JSON.stringify(entry.events)}, order: ${entry.order ?? DEFAULT_HANDLER_ORDER}, handler: handler${index} }`
+        ).join(", ")}]
+`
+      });
+    });
+    extendDatabaseTable(nuxt, {
+      resolver,
+      file: (dialect) => `./runtime/server/db/schema.${dialect}`
+    });
+  }
+});
+
+export { DEFAULT_WEBHOOK_PATH, STRIPE_API_VERSION, module$1 as default };

package/dist/runtime/server/db/schema.sqlite.d.ts

@@ -0,0 +1,26 @@
+export declare const users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "users";
+    schema: undefined;
+    columns: {
+        stripeCustomerId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "stripe_customer_id";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/runtime/server/db/schema.sqlite.js

@@ -0,0 +1,4 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const users = sqliteTable("users", {
+  stripeCustomerId: text("stripe_customer_id")
+});

package/dist/runtime/server/routes/webhook.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/webhook.post.js

@@ -0,0 +1,82 @@
+import Stripe from "stripe";
+import { kv } from "@nuxthub/kv";
+import { handlers as registeredHandlers } from "#stripe/handlers";
+import { getRuntimeStripeEventHandlers } from "../../utils/registry.js";
+const PROCESSED_TTL_SECONDS = 60 * 60 * 24 * 7;
+const DEFAULT_ORDER = 100;
+const matches = (events, type) => events === "*" || events.includes(type);
+function collectHandlers(type) {
+  const all = [
+    ...registeredHandlers.map((entry) => ({ events: entry.events, order: entry.order ?? DEFAULT_ORDER, handler: entry.handler })),
+    ...getRuntimeStripeEventHandlers().map((entry) => ({ events: entry.events, order: DEFAULT_ORDER, handler: entry.handler }))
+  ];
+  return all.filter((entry) => matches(entry.events, type)).sort((a, b) => a.order - b.order).map((entry) => entry.handler);
+}
+function getEventCustomerId(stripeEvent) {
+  const object = stripeEvent.data.object;
+  if (!object) return null;
+  if (object.object === "customer" && typeof object.id === "string") return object.id;
+  const customer = object.customer;
+  if (typeof customer === "string") return customer;
+  if (customer && typeof customer === "object" && typeof customer.id === "string") {
+    return customer.id;
+  }
+  return null;
+}
+export default defineEventHandler(async (event) => {
+  const { webhookSecret } = useRuntimeConfig(event).stripe;
+  if (!webhookSecret) {
+    throw createError({ statusCode: 500, statusMessage: "Stripe webhook is not configured (missing NUXT_STRIPE_WEBHOOK_SECRET)." });
+  }
+  const signature = getHeader(event, "stripe-signature");
+  if (!signature) {
+    throw createError({ statusCode: 400, statusMessage: "Missing stripe-signature header." });
+  }
+  const rawBody = await readRawBody(event, "utf8");
+  if (!rawBody) {
+    throw createError({ statusCode: 400, statusMessage: "Missing request body." });
+  }
+  let stripeEvent;
+  try {
+    stripeEvent = await Stripe.webhooks.constructEventAsync(
+      rawBody,
+      signature,
+      webhookSecret,
+      void 0,
+      Stripe.createSubtleCryptoProvider()
+    );
+  } catch (error) {
+    console.warn("[@frigear-nu/stripe] Rejected webhook with an invalid signature:", error instanceof Error ? error.message : error);
+    throw createError({ statusCode: 400, statusMessage: "Invalid Stripe signature." });
+  }
+  const processedKey = `stripe:event:${stripeEvent.id}`;
+  if (await kv.has(processedKey)) {
+    return { received: true, duplicate: true };
+  }
+  const customerId = getEventCustomerId(stripeEvent);
+  const user = customerId ? await getStripeCustomerUser(customerId) : null;
+  const context = {
+    stripe: useStripe(),
+    userId: user?.id ?? null,
+    event
+  };
+  let failures = 0;
+  for (const handler of collectHandlers(stripeEvent.type)) {
+    try {
+      await handler(stripeEvent, context);
+    } catch (error) {
+      failures++;
+      console.error(`[@frigear-nu/stripe] Handler failed for "${stripeEvent.type}" (${stripeEvent.id}):`, error);
+    }
+  }
+  try {
+    await useNitroApp().hooks.callHook("stripe:event", stripeEvent, context);
+  } catch (error) {
+    console.error(`[@frigear-nu/stripe] "stripe:event" hook failed for ${stripeEvent.id}:`, error);
+  }
+  if (failures > 0) {
+    throw createError({ statusCode: 500, statusMessage: `${failures} Stripe event handler(s) failed.` });
+  }
+  await kv.set(processedKey, Date.now(), { ttl: PROCESSED_TTL_SECONDS });
+  return { received: true };
+});

package/dist/runtime/server/utils/stripe.d.ts

@@ -0,0 +1,14 @@
+import Stripe from 'stripe';
+/**
+ * The shared Stripe SDK instance, configured from `runtimeConfig.stripe`. It uses the fetch HTTP
+ * client, so it works on Cloudflare Workers as well as Node.
+ */
+export declare function useStripe(): Stripe;
+/**
+ * Returns the Stripe customer id for a user, creating (and persisting) one when needed. Lookup
+ * order: `users.stripeCustomerId`, then a Stripe customer search by email, then a new customer.
+ * Safe to call lazily from consumers - there is no login coupling.
+ */
+export declare function ensureStripeCustomer(userId: number): Promise<string>;
+/** Resolves the local user owning a Stripe customer id, or `null` if none is linked. */
+export declare function getStripeCustomerUser(customerId: string): Promise<any>;

package/dist/runtime/server/utils/stripe.js

@@ -0,0 +1,47 @@
+import Stripe from "stripe";
+import { db, schema } from "@nuxthub/db";
+import { and, eq, isNull } from "drizzle-orm";
+let cached;
+export function useStripe() {
+  const { secretKey, apiVersion } = useRuntimeConfig().stripe;
+  if (!secretKey) {
+    throw createError({ statusCode: 500, statusMessage: "Stripe is not configured (missing `runtimeConfig.stripe.secretKey` / NUXT_STRIPE_SECRET_KEY)." });
+  }
+  if (!cached || cached.key !== secretKey || cached.apiVersion !== apiVersion) {
+    cached = {
+      key: secretKey,
+      apiVersion,
+      client: new Stripe(secretKey, {
+        apiVersion,
+        httpClient: Stripe.createFetchHttpClient()
+      })
+    };
+  }
+  return cached.client;
+}
+const escapeSearchValue = (value) => value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+export async function ensureStripeCustomer(userId) {
+  const [user] = await db.select().from(schema.users).where(eq(schema.users.id, userId)).limit(1);
+  if (!user) {
+    throw createError({ statusCode: 404, statusMessage: "User not found." });
+  }
+  if (user.stripeCustomerId) return user.stripeCustomerId;
+  const stripe = useStripe();
+  const existing = await stripe.customers.search({
+    query: `email:'${escapeSearchValue(user.email)}'`,
+    limit: 1
+  });
+  const customerId = existing.data[0]?.id ?? (await stripe.customers.create({
+    email: user.email,
+    name: user.name,
+    metadata: { userId: String(user.id) }
+  })).id;
+  const [updated] = await db.update(schema.users).set({ stripeCustomerId: customerId }).where(and(eq(schema.users.id, userId), isNull(schema.users.stripeCustomerId))).returning({ stripeCustomerId: schema.users.stripeCustomerId });
+  if (updated?.stripeCustomerId) return updated.stripeCustomerId;
+  const [winner] = await db.select({ stripeCustomerId: schema.users.stripeCustomerId }).from(schema.users).where(eq(schema.users.id, userId)).limit(1);
+  return winner?.stripeCustomerId ?? customerId;
+}
+export async function getStripeCustomerUser(customerId) {
+  const [user] = await db.select().from(schema.users).where(eq(schema.users.stripeCustomerId, customerId)).limit(1);
+  return user ?? null;
+}

package/dist/runtime/utils/handlers.d.ts

@@ -0,0 +1,32 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { RegisteredStripeEventHandler, StripeEventHandler, StripeEventType } from '../../types.js';
+export type RegisterStripeEventHandlerOptions = RegisteredStripeEventHandler;
+/**
+ * A typed identity helper for authoring a Stripe event handler file. The event is narrowed to the
+ * event type(s) given as the generic; the default export of the file is the handler.
+ *
+ * ```ts
+ * export default defineStripeEventHandler<'customer.subscription.updated' | 'customer.subscription.deleted'>(
+ *   async (event, { stripe, userId }) => {
+ *     const subscription = event.data.object
+ *   },
+ * )
+ * ```
+ *
+ * Handlers must be idempotent: if any handler for an event throws, the webhook answers 5xx and
+ * Stripe retries the whole event.
+ */
+export declare function defineStripeEventHandler<T extends StripeEventType = StripeEventType>(handler: StripeEventHandler<T>): StripeEventHandler;
+/**
+ * Build-time API for any module (or host app module) to subscribe to Stripe webhook events. Call it
+ * during `setup()`; registration order between modules doesn't matter, since handlers are only
+ * bundled once every module has finished setting up. `handler` must be an absolute path.
+ *
+ * ```ts
+ * registerStripeEventHandler(nuxt, {
+ *   events: ['customer.subscription.updated', 'checkout.session.completed'],
+ *   handler: resolver.resolve('./runtime/server/stripe/subscription-events'),
+ * })
+ * ```
+ */
+export declare function registerStripeEventHandler(nuxt: Nuxt, options: RegisterStripeEventHandlerOptions): void;

package/dist/runtime/utils/handlers.js

@@ -0,0 +1,15 @@
+export function defineStripeEventHandler(handler) {
+  return handler;
+}
+export function registerStripeEventHandler(nuxt, options) {
+  nuxt.options.stripe ||= {};
+  const handlers = Array.isArray(nuxt.options.stripe._handlers) ? nuxt.options.stripe._handlers : [];
+  nuxt.options.stripe._handlers = handlers;
+  const events = options.events === "*" ? "*" : [...options.events];
+  const exists = handlers.some(
+    (existing) => existing.handler === options.handler && JSON.stringify(existing.events) === JSON.stringify(events)
+  );
+  if (!exists) {
+    handlers.push({ events, handler: options.handler, order: options.order });
+  }
+}

package/dist/runtime/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { registerStripeEventHandler, defineStripeEventHandler } from './handlers.js';
+export type { RegisterStripeEventHandlerOptions } from './handlers.js';
+export { onStripeEvent } from './registry.js';
+export type { ModuleOptions, StripeEventType, StripeEventOf, StripeEventHandler, StripeEventHandlerContext, RegisteredStripeEventHandler, StripeRuntimeConfig, StripePublicRuntimeConfig, } from '../../types.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,2 @@
+export { registerStripeEventHandler, defineStripeEventHandler } from "./handlers.js";
+export { onStripeEvent } from "./registry.js";

package/dist/runtime/utils/registry.d.ts

@@ -0,0 +1,18 @@
+import type { StripeEventHandler, StripeEventType } from '../../types.js';
+export type RuntimeStripeEventHandler = {
+    events: string[] | '*';
+    handler: StripeEventHandler;
+};
+/**
+ * Runtime counterpart of `registerStripeEventHandler`, for Nitro plugins in host apps:
+ *
+ * ```ts
+ * // server/plugins/stripe.ts
+ * export default defineNitroPlugin(() => {
+ *   onStripeEvent('invoice.payment_failed', (event, ctx) => { ... })
+ * })
+ * ```
+ */
+export declare function onStripeEvent<T extends StripeEventType>(type: T | T[] | '*', handler: StripeEventHandler<T>): void;
+/** Handlers registered through `onStripeEvent`, in registration order. Internal: used by the webhook route. */
+export declare function getRuntimeStripeEventHandlers(): readonly RuntimeStripeEventHandler[];

package/dist/runtime/utils/registry.js

@@ -0,0 +1,10 @@
+const handlers = [];
+export function onStripeEvent(type, handler) {
+  handlers.push({
+    events: type === "*" ? "*" : Array.isArray(type) ? type : [type],
+    handler
+  });
+}
+export function getRuntimeStripeEventHandlers() {
+  return handlers;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { type DEFAULT_WEBHOOK_PATH, type STRIPE_API_VERSION, default } from './module.mjs'
+
+export { type ModuleOptions, type RegisteredStripeEventHandler, type StripeEventHandler, type StripeEventHandlerContext, type StripeEventOf, type StripeEventType, type StripePublicRuntimeConfig, type StripeRuntimeConfig } from './module.mjs'

package/package.json

@@ -1,6 +1,81 @@
 {
   "name": "@frigear-nu/stripe",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "Core Stripe plumbing for the frigear ecosystem: SDK access, customer linking, and a verified, idempotent webhook that other modules can subscribe to.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/stripe"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/index.d.ts",
+      "import": "./dist/runtime/utils/index.js",
+      "default": "./dist/runtime/utils/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "dependencies": {
+    "@frigear-nu/module-kit": "0.1.0",
+    "@frigear-nu/users": "1.0.2",
+    "@libsql/client": "^0.18.0",
+    "@nuxt/kit": "^4.6.0",
+    "h3": "^1.15.11",
+    "drizzle-kit": "^0.31.11",
+    "drizzle-orm": "^0.45.3",
+    "stripe": "^23.0.0",
+    "unstorage": "^1.17.5",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@nuxthub/core": "^0.10.8"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.6.0",
+    "@nuxt/test-utils": "^4.3.2",
+    "@nuxthub/core": "^0.10.8",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  },
+  "scripts": {
+    "postinstall": "nuxt-module-build build --stub && nuxt prepare",
+    "build": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  }
 }