@frigear-nu/subscriptions 0.0.0-stage → 0.0.3

package/dist/runtime/server/routes/subscriptions/portal.post.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { resolveSameOriginUrl } from "../../../utils/plans.js";
+const bodySchema = z.object({ returnUrl: z.string().optional() });
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  const { returnUrl } = await readValidatedBody(event, bodySchema.parse);
+  const origin = getRequestURL(event).origin;
+  let returnTo = `${origin}${useRuntimeConfig().public.subscriptions?.pages?.membership ?? "/"}`;
+  if (returnUrl) {
+    const safe = resolveSameOriginUrl(returnUrl, origin);
+    if (!safe) throw createError({ statusCode: 400, statusMessage: "returnUrl must be on the same origin." });
+    returnTo = safe;
+  }
+  const customer = await ensureStripeCustomer(user.id);
+  const session = await useStripe().billingPortal.sessions.create({ customer, return_url: returnTo });
+  return { url: session.url };
+});

package/dist/runtime/server/stripe/subscription-events.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@frigear-nu/stripe/types").StripeEventHandler;
+export default _default;

package/dist/runtime/server/stripe/subscription-events.js

@@ -0,0 +1,36 @@
+import { db, schema } from "@nuxthub/db";
+import { defineStripeEventHandler } from "@frigear-nu/stripe/utils";
+import { resolvePlanKey } from "../../utils/plans.js";
+const toDate = (seconds) => typeof seconds === "number" ? new Date(seconds * 1e3) : null;
+export default defineStripeEventHandler(async (event, ctx) => {
+  const subscription = event.data.object;
+  if (ctx.userId === null) {
+    console.warn(`[@frigear-nu/subscriptions] Ignoring ${event.type} (${event.id}): no local user is linked to the Stripe customer.`);
+    return;
+  }
+  const items = subscription.items?.data ?? [];
+  const first = items[0];
+  const priceId = first?.price?.id ?? "";
+  const plans = useRuntimeConfig().subscriptions?.plans ?? {};
+  const planKey = first?.price ? resolvePlanKey(plans, { id: first.price.id, lookupKey: first.price.lookup_key }) : null;
+  const starts = items.map((item) => item.current_period_start).filter((v) => typeof v === "number");
+  const ends = items.map((item) => item.current_period_end).filter((v) => typeof v === "number");
+  const endedAt = toDate(subscription.ended_at) ?? (event.type === "customer.subscription.deleted" ? toDate(subscription.canceled_at) ?? /* @__PURE__ */ new Date() : null);
+  const values = {
+    userId: ctx.userId,
+    planKey,
+    priceId,
+    status: event.type === "customer.subscription.deleted" ? "canceled" : subscription.status,
+    cancelAtPeriodEnd: subscription.cancel_at_period_end ?? false,
+    currentPeriodStart: starts.length ? toDate(Math.min(...starts)) : null,
+    currentPeriodEnd: ends.length ? toDate(Math.max(...ends)) : null,
+    endedAt,
+    rawItems: items.map((item) => ({
+      id: item.id,
+      priceId: item.price.id,
+      lookupKey: item.price.lookup_key ?? null,
+      quantity: item.quantity ?? null
+    }))
+  };
+  await db.insert(schema.subscriptions).values({ id: subscription.id, ...values }).onConflictDoUpdate({ target: schema.subscriptions.id, set: { ...values, updatedAt: /* @__PURE__ */ new Date() } });
+});

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

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import type { ResolvedPlan } from '../../../types.js';
+/** The configured plans with their live prices from Stripe, cached in KV for ~5 minutes. Unfiltered. */
+export declare function getResolvedPlans(): Promise<ResolvedPlan[]>;
+/** Resolved plans passed through the `subscriptions:plans:filter` policy hook. */
+export declare function getAvailablePlans(event?: H3Event): Promise<ResolvedPlan[]>;

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

@@ -0,0 +1,64 @@
+import { kv } from "@nuxthub/kv";
+const CACHE_TTL_SECONDS = 60 * 5;
+const INTERVALS = ["day", "week", "month", "year"];
+function toPlanPrice(price) {
+  const recurring = price.recurring;
+  if (!recurring || !INTERVALS.includes(recurring.interval)) return null;
+  return {
+    id: price.id,
+    amount: price.unit_amount ?? null,
+    currency: price.currency,
+    interval: recurring.interval,
+    intervalCount: recurring.interval_count ?? 1,
+    trialPeriodDays: recurring.trial_period_days ?? null,
+    lookupKey: price.lookup_key ?? null
+  };
+}
+async function fetchPrices(stripe, refs) {
+  const byRef = /* @__PURE__ */ new Map();
+  const lookupKeys = refs.filter((ref) => typeof ref !== "string").map((ref) => ref.lookupKey);
+  const ids = refs.filter((ref) => typeof ref === "string");
+  for (let i = 0; i < lookupKeys.length; i += 10) {
+    const chunk = lookupKeys.slice(i, i + 10);
+    const list = await stripe.prices.list({ lookup_keys: chunk, active: true, limit: 100 });
+    for (const price of list.data) {
+      if (price.lookup_key) byRef.set(`lookup:${price.lookup_key}`, price);
+    }
+  }
+  for (const id of ids) {
+    try {
+      byRef.set(`id:${id}`, await stripe.prices.retrieve(id));
+    } catch (error) {
+      console.warn(`[@frigear-nu/subscriptions] Could not load Stripe price "${id}":`, error instanceof Error ? error.message : error);
+    }
+  }
+  return byRef;
+}
+export async function getResolvedPlans() {
+  const config = useRuntimeConfig().subscriptions?.plans ?? {};
+  const entries = Object.entries(config);
+  if (!entries.length) return [];
+  const cacheKey = `subscriptions:plans:${JSON.stringify(config)}`;
+  const cached = await kv.get(cacheKey).catch(() => null);
+  if (cached) return cached;
+  const stripe = useStripe();
+  const prices = await fetchPrices(stripe, entries.flatMap(([, plan]) => plan.prices));
+  const plans = entries.map(([key, plan]) => {
+    const resolved = plan.prices.map((ref) => prices.get(typeof ref === "string" ? `id:${ref}` : `lookup:${ref.lookupKey}`)).filter((price) => !!price && price.active !== false).map(toPlanPrice).filter((price) => price !== null);
+    return {
+      key,
+      label: plan.label ?? key,
+      ...plan.description ? { description: plan.description } : {},
+      rank: plan.rank,
+      prices: resolved
+    };
+  }).sort((a, b) => a.rank - b.rank);
+  await kv.set(cacheKey, plans, { ttl: CACHE_TTL_SECONDS }).catch(() => {
+  });
+  return plans;
+}
+export async function getAvailablePlans(event) {
+  const ctx = { event, plans: structuredClone(await getResolvedPlans()) };
+  await useNitroApp().hooks.callHook("subscriptions:plans:filter", ctx);
+  return ctx.plans;
+}

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

@@ -0,0 +1,13 @@
+export type HasActiveSubscriptionOptions = {
+    /** Only count subscriptions on one of these plan keys. Omit for "any plan". */
+    plans?: string[];
+    /** Statuses that count as entitled. Defaults to `active` and `trialing`. */
+    statuses?: string[];
+};
+/**
+ * The user's current entitled subscription row (default statuses `active`/`trialing`, not ended), the one
+ * with the latest period end when several match, or `null`.
+ */
+export declare function getUserSubscription(userId: number, options?: Pick<HasActiveSubscriptionOptions, 'statuses'>): Promise<any>;
+/** Whether the user holds an entitled subscription, optionally restricted to specific plans. */
+export declare function hasActiveSubscription(userId: number, options?: HasActiveSubscriptionOptions): Promise<boolean>;

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

@@ -0,0 +1,16 @@
+import { db, schema } from "@nuxthub/db";
+import { desc, eq } from "drizzle-orm";
+import { DEFAULT_ENTITLED_STATUSES } from "../../utils/plans.js";
+export async function getUserSubscription(userId, options = {}) {
+  const statuses = options.statuses ?? DEFAULT_ENTITLED_STATUSES;
+  const rows = await db.select().from(schema.subscriptions).where(eq(schema.subscriptions.userId, userId)).orderBy(desc(schema.subscriptions.createdAt));
+  const entitled = rows.filter((row) => statuses.includes(row.status) && !row.endedAt).sort((a, b) => (b.currentPeriodEnd?.getTime() ?? 0) - (a.currentPeriodEnd?.getTime() ?? 0));
+  return entitled[0] ?? null;
+}
+export async function hasActiveSubscription(userId, options = {}) {
+  const statuses = options.statuses ?? DEFAULT_ENTITLED_STATUSES;
+  const rows = await db.select().from(schema.subscriptions).where(eq(schema.subscriptions.userId, userId));
+  return rows.some(
+    (row) => statuses.includes(row.status) && !row.endedAt && (!options.plans?.length || row.planKey !== null && options.plans.includes(row.planKey))
+  );
+}

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

@@ -0,0 +1,4 @@
+export { getUserSubscription, hasActiveSubscription } from '../server/utils/subscriptions.js';
+export type { HasActiveSubscriptionOptions } from '../server/utils/subscriptions.js';
+export { decideChangeKind, resolvePlanKey, resolveSameOriginUrl, DEFAULT_ENTITLED_STATUSES } from './plans.js';
+export type { CheckoutBeforeContext, PlansFilterContext, ResolvedPlan, PlanPrice, SubscriptionDto, ModuleOptions, } from '../../types.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,2 @@
+export { getUserSubscription, hasActiveSubscription } from "../server/utils/subscriptions.js";
+export { decideChangeKind, resolvePlanKey, resolveSameOriginUrl, DEFAULT_ENTITLED_STATUSES } from "./plans.js";

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

@@ -0,0 +1,32 @@
+import type { PlanPriceRef, ResolvedPlan } from '../../types.js';
+export declare const DEFAULT_ENTITLED_STATUSES: string[];
+/** Statuses that count as "holds a live subscription" when deciding between a new checkout and a plan change. */
+export declare const LIVE_STATUSES: string[];
+type PlanConfigLike = Record<string, {
+    prices: PlanPriceRef[];
+    rank: number;
+}>;
+/** Maps a Stripe price (id and/or lookup key) to the configured plan key that lists it, or `null`. */
+export declare function resolvePlanKey(plans: PlanConfigLike, price: {
+    id: string;
+    lookupKey?: string | null;
+}): string | null;
+export type ChangeKind = 'upgrade' | 'downgrade';
+/**
+ * Decides how to move a subscriber between plans from the plans' `rank` (never from price amounts).
+ * A higher target rank is an upgrade (immediate, prorated); a lower or equal rank (including a
+ * billing-interval change within one plan) is deferred to the end of the current period. A current
+ * plan that isn't configured counts as the lowest rank.
+ */
+export declare function decideChangeKind(currentRank: number | null | undefined, targetRank: number): ChangeKind;
+/**
+ * Validates a redirect URL supplied by a client: it must be a relative path (`/x`) or an absolute URL on
+ * `origin`. Returns an absolute URL on that origin, or `null` when it is unsafe.
+ */
+export declare function resolveSameOriginUrl(input: string, origin: string): string | null;
+/** Finds a price (and its plan) in already resolved plans by price id. */
+export declare function findPrice(plans: ResolvedPlan[], priceId: string): {
+    plan: ResolvedPlan;
+    price: import(".").PlanPrice;
+} | null;
+export {};

package/dist/runtime/utils/plans.js

@@ -0,0 +1,33 @@
+export const DEFAULT_ENTITLED_STATUSES = ["active", "trialing"];
+export const LIVE_STATUSES = ["active", "trialing", "past_due"];
+export function resolvePlanKey(plans, price) {
+  for (const [key, plan] of Object.entries(plans)) {
+    const match = plan.prices.some(
+      (ref) => typeof ref === "string" ? ref === price.id : !!price.lookupKey && ref.lookupKey === price.lookupKey
+    );
+    if (match) return key;
+  }
+  return null;
+}
+export function decideChangeKind(currentRank, targetRank) {
+  if (currentRank === null || currentRank === void 0) return "upgrade";
+  return targetRank > currentRank ? "upgrade" : "downgrade";
+}
+export function resolveSameOriginUrl(input, origin) {
+  if (input.startsWith("/")) {
+    if (input.startsWith("//") || input.startsWith("/\\")) return null;
+    return `${origin}${input}`;
+  }
+  try {
+    return new URL(input).origin === new URL(origin).origin ? input : null;
+  } catch {
+    return null;
+  }
+}
+export function findPrice(plans, priceId) {
+  for (const plan of plans) {
+    const price = plan.prices.find((item) => item.id === priceId);
+    if (price) return { plan, price };
+  }
+  return null;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type CheckoutBeforeContext, type CheckoutBody, type CheckoutResponse, type MeResponse, type ModuleOptions, type PlanConfig, type PlanPrice, type PlanPriceRef, type PlansFilterContext, type PlansResponse, type PortalBody, type PublicModuleOptions, type PublicPlan, type ResolvedPlan, type SubscriptionDto, type SubscriptionsRuntimeConfig } from './module.mjs'

package/package.json

@@ -1,6 +1,91 @@
 {
   "name": "@frigear-nu/subscriptions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.3",
+  "description": "Recurring subscriptions (plans, checkout, upgrade/downgrade, billing portal and entitlements) for the frigear ecosystem, built on @frigear-nu/stripe.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/subscriptions"
+  },
+  "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/menu": "0.0.3",
+    "@frigear-nu/module-kit": "0.1.2",
+    "@frigear-nu/stripe": "0.0.3",
+    "@frigear-nu/users": "1.0.3",
+    "@libsql/client": "^0.18.0",
+    "@nuxt/kit": "^4.6.0",
+    "@vueuse/core": "^15.0.0",
+    "drizzle-kit": "^0.31.11",
+    "drizzle-orm": "^0.45.3",
+    "h3": "^1.15.11",
+    "stripe": "^23.0.0",
+    "unstorage": "^1.17.5",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@nuxt/ui": "^4.10.0",
+    "@nuxthub/core": "^0.10.8"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/ui": {
+      "optional": true
+    }
+  },
+  "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",
+    "@nuxt/ui": "^4.11.0",
+    "@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"
+      ]
+    }
+  }
 }