@owlmeans/payment 0.1.18-rc.9 → 0.1.18

package/tests/estimate.spec.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  DEFAULT_PRICING_POLICY, TaxBehavior, TaxEstimateStatus, TaxType, type PriceEstimate,
+  type PricingPolicy, priceEstimateHelper,
+} from '../src/index.js'
+
+describe('ratePpmOf', () => {
+  test('parses a whole percentage', () => {
+    expect(priceEstimateHelper.ratePpmOf('23')).toBe(230_000)
+  })
+
+  test('parses a trailing zero the same as none', () => {
+    expect(priceEstimateHelper.ratePpmOf('23.0')).toBe(230_000)
+  })
+
+  test('parses fractional percentages exactly, without float drift', () => {
+    expect(priceEstimateHelper.ratePpmOf('8.875')).toBe(88_750)
+    expect(priceEstimateHelper.ratePpmOf('25.5')).toBe(255_000)
+  })
+
+  test('parses a zero rate', () => {
+    expect(priceEstimateHelper.ratePpmOf('0.0')).toBe(0)
+  })
+
+  test('rejects a non-decimal string', () => {
+    expect(() => priceEstimateHelper.ratePpmOf('abc')).toThrow()
+    expect(() => priceEstimateHelper.ratePpmOf('1e3')).toThrow()
+    expect(() => priceEstimateHelper.ratePpmOf('-1')).toThrow()
+  })
+})
+
+const plVat: PriceEstimate = {
+  country: 'PL', source: 'request', currency: 'usd', behavior: TaxBehavior.Exclusive,
+  tax: {
+    status: TaxEstimateStatus.Taxed, subtotalMinor: 1_021, taxMinor: 235, totalMinor: 1_256,
+    scalable: true,
+    rates: [{ type: TaxType.Vat, percentage: '23', ratePpm: 230_000, country: 'PL' }],
+  },
+}
+
+describe('estimateOf', () => {
+  test('echoes the reference amount exactly, as Stripe returned it (1021 -> 235 -> 1256)', () => {
+    const result = priceEstimateHelper.estimateOf(1_021, plVat)
+    expect(result).toEqual({ subtotalMinor: 1_021, taxMinor: 235, totalMinor: 1_256 })
+  })
+
+  test('rescales an exclusive, scalable rate to a different amount', () => {
+    // 3_750 * 23% = 862.5 -> rounds up to 863
+    const result = priceEstimateHelper.estimateOf(3_750, plVat)
+    expect(result.taxMinor).toBe(863)
+    expect(result.totalMinor).toBe(4_613)
+  })
+
+  test('rounds a half-cent up', () => {
+    // 100 * 23% = 23.0 exactly, no rounding ambiguity; use a value that lands on .5
+    // 50 * 23% = 11.5 -> rounds to 12
+    const result = priceEstimateHelper.estimateOf(50, plVat)
+    expect(result.taxMinor).toBe(12)
+  })
+
+  test('returns null amounts for a different amount when the estimate is not scalable', () => {
+    const flat: PriceEstimate = {
+      ...plVat,
+      tax: { ...plVat.tax, scalable: false },
+    }
+    expect(priceEstimateHelper.estimateOf(3_750, flat)).toEqual({ subtotalMinor: 3_750, taxMinor: null, totalMinor: null })
+    // the reference amount is still exact even when not scalable
+    expect(priceEstimateHelper.estimateOf(1_021, flat)).toEqual({ subtotalMinor: 1_021, taxMinor: 235, totalMinor: 1_256 })
+  })
+
+  test('never rescales an inclusive amount away from the reference, even when scalable', () => {
+    const inclusive: PriceEstimate = { ...plVat, behavior: TaxBehavior.Inclusive }
+    expect(priceEstimateHelper.estimateOf(1_021, inclusive)).toEqual({ subtotalMinor: 1_021, taxMinor: 235, totalMinor: 1_256 })
+    expect(priceEstimateHelper.estimateOf(3_750, inclusive)).toEqual({ subtotalMinor: 3_750, taxMinor: null, totalMinor: null })
+  })
+
+  test('carries the subtotal, tax and total in the local currency alongside a rescaled amount', () => {
+    const withLocal: PriceEstimate = { ...plVat, local: { currency: 'pln', exchangeRate: 0.25 } }
+    // $10.21 / $2.35 / $12.56, each divided by 0.25 usd-per-pln -> 40.84 / 9.40 / 50.24
+    const result = priceEstimateHelper.estimateOf(1_021, withLocal)
+    expect(result.local).toEqual({ currency: 'pln', subtotalAmount: 40.84, taxAmount: 9.4, totalAmount: 50.24 })
+  })
+
+  test('rejects a negative or non-integer amount', () => {
+    expect(() => priceEstimateHelper.estimateOf(-1, plVat)).toThrow()
+    expect(() => priceEstimateHelper.estimateOf(1.5, plVat)).toThrow()
+  })
+})
+
+describe('assertPricingPolicy', () => {
+  test('accepts the default policy', () => {
+    expect(priceEstimateHelper.assertPricingPolicy(DEFAULT_PRICING_POLICY)).toBe(DEFAULT_PRICING_POLICY)
+  })
+
+  test('rejects a tax estimate without automatic tax', () => {
+    const policy: PricingPolicy = { tax: { automatic: false, collectTaxId: false, estimate: true }, currency: { estimate: false } }
+    expect(() => priceEstimateHelper.assertPricingPolicy(policy)).toThrow()
+  })
+
+  test('rejects a currency estimate without adaptive pricing', () => {
+    const policy: PricingPolicy = {
+      tax: { automatic: true, collectTaxId: true, estimate: false },
+      currency: { estimate: true },
+    }
+    expect(() => priceEstimateHelper.assertPricingPolicy(policy)).toThrow()
+  })
+
+  test('accepts a currency estimate declared alongside adaptive pricing', () => {
+    const policy: PricingPolicy = {
+      tax: { automatic: true, collectTaxId: true, estimate: true },
+      currency: { adaptive: true, estimate: true },
+    }
+    expect(priceEstimateHelper.assertPricingPolicy(policy)).toBe(policy)
+  })
+
+  test('accepts the Adaptive Pricing fee alongside adaptive pricing', () => {
+    const policy: PricingPolicy = {
+      tax: { automatic: true, collectTaxId: true, estimate: true },
+      currency: { adaptive: true, adaptiveFeeRate: 0.04, estimate: true },
+    }
+    expect(priceEstimateHelper.assertPricingPolicy(policy)).toBe(policy)
+  })
+
+  test('rejects an Adaptive Pricing fee without adaptive pricing, or outside [0, 1)', () => {
+    const tax = { automatic: true, collectTaxId: true, estimate: false }
+    expect(() => priceEstimateHelper.assertPricingPolicy({ tax, currency: { adaptiveFeeRate: 0.04, estimate: false } })).toThrow()
+    for (const adaptiveFeeRate of [-0.01, 1, Number.NaN, Number.POSITIVE_INFINITY]) {
+      expect(() => priceEstimateHelper.assertPricingPolicy({
+        tax, currency: { adaptive: true, adaptiveFeeRate, estimate: false },
+      })).toThrow()
+    }
+  })
+
+  test('rejects a non-positive or fractional TTL', () => {
+    const base: PricingPolicy = { tax: { automatic: true, collectTaxId: true, estimate: false }, currency: { estimate: false } }
+    expect(() => priceEstimateHelper.assertPricingPolicy({ ...base, tax: { ...base.tax, estimateTtlSeconds: 0 } })).toThrow()
+    expect(() => priceEstimateHelper.assertPricingPolicy({ ...base, tax: { ...base.tax, estimateTtlSeconds: 1.5 } })).toThrow()
+  })
+})

package/tests/limit.spec.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from 'bun:test'
+import { LimitKind, LimitMisdeclared, LimitWindow, planLimitHelper } from '../src/index.js'
+import type { EntitlementView, LimitView } from '../src/index.js'
+
+const utc = (iso: string): Date => new Date(iso)
+
+describe('window keys', () => {
+  test('subscription weeks roll at the exact anniversary across DST and month boundaries', () => {
+    const anchor = utc('2026-10-23T15:03:00.000Z')
+    const before = utc('2026-10-30T15:02:59.999Z')
+    const reset = utc('2026-10-30T15:03:00.000Z')
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.SubscriptionWeek, before, anchor))
+      .toBe('subscription-week:2026-10-23T15:03:00.000Z')
+    expect(planLimitHelper.windowBoundsOf(LimitWindow.SubscriptionWeek, before, anchor)).toEqual({ start: anchor, resetsAt: reset })
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.SubscriptionWeek, reset, anchor))
+      .toBe('subscription-week:2026-10-30T15:03:00.000Z')
+    expect(planLimitHelper.windowBoundsOf(LimitWindow.SubscriptionWeek, utc('2026-11-06T15:03:00.000Z'), anchor).resetsAt)
+      .toEqual(utc('2026-11-13T15:03:00.000Z'))
+    expect(() => planLimitHelper.windowBoundsOf(LimitWindow.SubscriptionWeek, before)).toThrow(LimitMisdeclared)
+  })
+
+  test('a day window rolls at UTC midnight', () => {
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Day, utc('2026-01-31T23:59:59.999Z'))).toBe('2026-01-31')
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Day, utc('2026-02-01T00:00:00.000Z'))).toBe('2026-02-01')
+  })
+
+  test('a month window rolls on the 1st, UTC, across a year', () => {
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Month, utc('2026-12-31T23:59:59.999Z'))).toBe('2026-12')
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Month, utc('2027-01-01T00:00:00.000Z'))).toBe('2027-01')
+    // A local time zone ahead of UTC does not move the key.
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Month, utc('2026-03-31T23:30:00-02:00'))).toBe('2026-04')
+  })
+
+  test('lifetime and occupancy never renew', () => {
+    expect(planLimitHelper.windowKeyOf(LimitKind.Lifetime, undefined, utc('2026-01-01T00:00:00Z'))).toBe('lifetime')
+    expect(planLimitHelper.windowKeyOf(LimitKind.Occupancy, LimitWindow.Day, utc('2030-06-15T12:00:00Z'))).toBe('occupancy')
+  })
+
+  test('a window limit without a window is a misdeclaration', () => {
+    expect(() => planLimitHelper.windowKeyOf(LimitKind.Window, undefined)).toThrow(LimitMisdeclared)
+  })
+})
+
+describe('window bounds', () => {
+  test('a day spans [midnight, next midnight)', () => {
+    const { start, resetsAt } = planLimitHelper.windowBoundsOf(LimitWindow.Day, utc('2026-01-31T13:00:00Z'))
+    expect(start.toISOString()).toBe('2026-01-31T00:00:00.000Z')
+    expect(resetsAt.toISOString()).toBe('2026-02-01T00:00:00.000Z')
+  })
+
+  test('a month spans [1st, next 1st) and resetsAt belongs to the next window', () => {
+    const { start, resetsAt } = planLimitHelper.windowBoundsOf(LimitWindow.Month, utc('2026-12-31T23:59:59.999Z'))
+    expect(start.toISOString()).toBe('2026-12-01T00:00:00.000Z')
+    expect(resetsAt.toISOString()).toBe('2027-01-01T00:00:00.000Z')
+    expect(planLimitHelper.windowKeyOf(LimitKind.Window, LimitWindow.Month, resetsAt)).toBe('2027-01')
+  })
+})
+
+describe('limit parameters', () => {
+  test('format and parse round-trip', () => {
+    expect(planLimitHelper.formatLimitParam('seats')).toBe('limit:seats')
+    expect(planLimitHelper.formatLimitParam('seats', 3)).toBe('limit:seats>=3')
+    expect(planLimitHelper.parseLimitParam(planLimitHelper.formatLimitParam('seats'))).toEqual({ key: 'seats', atLeast: 1 })
+    expect(planLimitHelper.parseLimitParam(planLimitHelper.formatLimitParam('seats', 3))).toEqual({ key: 'seats', atLeast: 3 })
+  })
+
+  test('a capability parameter, a bare key or an empty key is not a limit', () => {
+    expect(planLimitHelper.parseLimitParam('feature:whitelabel')).toBeNull()
+    expect(planLimitHelper.parseLimitParam('seats')).toBeNull()
+    expect(planLimitHelper.parseLimitParam('limit:')).toBeNull()
+    expect(planLimitHelper.parseLimitParam('')).toBeNull()
+  })
+
+  test('a floor that is not positive refuses rather than throwing', () => {
+    expect(planLimitHelper.parseLimitParam('limit:seats>=0')).toBeNull()
+    expect(() => planLimitHelper.parseLimitParam(undefined as unknown as string)).not.toThrow()
+    expect(planLimitHelper.parseLimitParam(undefined as unknown as string)).toBeNull()
+  })
+})
+
+const seats: LimitView = {
+  key: 'seats', param: 'limit:seats', kind: LimitKind.Occupancy, limit: 3, used: 2, remaining: 1,
+}
+
+const view: EntitlementView = {
+  plan: {
+    sku: 'pro-monthly', productSku: 'pro', title: 'Pro', rank: 10, free: false,
+    status: 'active' as EntitlementView['plan']['status'], paygate: 'stripe',
+  },
+  capabilities: [
+    { param: 'feature:whitelabel', scope: 'feature', permission: 'whitelabel', value: true, granted: true },
+    { param: 'feature:custom-domain', scope: 'feature', permission: 'custom-domain', value: true, granted: false },
+  ],
+  limits: [seats],
+  at: new Date(),
+}
+
+describe('reading a view', () => {
+  test('room is remaining against the floor', () => {
+    expect(planLimitHelper.hasLimitRoom(seats)).toBe(true)
+    expect(planLimitHelper.hasLimitRoom(seats, 2)).toBe(false)
+    expect(planLimitHelper.hasLimitRoom(null)).toBe(false)
+  })
+
+  test('a limit is found by key', () => {
+    expect(planLimitHelper.limitOf(view, 'seats')).toBe(seats)
+    expect(planLimitHelper.limitOf(view, 'projects')).toBeNull()
+    expect(planLimitHelper.limitOf(null, 'seats')).toBeNull()
+  })
+
+  test('a capability passes only while granted, and a limit parameter never does', () => {
+    expect(planLimitHelper.capabilityOf(view, 'feature:whitelabel')).toBe(true)
+    expect(planLimitHelper.capabilityOf(view, 'feature:custom-domain')).toBe(false)
+    expect(planLimitHelper.capabilityOf(view, 'limit:seats')).toBe(false)
+    expect(planLimitHelper.capabilityOf(null, 'feature:whitelabel')).toBe(false)
+  })
+})

package/tests/pricing.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test'
+import { type AmountCheckoutPolicy, checkoutPricingHelper } from '../src/index.js'
+
+const policy: AmountCheckoutPolicy = {
+  currency: 'usd', minimumMinor: 500, maximumMinor: 50_000, defaultMinor: 1_000,
+  presetsMinor: [1_000, 2_000, 5_000, 10_000], fixedMinor: 0, rateBps: 200,
+}
+
+describe('amount checkout pricing', () => {
+  test('accepts exact boundaries and custom cents', () => {
+    expect(checkoutPricingHelper.assertCheckoutAmount(policy, 500)).toBe(500)
+    expect(checkoutPricingHelper.assertCheckoutAmount(policy, 501)).toBe(501)
+    expect(checkoutPricingHelper.assertCheckoutAmount(policy, 50_000)).toBe(50_000)
+  })
+
+  test('rejects values outside the net-credit bounds', () => {
+    expect(() => checkoutPricingHelper.assertCheckoutAmount(policy, 499)).toThrow()
+    expect(() => checkoutPricingHelper.assertCheckoutAmount(policy, 50_001)).toThrow()
+  })
+
+  test('grosses ten dollars up to ten dollars and twenty-one cents', () => {
+    expect(checkoutPricingHelper.chargeAmountMinor(1_000, policy)).toBe(1_021)
+  })
+
+  test('rejects invalid policy ordering, duplicate presets, and a 100% rate', () => {
+    expect(() => checkoutPricingHelper.assertAmountCheckoutPolicy({ ...policy, defaultMinor: 100 })).toThrow()
+    expect(() => checkoutPricingHelper.assertAmountCheckoutPolicy({ ...policy, presetsMinor: [1_000, 1_000] })).toThrow()
+    expect(() => checkoutPricingHelper.assertAmountCheckoutPolicy({ ...policy, rateBps: 10_000 })).toThrow()
+  })
+})

package/tests/view.spec.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  LimitKind, LimitWindow, PlanDuration, PlanStatus, SubscriptionStatus, entitlementViewHelper,
+  promoHelper,
+} from '../src/index.js'
+import type { EntitlementPlanView, ProductPlan } from '../src/index.js'
+
+const until = new Date('2026-10-01T00:00:00.000Z')
+const before = new Date('2026-09-15T00:00:00.000Z')
+const after = new Date('2026-10-15T00:00:00.000Z')
+
+describe('promos', () => {
+  test('no promo is always in force', () => {
+    expect(promoHelper.promoActive(undefined, undefined, after)).toBe(true)
+    expect(promoHelper.promoViewOf(undefined, undefined, after)).toBeUndefined()
+  })
+
+  test('a promo ends AT until, not after it', () => {
+    expect(promoHelper.promoActive({ until }, null, new Date(until.getTime() - 1))).toBe(true)
+    expect(promoHelper.promoActive({ until }, null, until)).toBe(false)
+  })
+
+  test('grandfathering keeps it for a subscription created before until — and only then', () => {
+    const promo = { until, grandfather: true }
+    expect(promoHelper.promoActive(promo, before, after)).toBe(true)
+    expect(promoHelper.promoActive(promo, until, after)).toBe(false)
+    expect(promoHelper.promoActive(promo, null, after)).toBe(false)
+    expect(promoHelper.promoActive({ until }, before, after)).toBe(false)
+  })
+
+  test('the view says whether it is kept for the plan', () => {
+    expect(promoHelper.promoViewOf({ until, grandfather: true }, before, after))
+      .toEqual({ until, grandfathered: true, active: true })
+    expect(promoHelper.promoViewOf({ until }, before, after)).toEqual({ until, grandfathered: false, active: false })
+  })
+})
+
+const plan: ProductPlan = {
+  productSku: 'pro', sku: 'pro-monthly', status: PlanStatus.Active, duration: PlanDuration.Monthly,
+  price: 20, title: 'Pro', rank: 10,
+  capabilities: [
+    { scope: 'feature', permissions: { whitelabel: true, legacy: false, unset: null } },
+    { scope: 'feature', permissions: { 'custom-domain': true }, promo: { until } },
+  ],
+  limits: {
+    seats: { kind: LimitKind.Occupancy, limit: 3, unit: 'seat' },
+    exports: { kind: LimitKind.Window, window: LimitWindow.Day, limit: 5 },
+    imports: { kind: LimitKind.Lifetime, limit: 1, promo: { until } },
+  },
+}
+
+describe('capability views', () => {
+  test('one row per granted permission; false and null are not listed', () => {
+    const rows = entitlementViewHelper.capabilityViewsOf(plan, null, before)
+    expect(rows.map(row => row.param)).toEqual(['feature:whitelabel', 'feature:custom-domain'])
+    expect(rows.every(row => row.granted)).toBe(true)
+  })
+
+  test('a lapsed promo ungrants but still lists the capability', () => {
+    const domain = entitlementViewHelper.capabilityViewsOf(plan, null, after).find(row => row.permission === 'custom-domain')
+    expect(domain).toMatchObject({ granted: false, promo: { active: false, grandfathered: false } })
+  })
+
+  test('a set under the reserved limit scope is not a capability', () => {
+    expect(entitlementViewHelper.capabilityViewsOf({ capabilities: [{ scope: 'limit', permissions: { seats: 3 } }] })).toEqual([])
+  })
+})
+
+describe('limit views', () => {
+  const at = new Date('2026-09-15T10:00:00.000Z')
+
+  test('used comes from the current window; a missing row is zero', () => {
+    const rows = entitlementViewHelper.limitViewsOf(plan, [
+      { key: 'exports', window: '2026-09-14', used: 5 },
+      { key: 'exports', window: '2026-09-15', used: 2 },
+      { key: 'seats', window: 'occupancy', used: 1 },
+    ], null, at)
+    expect(rows.find(row => row.key === 'exports')).toMatchObject({ used: 2, remaining: 3, param: 'limit:exports' })
+    expect(rows.find(row => row.key === 'seats')).toMatchObject({ used: 1, remaining: 2, unit: 'seat' })
+    expect(rows.find(row => row.key === 'imports')).toMatchObject({ used: 0, remaining: 1 })
+  })
+
+  test('only a window limit carries its bounds', () => {
+    const rows = entitlementViewHelper.limitViewsOf(plan, [], null, at)
+    expect(rows.find(row => row.key === 'exports')).toMatchObject({
+      window: LimitWindow.Day,
+      windowStart: new Date('2026-09-15T00:00:00.000Z'),
+      resetsAt: new Date('2026-09-16T00:00:00.000Z'),
+    })
+    expect(rows.find(row => row.key === 'seats')).not.toHaveProperty('resetsAt')
+  })
+
+  test('remaining floors at zero when the counter over-counts', () => {
+    const seats = entitlementViewHelper.limitViewsOf(plan, [{ key: 'seats', window: 'occupancy', used: 7 }], null, at)
+      .find(row => row.key === 'seats')
+    expect(seats).toMatchObject({ limit: 3, used: 7, remaining: 0 })
+  })
+
+  test('a lapsed promo makes the limit zero', () => {
+    expect(entitlementViewHelper.limitViewsOf(plan, [], null, after).find(row => row.key === 'imports'))
+      .toMatchObject({ limit: 0, remaining: 0, promo: { active: false } })
+  })
+})
+
+const planView: EntitlementPlanView = {
+  sku: 'pro-monthly', productSku: 'pro', title: 'Pro', rank: 10, free: false,
+  status: SubscriptionStatus.Active, paygate: 'stripe', subscriptionId: 'sub_1',
+  subscribedAt: before, periodEnd: after,
+}
+
+describe('the entitlement view', () => {
+  test('promos are measured against the subscription date on the plan view', () => {
+    const grandfathered: ProductPlan = {
+      ...plan, capabilities: [{ scope: 'feature', permissions: { beta: true }, promo: { until, grandfather: true } }],
+    }
+    const view = entitlementViewHelper.entitlementViewOf(grandfathered, planView, [], after)
+    expect(view.capabilities[0]).toMatchObject({ granted: true, promo: { grandfathered: true } })
+    expect(entitlementViewHelper.entitlementViewOf(grandfathered, { ...planView, subscribedAt: undefined }, [], after)
+      .capabilities[0].granted).toBe(false)
+    expect(view.at).toBe(after)
+  })
+
+  test('the wire form revives into dates', () => {
+    const view = entitlementViewHelper.entitlementViewOf(plan, planView, [], before)
+    const revived = entitlementViewHelper.reviveEntitlementView(JSON.parse(JSON.stringify(view)))
+    expect(revived).toEqual(view)
+    expect(revived.limits.find(row => row.key === 'exports')?.resetsAt).toBeInstanceOf(Date)
+    expect(entitlementViewHelper.reviveEntitlementView(view)).toEqual(view)
+  })
+})

package/src/model/subscription.ts

@@ -1,63 +0,0 @@
-import type { JSONSchemaType } from 'ajv'
-import type { PlanSubscription, SubscriptionPropagateBody } from '../types.js'
-import { ResourceValueSchema, PermissionSetSchema, DateSchema, EntityValueSchema, IdValueSchema } from '@owlmeans/auth'
-import { SubscriptionStatusSchema } from '../consts.js'
-import { CapabilityUsageSchema, LimitConfigSchema } from './utils.js'
-
-export const PlanSubscriptionSchema: JSONSchemaType<PlanSubscription> = {
-  type: 'object',
-  properties: {
-    sku: ResourceValueSchema,
-    entityId: EntityValueSchema,
-    paymentMethod: { ...IdValueSchema, nullable: true },
-    externalId: { ...IdValueSchema, nullable: true },
-    createdAt: DateSchema,
-    lastPaymentAt: { ...DateSchema, nullable: true },
-    trialUntil: { ...DateSchema, nullable: true },
-    startsdAt: DateSchema,
-    expirationAt: { ...DateSchema, nullable: true },
-    endsAt: { ...DateSchema, nullable: true },
-    archiveAt: { ...DateSchema, nullable: true },
-    suspendedAt: { ...DateSchema, nullable: true },
-    canceledAt: { ...DateSchema, nullable: true },
-    blockedAt: { ...DateSchema, nullable: true },
-    suspendedUntil: { ...DateSchema, nullable: true },
-    status: SubscriptionStatusSchema,
-    capabilities: { type: 'array', items: PermissionSetSchema, nullable: true },
-    limits: {
-      type: 'object', required: [], nullable: true,
-      additionalProperties: LimitConfigSchema
-    },
-    consumptions: {
-      type: 'object', required: [], nullable: true,
-      additionalProperties: CapabilityUsageSchema
-    }
-  },
-  required: ['sku', 'entityId', 'createdAt', 'startsdAt', 'status'],
-  additionalProperties: false,
-}
-
-export const SubscriptionPropagateBodySchema: JSONSchemaType<SubscriptionPropagateBody> = {
-  type: 'object',
-  properties: {
-    ...PlanSubscriptionSchema.properties,
-    service: { ...ResourceValueSchema, minLength: 2 },
-    externalId: IdValueSchema,
-  } as any, // @TODO Figure out why it doesn't work (probably different version of ajv)
-  required: ['externalId', 'service', ...PlanSubscriptionSchema.required],
-  additionalProperties: false,
-}
-
-/**
- * @deprecated Use SubscriptionPropogateBodySchema instead
- */
-export const SubscriptionPropogateBodySchema: JSONSchemaType<SubscriptionPropagateBody> = {
-  type: 'object',
-  properties: {
-    ...PlanSubscriptionSchema.properties,
-    service: { ...ResourceValueSchema, minLength: 2 },
-    externalId: IdValueSchema,
-  } as any, // @TODO Figure out why it doesn't work (probably different version of ajv)
-  required: ['externalId', 'service', ...PlanSubscriptionSchema.required],
-  additionalProperties: false,
-}

package/src/model/utils.ts

@@ -1,32 +0,0 @@
-
-import type { JSONSchemaType } from 'ajv'
-import type { LimitConfig, CapabilityUsage } from '../types.js'
-import { PlanDurationSchema } from '../consts.js'
-import { DateSchema } from '@owlmeans/auth'
-
-export const LimitConfigSchema: JSONSchemaType<LimitConfig> = {
-  type: 'object',
-  properties: {
-    interval: PlanDurationSchema,
-    measurment: { type: 'string', nullable: true, maxLength: 16 },
-    limit: { type: 'number' }
-  },
-  required: ['interval', 'limit'],
-  additionalProperties: false,
-}
-
-export const CapabilityUsageSchema: JSONSchemaType<CapabilityUsage> = {
-  type: 'object',
-  properties: {
-    interval: PlanDurationSchema,
-    measurment: { type: 'string', nullable: true, maxLength: 16 },
-    startedAt: DateSchema,
-    limit: { type: 'number' },
-    refreshedAt: { ...DateSchema, nullable: true },
-    refreshAt: { ...DateSchema, nullable: true },
-    lastConsumedAt: { ...DateSchema, nullable: true },
-    consumption: { type: 'number' }
-  },
-  required: ['interval', 'limit', 'startedAt', 'consumption'],
-  additionalProperties: false,
-}

package/src/modules.ts

@@ -1,43 +0,0 @@
-import { body, filter, entrypoint } from '@owlmeans/entrypoint'
-import { route, backend, RouteMethod } from '@owlmeans/route'
-import { paymentApi } from './consts.js'
-import { SubscriptionPropagateBodySchema } from './model/subscription.js'
-import { CreateCheckoutBodySchema } from './model/checkout.js'
-
-export const modules = [
-  entrypoint(route(paymentApi.subscription.base, '/subscription', backend())),
-  entrypoint(
-    route(paymentApi.subscription.propogate, '/propogate', backend(
-      paymentApi.subscription.base,
-      RouteMethod.POST
-    )),
-    filter(body(SubscriptionPropagateBodySchema))
-  ),
-  entrypoint(
-    route(paymentApi.subscription.propagate, '/propagate', backend(
-      paymentApi.subscription.base,
-      RouteMethod.POST
-    )),
-    filter(body(SubscriptionPropagateBodySchema))
-  )
-]
-
-export const serviceModules = [
-  entrypoint(route(paymentApi.service.base, '/payment-service', backend())),
-  entrypoint(
-    route(paymentApi.service.checkout.base, '/checkout', backend(paymentApi.service.base)),
-  ),
-  entrypoint(
-    route(paymentApi.service.checkout.session.base, '/session', backend(paymentApi.service.checkout.base)),
-  ),
-  entrypoint(
-    route(paymentApi.service.checkout.session.external.base, '/external', backend(paymentApi.service.checkout.session.base)),
-  ),
-  entrypoint(
-    route(paymentApi.service.checkout.session.external.create, '/create', backend(
-      paymentApi.service.checkout.session.external.base,
-      RouteMethod.POST
-    )),
-    filter(body(CreateCheckoutBodySchema))
-  )
-]

package/tests/entitlement.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=entitlement.spec.d.ts.map

package/tests/entitlement.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entitlement.spec.d.ts","sourceRoot":"","sources":["entitlement.spec.ts"],"names":[],"mappings":""}

package/tests/entitlement.spec.js

@@ -1,72 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { CAPABILITY_FEATURE_SCOPE, entitlementList, formatEntitlementParam, hasEntitlement, parseEntitlementParam, } from '../src/entitlement.js';
-const pro = [
-    { scope: 'renewable', permissions: { production: 1, credits: 5000 } },
-    { scope: CAPABILITY_FEATURE_SCOPE, permissions: { 'branding--whitelabel': true, 'domain--custom': true } },
-];
-describe('the parameter grammar', () => {
-    test('a bare permission has no scope and no floor', () => {
-        expect(parseEntitlementParam('domain--custom')).toEqual({ permission: 'domain--custom' });
-    });
-    test('a scope is everything before the first colon', () => {
-        expect(parseEntitlementParam('feature:branding--whitelabel'))
-            .toEqual({ scope: 'feature', permission: 'branding--whitelabel' });
-    });
-    test('a floor is parsed as a number', () => {
-        expect(parseEntitlementParam('renewable:credits>=100'))
-            .toEqual({ scope: 'renewable', permission: 'credits', atLeast: 100 });
-    });
-    test('formatting round-trips', () => {
-        for (const param of ['domain--custom', 'feature:branding--whitelabel', 'renewable:credits>=100']) {
-            expect(formatEntitlementParam(parseEntitlementParam(param))).toBe(param);
-        }
-    });
-});
-describe('the predicate', () => {
-    test('a held feature passes', () => {
-        expect(hasEntitlement(pro, 'feature:branding--whitelabel')).toBe(true);
-    });
-    test('a feature nobody granted does not', () => {
-        expect(hasEntitlement(pro, 'feature:branding--nonexistent')).toBe(false);
-    });
-    test('a scope that does not match is not consulted', () => {
-        expect(hasEntitlement(pro, 'renewable:branding--whitelabel')).toBe(false);
-        // …and without a scope, any set may answer.
-        expect(hasEntitlement(pro, 'branding--whitelabel')).toBe(true);
-    });
-    test('a numeric floor compares', () => {
-        expect(hasEntitlement(pro, 'renewable:credits>=5000')).toBe(true);
-        expect(hasEntitlement(pro, 'renewable:credits>=5001')).toBe(false);
-    });
-    test('a boolean cannot satisfy a numeric floor', () => {
-        expect(hasEntitlement(pro, 'feature:branding--whitelabel>=1')).toBe(false);
-    });
-    test('an explicit false is not a grant', () => {
-        expect(hasEntitlement([{ scope: 'feature', permissions: { x: false } }], 'feature:x')).toBe(false);
-        expect(hasEntitlement([{ scope: 'feature', permissions: { x: null } }], 'feature:x')).toBe(false);
-    });
-    test('no capabilities at all is a refusal, never a pass', () => {
-        expect(hasEntitlement(undefined, 'feature:branding--whitelabel')).toBe(false);
-        expect(hasEntitlement([], 'feature:branding--whitelabel')).toBe(false);
-    });
-    test('a malformed parameter refuses rather than throwing', () => {
-        // A gate that crashed on a typo would take down the endpoint it guards.
-        expect(() => hasEntitlement(pro, '')).not.toThrow();
-        expect(hasEntitlement(pro, '')).toBe(false);
-        expect(hasEntitlement(pro, 'feature:')).toBe(false);
-        expect(hasEntitlement(pro, 'renewable:credits>=abc')).toBe(true);
-    });
-});
-describe('listing', () => {
-    test('unions every granted capability, scoped', () => {
-        expect(entitlementList(pro).sort()).toEqual([
-            'feature:branding--whitelabel', 'feature:domain--custom',
-            'renewable:credits', 'renewable:production',
-        ]);
-    });
-    test('skips what is not granted', () => {
-        expect(entitlementList([{ scope: 'feature', permissions: { a: true, b: false, c: null } }]))
-            .toEqual(['feature:a']);
-    });
-});
-//# sourceMappingURL=entitlement.spec.js.map

package/tests/entitlement.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"entitlement.spec.js","sourceRoot":"","sources":["entitlement.spec.ts"],"names":[],"mappings":"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"}