@volter/twin-stripe 2.0.38 → 3.0.0

package/dist/src/semantics/subscription_items.d.ts

@@ -0,0 +1,5 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function DeleteSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;
+export declare function GetSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptionItems(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptionItemsItem(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/subscription_items.js

@@ -0,0 +1,55 @@
+import { subscriptionItemPrice } from "../engine/stripe.js";
+import { ITEM_ATTRIBUTES, SUB } from "../engine/subscriptions.js";
+import { at, created, fail, finder, subMissing, subscriptionsItemMissing, syncItems, withPeriod } from "./shared.js";
+export async function DeleteSubscriptionItemsItem(ctx) {
+    const id = at(ctx, 'item');
+    const si = ctx.get('subscription_item', id);
+    if (!si)
+        return subscriptionsItemMissing(ctx, id);
+    await ctx.write('subscription_item', id, { deleted: true }, 'subscription_item.delete');
+    await syncItems(ctx, String(si.subscription));
+    return ctx.reply({ id, object: 'subscription_item', deleted: true });
+}
+export async function GetSubscriptionItemsItem(ctx) {
+    const si = ctx.get('subscription_item', at(ctx, 'item'));
+    return si ? ctx.reply(withPeriod(ctx, si)) : subscriptionsItemMissing(ctx, at(ctx, 'item'));
+}
+export async function PostSubscriptionItems(ctx) {
+    const params = ctx.params;
+    const subId = typeof params.subscription === 'string' ? params.subscription : '';
+    if (!subId)
+        return fail(ctx, 'Missing required param: subscription.', 400, 'parameter_missing');
+    if (!ctx.get(SUB, subId))
+        return subMissing(ctx, subId);
+    const priceRef = typeof params.price === 'string' ? params.price : '';
+    if (!priceRef && !(params.price_data && typeof params.price_data === 'object'))
+        return fail(ctx, 'Missing required param: price.', 400, 'parameter_missing');
+    if (priceRef && !ctx.get('price', priceRef))
+        return fail(ctx, `No such price: '${priceRef}'`, 400, 'resource_missing');
+    const quantity = params.quantity !== undefined ? Math.max(0, Math.trunc(Number(params.quantity) || 0)) : 1;
+    // "metadata: Set of key-value pairs that you can attach to an object" (docs.stripe.com/api/subscription_items/create)
+    const metadata = params.metadata && typeof params.metadata === 'object' ? { metadata: params.metadata } : {};
+    const body = await created(ctx, 'subscription_item', { subscription: subId, ...(priceRef ? subscriptionItemPrice(priceRef, finder(ctx)) : { price: null, plan: null }), quantity, ...metadata }, { livemode: false, metadata: {} });
+    await syncItems(ctx, subId);
+    return ctx.reply(withPeriod(ctx, body));
+}
+export async function PostSubscriptionItemsItem(ctx) {
+    const id = at(ctx, 'item');
+    const si = ctx.get('subscription_item', id);
+    if (!si)
+        return subscriptionsItemMissing(ctx, id);
+    // only the item's own attributes are kept; the update's instructions (off_session, payment_behavior, price_data,
+    // proration_behavior, proration_date) are not attributes of the Subscription Item object
+    // (docs.stripe.com/api/subscription_items/object lists none of them)
+    const fields = Object.fromEntries(Object.entries(ctx.params).filter(([k]) => ITEM_ATTRIBUTES.has(k)));
+    if (ctx.params.quantity !== undefined)
+        fields.quantity = Math.max(0, Math.trunc(Number(ctx.params.quantity) || 0));
+    if (typeof ctx.params.price === 'string' && ctx.params.price && !ctx.get('price', ctx.params.price))
+        return fail(ctx, `No such price: '${ctx.params.price}'`, 400, 'resource_missing');
+    // the item carries its Price and plan, as the subscription's own items do (subscriptionItemPrice)
+    if (typeof ctx.params.price === 'string' && ctx.params.price)
+        Object.assign(fields, subscriptionItemPrice(ctx.params.price, finder(ctx)));
+    const out = await ctx.write('subscription_item', id, fields, 'subscription_item.update');
+    await syncItems(ctx, String(si.subscription));
+    return ctx.reply(withPeriod(ctx, out));
+}

package/dist/src/semantics/subscription_schedules.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetSubscriptionSchedulesSchedule(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptionSchedules(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptionSchedulesScheduleRelease(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/subscription_schedules.js

@@ -0,0 +1,60 @@
+import { buildSubscriptionItemsList, nowUnix } from "../engine/stripe.js";
+import { SS } from "../engine/subscription-schedules.js";
+import { at, created, end, fail, finder, phasesOf, scheduleMissing, storeItems } from "./shared.js";
+export async function GetSubscriptionSchedulesSchedule(ctx) {
+    const s = ctx.get(SS, at(ctx, 'schedule'));
+    return s ? ctx.reply(s) : scheduleMissing(ctx, at(ctx, 'schedule'));
+}
+// a schedule starts from a customer or from an existing subscription
+export async function PostSubscriptionSchedules(ctx) {
+    const params = ctx.params;
+    const customer = typeof params.customer === 'string' ? params.customer : '';
+    const fromSub = typeof params.from_subscription === 'string' ? params.from_subscription : '';
+    if (!customer && !fromSub)
+        return fail(ctx, 'Missing required param: customer (or from_subscription).', 400, 'parameter_missing');
+    if (customer && !ctx.get('customer', customer))
+        return fail(ctx, `No such customer: '${customer}'`, 404, 'resource_missing');
+    if (fromSub && !ctx.get('subscription', fromSub))
+        return fail(ctx, `No such subscription: '${fromSub}'`, 404, 'resource_missing');
+    // start_date is an instruction ("now" or when), not a field of the schedule
+    const start = params.start_date !== undefined && params.start_date !== 'now' ? Number(params.start_date) : Number(nowUnix(ctx.occurredAt));
+    const phases = phasesOf(ctx, Array.isArray(params.phases) ? params.phases : [], start);
+    const { phases: _p, start_date: _s, default_settings: givenDefaults, ...rest } = params;
+    const defaults = givenDefaults && typeof givenDefaults === 'object' ? givenDefaults : {};
+    const schedId = ctx.mint(SS);
+    // a schedule for a customer whose first phase starts now starts its subscription at once, on that phase's items
+    // (docs.stripe.com/billing/subscriptions/subscription-schedules#managing)
+    let subscription = fromSub || null;
+    if (!fromSub && phases.length) {
+        const now = Number(nowUnix(ctx.occurredAt));
+        const subId = ctx.mint('subscription');
+        const items = buildSubscriptionItemsList(phases[0].items, subId, now, finder(ctx));
+        await created(ctx, 'subscription', { customer, id: subId }, {
+            status: 'active', livemode: false, currency: 'usd', collection_method: String(params.default_settings?.collection_method ?? 'charge_automatically'),
+            cancel_at_period_end: false, start_date: now, billing_cycle_anchor: now, metadata: {}, discounts: [], billing_schedules: [],
+            trial_start: null, trial_end: null, current_period_start: now, current_period_end: phases[0].end_date, items, schedule: schedId,
+            automatic_tax: { enabled: false, liability: null }, billing_mode: { type: 'classic' }, invoice_settings: { issuer: { type: 'self' } },
+        });
+        await storeItems(ctx, subId, items.data ?? []);
+        subscription = subId;
+    }
+    return ctx.reply(await created(ctx, SS, { ...rest, id: schedId }, {
+        status: 'active', livemode: false, phases, current_phase: phases.length ? { start_date: phases[0].start_date, end_date: phases[0].end_date } : null,
+        subscription, released_subscription: null, released_at: null,
+        canceled_at: null, completed_at: null, end_behavior: params.end_behavior ?? 'release',
+        renewal_interval: null, metadata: {}, billing_mode: { type: 'classic' },
+        // "billing_cycle_anchor: Possible values are phase_start or automatic" and invoice_settings are required (the
+        // served spec's default settings); the rest answer what the request set, else null
+        default_settings: {
+            application_fee_percent: defaults.application_fee_percent ?? null, automatic_tax: { enabled: false, liability: null, disabled_reason: null },
+            billing_cycle_anchor: typeof defaults.billing_cycle_anchor === 'string' ? defaults.billing_cycle_anchor : 'automatic', billing_thresholds: null,
+            collection_method: typeof defaults.collection_method === 'string' ? defaults.collection_method : 'charge_automatically', default_payment_method: defaults.default_payment_method ?? null,
+            description: defaults.description ?? null, invoice_settings: { account_tax_ids: null, days_until_due: null, issuer: { type: 'self' } }, on_behalf_of: null, transfer_data: null,
+        },
+        // a schedule made from a subscription is its customer's
+        customer: customer || String(ctx.get('subscription', fromSub)?.customer ?? ''),
+    }));
+}
+export async function PostSubscriptionSchedulesScheduleRelease(ctx) {
+    return (end('release'))(ctx);
+}

package/dist/src/semantics/subscriptions.d.ts

@@ -1,11 +1,7 @@
-import type { Semantics, SemanticsContext } from '@volter/world-core';
-import { type Row } from './shared.js';
-/** A `trial_end` Stripe refuses: the parameter is `"now" | timestamp` (docs.stripe.com/api/subscriptions/update), and a
- *  timestamp that is not in the future answers "Invalid timestamp: must be an integer Unix timestamp in the future."
- *  (Stripe's own message, as its SDKs' users report it: github.com/stripe/stripe-dotnet/issues/805,
- *  github.com/stripe/stripe-ruby/issues/682). Where the documentation stops and the twin decides: a value that is no
- *  number at all, and one more than two years on, answer that same message. */
-export declare function trialEndRefused(ctx: SemanticsContext, value: unknown, now: number): Response | undefined;
-/** A new subscription's items, each its own subscription_item as Stripe keeps it (/v1/subscription_items/{id}). */
-export declare function storeItems(ctx: SemanticsContext, subId: string, items: Row[]): Promise<void>;
-export declare const subscriptions: Record<string, Semantics>;
+import type { HandlerContext } from '@volter/world-core';
+export declare function DeleteSubscriptionsSubscriptionExposedId(ctx: HandlerContext): Promise<Response>;
+export declare function GetSubscriptions(ctx: HandlerContext): Promise<Response>;
+export declare function GetSubscriptionsSearch(ctx: HandlerContext): Promise<Response>;
+export declare function GetSubscriptionsSubscriptionExposedId(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptions(ctx: HandlerContext): Promise<Response>;
+export declare function PostSubscriptionsSubscriptionExposedId(ctx: HandlerContext): Promise<Response>;