cabloy 5.1.122 → 5.1.124

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/controller/mockPayment.ts

@@ -0,0 +1,25 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+import { DtoMockPaymentComplete } from '../dto/mockPaymentComplete.tsx';
+import { DtoMockPaymentReceipt } from '../dto/mockPaymentReceipt.tsx';
+
+export interface IControllerOptionsMockPayment extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsMockPayment>('mock/payment-session', {
+  meta: { mode: ['dev', 'test'] },
+})
+export class ControllerMockPayment extends BeanBase {
+  @Web.post(':id/complete')
+  @Api.body(DtoMockPaymentReceipt)
+  async complete(
+    @Arg.param('id', v.tableIdentity()) id: TableIdentity,
+    @Arg.body() command: DtoMockPaymentComplete,
+  ): Promise<DtoMockPaymentReceipt> {
+    return await this.scope.service.payMock.completePaymentSession(id, command.outcome);
+  }
+}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/dto/mockPaymentComplete.tsx

@@ -0,0 +1,13 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsMockPaymentComplete extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsMockPaymentComplete>()
+export class DtoMockPaymentComplete {
+  @Api.field(z.enum(['succeeded', 'failed', 'cancelled']))
+  outcome: 'succeeded' | 'failed' | 'cancelled';
+}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/dto/mockPaymentReceipt.tsx

@@ -0,0 +1,16 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsMockPaymentReceipt extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsMockPaymentReceipt>()
+export class DtoMockPaymentReceipt {
+  @Api.field(v.tableIdentity())
+  paymentSessionId: TableIdentity;
+
+  @Api.field(v.required())
+  accepted: true;
+}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/index.ts';
+export * from './types/index.ts';
+export * from './.metadata/index.ts';

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/lib/index.ts

@@ -0,0 +1 @@
+export {};

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/service/payMock.ts

@@ -0,0 +1,78 @@
+import type { TableIdentity } from 'table-identity';
+
+import { createHmac, randomUUID } from 'node:crypto';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+export type TypeMockPaymentOutcome = 'succeeded' | 'failed' | 'cancelled';
+
+@Service()
+export class ServicePayMock extends BeanBase {
+  async completePaymentSession(paymentSessionId: TableIdentity, outcome: TypeMockPaymentOutcome) {
+    this._assertSimulatorEnabled();
+    const session = await this.$scope.pay.model.paymentSession.getById(paymentSessionId);
+    if (!session || String(session.userId) !== String(this.bean.passport.currentUser!.id)) {
+      this.app.throw(404, 'payment session not found');
+    }
+    if (
+      session.providerName !== 'pay-mock:mock' ||
+      session.clientName !== 'default' ||
+      session.environment !== 'sandbox'
+    ) {
+      this.app.throw(404, 'mock payment session not found');
+    }
+    if (session.state !== 'requires_action') {
+      this.app.throw(409, 'mock payment session is not actionable');
+    }
+    if (session.expiresAt <= new Date()) {
+      this.app.throw(409, 'payment session is expired');
+    }
+    const { clientOptions } = this.bean.payProvider.resolveByName(
+      session.providerName,
+      session.clientName,
+    );
+    if (clientOptions.environment !== session.environment) {
+      this.app.throw(500, 'mock payment provider environment is inconsistent');
+    }
+    const secret = clientOptions.secretWebhook;
+    if (typeof secret !== 'string' || !secret) {
+      this.app.throw(500, 'mock webhook secret is not configured');
+    }
+
+    const rawBody = JSON.stringify({
+      eventId: `mock-payment-${randomUUID()}`,
+      eventType: `payment.${outcome}`,
+      paymentSessionId: String(session.id),
+      state: outcome,
+      amountMinor: session.amountMinor,
+      currency: session.currency,
+      providerPaymentId: session.providerPaymentId ?? `mock-payment-${session.id}`,
+      ...(outcome === 'succeeded' ? { providerCaptureId: `mock-capture-${session.id}` } : {}),
+    });
+    const signature = createHmac('sha256', secret).update(rawBody).digest('hex');
+    const instanceName = this.ctx.instanceName;
+    const instanceHeaderField = this.app.config.instance.headerField;
+    const response = await fetch(
+      this.app.util.getAbsoluteUrlByApiPath(
+        `/pay/webhook/${session.providerName}/${session.clientName}`,
+      ),
+      {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          'x-pay-mock-signature': signature,
+          ...(instanceName && instanceHeaderField ? { [instanceHeaderField]: instanceName } : {}),
+        },
+        body: rawBody,
+      },
+    );
+    if (!response.ok) this.app.throw(502, 'mock payment webhook was rejected');
+    return { paymentSessionId: session.id, accepted: true as const };
+  }
+
+  private _assertSimulatorEnabled() {
+    if (this.app.meta.env.META_MODE === 'prod') {
+      this.app.throw(404, 'mock payment simulator is unavailable');
+    }
+  }
+}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/types/index.ts

@@ -0,0 +1,10 @@
+declare module 'vona' {
+  export interface VonaConfigEnv {
+    PAY_MOCK_DEFAULT_CREDENTIAL: string | undefined;
+    PAY_MOCK_DEFAULT_WEBHOOK: string | undefined;
+    PAY_MOCK_SECONDARY_CREDENTIAL: string | undefined;
+    PAY_MOCK_SECONDARY_WEBHOOK: string | undefined;
+  }
+}
+
+export {};

package/vona/src/suite-vendor/a-pay/modules/pay-mock/test/payMock.test.ts

@@ -0,0 +1,141 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+interface IFixture {
+  userId?: number;
+  paymentSessionId?: number;
+}
+
+async function createFixture(suffix: string): Promise<IFixture> {
+  const user = await app.bean.user.register({ name: `pay-mock-${suffix}` }, true);
+  await app.bean.passport.signinMock(`pay-mock-${suffix}` as any);
+  const session = await app.scope('a-pay').service.paymentSession.create({
+    userId: user.id,
+    payScene: 'commerce-payment:commerceOrder',
+    businessReference: `business-${suffix}`,
+    amountMinor: 1299,
+    currency: 'USD',
+    correlationId: `payment-${suffix}`,
+  });
+  await app.scope('a-pay').service.paymentSession.start(session.id);
+  return { userId: user.id as number, paymentSessionId: session.id as number };
+}
+
+async function cleanup(fixture: IFixture) {
+  const pay = app.scope('a-pay');
+  if (fixture.paymentSessionId !== undefined) {
+    await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.paymentAudit.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.paymentSession.delete({ id: fixture.paymentSessionId });
+  }
+  if (fixture.userId !== undefined) {
+    await app.scope('home-user').model.roleUser.delete({ userId: fixture.userId });
+    await app.bean.user.removeById(fixture.userId);
+  }
+  await app.bean.passport.signout();
+}
+
+describe('payMock.test.ts', { concurrency: false }, () => {
+  it('captures Vona env secrets in the mock Provider options', () => {
+    const options = app.bean.payProvider.getOptions('pay-mock:mock', 'default');
+    assert.equal(options.secretCredential, app.meta.env.PAY_MOCK_DEFAULT_CREDENTIAL);
+    assert.equal(options.secretWebhook, app.meta.env.PAY_MOCK_DEFAULT_WEBHOOK);
+    assert.equal(String(options.secretCredential).startsWith('env:' + '//'), false);
+    assert.equal(String(options.secretWebhook).startsWith('env:' + '//'), false);
+    assert.deepEqual(options.capabilities, {
+      redirectCheckout: false,
+      embeddedCheckout: true,
+      automaticCapture: true,
+      manualCapture: false,
+      refunds: true,
+      partialRefunds: true,
+      webhooks: true,
+    });
+    assert.deepEqual(
+      app.bean.payProvider.resolveByName('pay-mock:mock', 'secondary').clientOptions.capabilities,
+      options.capabilities,
+    );
+  });
+
+  it('submits server-derived mock payment facts through the signed webhook', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createFixture('success'));
+        const receipt = await app
+          .scope('pay-mock')
+          .service.payMock.completePaymentSession(fixture.paymentSessionId!, 'succeeded');
+        assert.deepEqual(receipt, { paymentSessionId: fixture.paymentSessionId, accepted: true });
+        const pay = app.scope('a-pay');
+        const [session, inboxes, audits, outbox] = await Promise.all([
+          pay.model.paymentSession.getById(fixture.paymentSessionId!),
+          pay.model.webhookInbox.select({ where: { paymentSessionId: fixture.paymentSessionId } }),
+          pay.model.paymentAudit.select({ where: { paymentSessionId: fixture.paymentSessionId } }),
+          pay.model.outboxEvent.select({ where: { paymentSessionId: fixture.paymentSessionId } }),
+        ]);
+        assert.equal(session?.state, 'succeeded');
+        assert.equal(inboxes.length, 1);
+        assert.equal(audits.filter(item => item.source === 'webhook').length, 1);
+        assert.equal(outbox.length, 1);
+      } finally {
+        await cleanup(fixture);
+      }
+    });
+  });
+
+  it('completes a payment session in the active named instance', async () => {
+    await app.bean.executor.mockCtx(
+      async () => {
+        const fixture: IFixture = {};
+        try {
+          Object.assign(fixture, await createFixture(`named-${randomUUID().slice(0, 12)}`));
+          const receipt = await app
+            .scope('pay-mock')
+            .service.payMock.completePaymentSession(fixture.paymentSessionId!, 'succeeded');
+          assert.deepEqual(receipt, { paymentSessionId: fixture.paymentSessionId, accepted: true });
+          const pay = app.scope('a-pay');
+          const [session, inboxes, audits, outbox] = await Promise.all([
+            pay.model.paymentSession.getById(fixture.paymentSessionId!),
+            pay.model.webhookInbox.select({
+              where: { paymentSessionId: fixture.paymentSessionId },
+            }),
+            pay.model.paymentAudit.select({
+              where: { paymentSessionId: fixture.paymentSessionId },
+            }),
+            pay.model.outboxEvent.select({ where: { paymentSessionId: fixture.paymentSessionId } }),
+          ]);
+          assert.equal(session?.state, 'succeeded');
+          assert.equal(inboxes.length, 1);
+          assert.equal(audits.filter(item => item.source === 'webhook').length, 1);
+          assert.equal(outbox.length, 1);
+        } finally {
+          await cleanup(fixture);
+        }
+      },
+      { instanceName: 'shareTest' as any },
+    );
+  });
+
+  it('does not simulate a session that is no longer actionable', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createFixture('terminal'));
+        await app
+          .scope('pay-mock')
+          .service.payMock.completePaymentSession(fixture.paymentSessionId!, 'cancelled');
+        await assert.rejects(
+          app
+            .scope('pay-mock')
+            .service.payMock.completePaymentSession(fixture.paymentSessionId!, 'cancelled'),
+          { status: 409 },
+        );
+      } finally {
+        await cleanup(fixture);
+      }
+    });
+  });
+});

package/vona/src/suite-vendor/a-pay/modules/pay-mock/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vona-module-pay-paypal",
+  "version": "5.0.1",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {
+    "vona-module-a-pay": "workspace:*"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "pay-paypal",
+  "vonaModule": {
+    "dependencies": {
+      "a-pay": "5.0.0",
+      "a-vona": "5.0.0"
+    }
+  }
+}

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/.metadata/index.ts

@@ -0,0 +1,62 @@
+// eslint-disable
+/** payProvider: begin */
+export * from '../bean/payProvider.paypal.ts';
+import type { IPayProviderOptionsPaypal } from '../bean/payProvider.paypal.ts';
+import 'vona-module-a-pay';
+declare module 'vona-module-a-pay' {
+  
+    export interface IPayProviderRecord {
+      'pay-paypal:paypal': IPayProviderOptionsPaypal;
+    }
+
+  
+}
+declare module 'vona-module-pay-paypal' {
+  
+        export interface PayProviderPaypal {
+          /** @internal */
+          get scope(): ScopeModulePayPaypal;
+        }
+
+          export interface PayProviderPaypal {
+            get $beanFullName(): 'pay-paypal.payProvider.paypal';
+            get $onionName(): 'pay-paypal:paypal';
+            get $onionOptions(): IPayProviderOptionsPaypal;
+          } 
+}
+/** payProvider: end */
+/** payProvider: begin */
+import type { PayProviderPaypal } from '../bean/payProvider.paypal.ts';
+export interface IModulePayProvider {
+  'paypal': PayProviderPaypal;
+}
+/** payProvider: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModulePayPaypal extends BeanScopeBase {}
+
+export interface ScopeModulePayPaypal {
+  util: BeanScopeUtil;
+payProvider: IModulePayProvider;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'pay-paypal': ScopeModulePayPaypal;
+  }
+
+  export interface IBeanScopeContainer {
+    payPaypal: ScopeModulePayPaypal;
+  }
+  
+  
+
+  
+
+  
+}
+/** scope: end */

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'pay-paypal';
+export { ScopeModulePayPaypal as ScopeModule } from './index.ts';

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/bean/payProvider.paypal.ts

@@ -0,0 +1,91 @@
+import type {
+  IDecoratorPayProviderOptions,
+  IPayProviderClientOptions,
+  IPayProviderClientRecord,
+  IPayProviderExecute,
+  IPayProviderPaymentInput,
+  IPayProviderPaymentSnapshot,
+  IPayProviderRefundInput,
+  IPayProviderRefundSnapshot,
+  IPayProviderVerifiedWebhook,
+  IPayProviderWebhookInput,
+} from 'vona-module-a-pay';
+
+import { BeanBase, useApp } from 'vona';
+import { PayProvider } from 'vona-module-a-pay';
+
+export interface IPayProviderPaypalClientRecord extends IPayProviderClientRecord {}
+
+export interface IPayProviderPaypalClientOptions extends IPayProviderClientOptions {
+  secretCredential: { clientId: string | undefined; clientSecret: string | undefined };
+  webhookId: string | undefined;
+}
+
+const app = useApp();
+
+export interface IPayProviderOptionsPaypal extends IDecoratorPayProviderOptions<
+  IPayProviderPaypalClientRecord,
+  IPayProviderPaypalClientOptions
+> {}
+
+@PayProvider<IPayProviderOptionsPaypal>({
+  base: {
+    capabilities: {
+      redirectCheckout: true,
+      embeddedCheckout: false,
+      automaticCapture: true,
+      manualCapture: false,
+      refunds: true,
+      partialRefunds: true,
+      webhooks: true,
+    },
+  },
+  clients: {
+    default: {
+      environment: 'sandbox',
+      secretCredential: {
+        clientId: app.meta.env.PAYPAL_CLIENT_ID,
+        clientSecret: app.meta.env.PAYPAL_CLIENT_SECRET,
+      },
+      webhookId: app.meta.env.PAYPAL_WEBHOOK_ID,
+    },
+  },
+})
+export class PayProviderPaypal
+  extends BeanBase
+  implements IPayProviderExecute<IPayProviderPaypalClientOptions>
+{
+  async startPayment(
+    _input: IPayProviderPaymentInput,
+    _clientOptions: IPayProviderPaypalClientOptions,
+  ): Promise<IPayProviderPaymentSnapshot> {
+    this.app.throw(501, 'PayPal provider is not configured');
+  }
+
+  async queryPayment(
+    _input: IPayProviderPaymentInput,
+    _clientOptions: IPayProviderPaypalClientOptions,
+  ): Promise<IPayProviderPaymentSnapshot> {
+    this.app.throw(501, 'PayPal provider is not configured');
+  }
+
+  async createRefund(
+    _input: IPayProviderRefundInput,
+    _clientOptions: IPayProviderPaypalClientOptions,
+  ): Promise<IPayProviderRefundSnapshot> {
+    this.app.throw(501, 'PayPal provider is not configured');
+  }
+
+  async verifyWebhook(
+    _input: IPayProviderWebhookInput,
+    _clientOptions: IPayProviderPaypalClientOptions,
+  ): Promise<IPayProviderVerifiedWebhook> {
+    this.app.throw(501, 'PayPal webhook verification is not configured');
+  }
+}
+
+declare module 'vona-module-a-pay' {
+  export interface IPayProviderRecord {
+    'pay-paypal:paypal': IPayProviderOptionsPaypal;
+  }
+}

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/index.ts';
+export * from './types/index.ts';
+export * from './.metadata/index.ts';

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/lib/index.ts

@@ -0,0 +1 @@
+export {};

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/src/types/index.ts

@@ -0,0 +1,9 @@
+declare module 'vona' {
+  export interface VonaConfigEnv {
+    PAYPAL_CLIENT_ID: string | undefined;
+    PAYPAL_CLIENT_SECRET: string | undefined;
+    PAYPAL_WEBHOOK_ID: string | undefined;
+  }
+}
+
+export {};

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite-vendor/a-pay/modules/pay-paypal/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

package/vona/src/suite-vendor/a-pay/modules/pay-stripe/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vona-module-pay-stripe",
+  "version": "5.0.1",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {
+    "vona-module-a-pay": "workspace:*"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "pay-stripe",
+  "vonaModule": {
+    "dependencies": {
+      "a-pay": "5.0.0",
+      "a-vona": "5.0.0"
+    }
+  }
+}