@owlmeans/payment 0.1.0

package/src/model/utils.ts

@@ -0,0 +1,32 @@
+
+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

@@ -0,0 +1,15 @@
+import { body, filter, module } from '@owlmeans/module'
+import { route, backend, RouteMethod } from '@owlmeans/route'
+import { paymentApi } from './consts.js'
+import { SubscriptionPropogateBodySchema } from './model/subscription.js'
+
+export const modules = [
+  module(route(paymentApi.subscription.base, '/subscription', backend())),
+  module(
+    route(paymentApi.subscription.propogate, '/propogate', backend(
+      paymentApi.subscription.base,
+      RouteMethod.POST
+    )),
+    filter(body(SubscriptionPropogateBodySchema))
+  )
+]

package/src/service.ts

@@ -0,0 +1,95 @@
+import { createService, assertContext } from '@owlmeans/context'
+import type { ConfigRecord } from '@owlmeans/context'
+import { DEFAULT_ALIAS, PaymentEntityType } from './consts.js'
+import type { Localization, PaymentService } from './types.js'
+import type { Config, Context } from './utils/types.js'
+import { PLAN_RECORD_TYPE, PRODUCT_RECORD_PREFIX } from './consts.js'
+import { PaymentIdentificationError, UnknownProduct } from './errors.js'
+import type { Product, ProductPlan } from './types.js'
+import { fromConfigRecord } from '@owlmeans/config'
+import type { ResourceRecord } from '@owlmeans/resource'
+import { l10nToId } from './helper.js'
+import { DEFAULT_LNG } from '@owlmeans/i18n'
+import { EnvelopeKind, makeEnvelopeModel } from '@owlmeans/basic-envelope'
+import type { AuthCredentials } from '@owlmeans/auth'
+
+export const makePaymentService = (alias: string = DEFAULT_ALIAS): PaymentService => {
+  const service: PaymentService = createService<PaymentService>(alias, {
+    product: async sku => {
+      const context = assertContext(service.ctx) as Context
+
+      const configRes = context.getConfigResource()
+
+      const result = fromConfigRecord<ConfigRecord, Product & ResourceRecord>(await configRes.get(`${PRODUCT_RECORD_PREFIX}:${sku}`))
+
+      if (result == null) {
+        throw new UnknownProduct(sku)
+      }
+
+      return result as Product
+    },
+
+    plans: async (productSku, duration) => {
+      const context = assertContext(service.ctx) as Context
+      const configRes = context.getConfigResource()
+
+      const result = await configRes.list({
+        productSku, duration, recordType: PLAN_RECORD_TYPE
+      })
+
+      return result.items.map(
+        item => fromConfigRecord<ConfigRecord, ProductPlan & ResourceRecord>(item)
+      ) as ProductPlan[]
+    },
+
+    localize: async (lng, entity) => {
+      const context = assertContext(service.ctx) as Context
+      const configRes = context.getConfigResource()
+
+      const idsToCheck: string[] = []
+      if ("productSku" in entity) {
+        idsToCheck.push(l10nToId({ lng, type: PaymentEntityType.Plan, sku: entity.sku }, true))
+        idsToCheck.push(l10nToId({ lng: DEFAULT_LNG, type: PaymentEntityType.Plan, sku: entity.sku }, true))
+
+        idsToCheck.push(l10nToId({ lng, type: PaymentEntityType.Product, sku: entity.productSku }, true))
+        idsToCheck.push(l10nToId({ lng: DEFAULT_LNG, type: PaymentEntityType.Product, sku: entity.productSku }, true))
+      } else if ("sku" in entity) {
+        idsToCheck.push(l10nToId({ lng, type: PaymentEntityType.Product, sku: entity.sku }, true))
+        idsToCheck.push(l10nToId({ lng: DEFAULT_LNG, type: PaymentEntityType.Product, sku: entity.sku }, true))
+      } else {
+        idsToCheck.push(l10nToId({ lng, type: PaymentEntityType.CapabilitySet, sku: entity.scope }, true))
+        idsToCheck.push(l10nToId({ lng: DEFAULT_LNG, type: PaymentEntityType.CapabilitySet, sku: entity.scope }, true))
+      }
+
+      for (let id of idsToCheck) {
+        const l10n = await configRes.load(id)
+        if (l10n != null) {
+          return fromConfigRecord<ConfigRecord, Localization & ResourceRecord>(l10n)
+        }
+      }
+
+      return null
+    },
+
+    shallowAuthentication: async token => {
+      if (token == null) {
+        throw new PaymentIdentificationError('token')
+      }
+      const envelope = makeEnvelopeModel<AuthCredentials>(token, EnvelopeKind.Token)
+      const auth = envelope.message()
+      if (auth.profileId == null) {
+        throw new PaymentIdentificationError('profileId')
+      }
+
+      return auth.profileId
+    }
+  }, service => async () => {
+    service.initialized = true
+  })
+
+  return service
+}
+
+export const appendPaymentService = <C extends Config, T extends Context<C>>(
+  context: T, alias: string = DEFAULT_ALIAS
+): T => context.registerService(makePaymentService(alias))

package/src/types.ts

@@ -0,0 +1,119 @@
+import type { InitializedService } from '@owlmeans/context'
+
+import type { PaymentEntityType, PlanDuration, PlanStatus, ProductType, SubscriptionStatus } from './consts.js'
+import type { PermissionSet } from '@owlmeans/auth'
+
+export interface Product {
+  type: ProductType
+  sku: string
+  title: string
+  description?: string
+  defaultLng?: string
+  /**
+   * Related software services.
+   * Actually even if it's a physical product, it can have related 
+   * software services.
+   */
+  services?: string[]
+  capabilities?: PermissionSet[]
+}
+
+export interface Localization {
+  sku: string
+  type: PaymentEntityType
+  lng: string
+  title?: string
+  description?: string
+  keywords?: { [key: string]: string }
+}
+
+export interface ProductPlan {
+  productSku: string
+  sku: string
+  status: PlanStatus
+  payagateAliases?: {
+    [paygate: string]: string
+  }
+  duration: PlanDuration
+  trial?: number
+  gatedTrial?: boolean
+  price: number
+  order?: number
+  highlight?: string
+  currency?: string
+  originalPrice?: number
+  discount?: number
+  awaitingInterval?: number
+  title: string
+  description?: string
+  customUrl?: string
+  createdAt?: Date
+  archivedAt?: Date
+  /**
+   * Deprecation date should be set alongside suspnsion date (that should be set to the future).
+   * This way we can plan event when users loose access in case they don't upgrade.
+   */
+  deprecatedAt?: Date
+  supsendedAt?: Date
+  capabilities?: PermissionSet[]
+  limits?: { [key: string]: LimitConfig }
+}
+
+export interface PlanSubscription {
+  sku: string
+  entityId: string
+  paymentMethod?: string
+  externalId?: string
+  createdAt: Date
+  lastPaymentAt?: Date
+  trialUntil?: Date
+  startsdAt: Date
+  expirationAt?: Date
+  endsAt?: Date
+  archiveAt?: Date
+  suspendedAt?: Date
+  canceledAt?: Date
+  blockedAt?: Date
+  suspendedUntil?: Date
+  status: SubscriptionStatus
+  /**
+   * Custom capabilities for the particular subscription.
+   */
+  capabilities?: PermissionSet[]
+  /**
+   * Custom limits for the particular subscription.
+   */
+  limits?: { [key: string]: LimitConfig }
+  consumptions?: { [key: string]: CapabilityUsage }
+}
+
+export interface SubscriptionPropogateBody extends PlanSubscription {
+  service: string
+  externalId: string
+}
+
+export interface LimitConfig {
+  interval: PlanDuration
+  limit: number
+  measurment?: string
+}
+
+export interface CapabilityUsage extends LimitConfig {
+  startedAt: Date
+  refreshedAt?: Date
+  refreshAt?: Date
+  lastConsumedAt?: Date
+  consumption: number
+}
+
+type PaymentEntity = Product | ProductPlan | PermissionSet
+
+export interface PaymentService extends InitializedService {
+  product: (sku: string) => Promise<Product>
+
+  plans: (productSku: string, duration: PlanDuration) => Promise<ProductPlan[]>
+
+  localize: (lng: string, entity: PaymentEntity) => Promise<Localization | null>
+
+  shallowAuthentication: (token: string | null) => Promise<string>
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+
+export type * from './types.js'

package/src/utils/types.ts

@@ -0,0 +1,9 @@
+
+import type { CommonConfig, ConfigResourceAppend } from '@owlmeans/config'
+import type { BasicContext } from '@owlmeans/context'
+
+export interface Config extends CommonConfig { }
+
+export interface Context<C extends Config = Config> extends BasicContext<C>
+  , ConfigResourceAppend {
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+    "moduleResolution": "Bundler"
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/errors.ts","./src/helper.ts","./src/i18n.ts","./src/index.ts","./src/modules.ts","./src/service.ts","./src/types.ts","./src/model/index.ts","./src/model/localization.ts","./src/model/plan.ts","./src/model/product.ts","./src/model/subscription.ts","./src/model/utils.ts","./src/utils/index.ts","./src/utils/types.ts"],"version":"5.6.3"}