cabloy 5.1.122 → 5.1.124

package/zova/src/suite/a-commerce/modules/commerce-trade/src/page/payment/controller.tsx

@@ -1,48 +1,113 @@
+import type { ModelPaymentSession } from 'zova-module-a-pay';
+import type { ModelPayMockPayment } from 'zova-module-pay-mock';
+
 import { z } from 'zod';
 import { BeanControllerPageBase, Use } from 'zova';
 import { Controller } from 'zova-module-a-bean';
+import { $QueryEnsureLoaded } from 'zova-module-a-model';
+import { ZPaymentNextAction } from 'zova-module-a-pay';
 import { ZPage } from 'zova-module-home-base';
 
-import { ModelPayment } from '../../model/payment.js';
+import { ModelOrderMine } from '../../model/orderMine.js';
 
 export const ControllerPagePaymentSchemaParams = z.object({
-  attemptId: z.string(),
+  paymentSessionId: z.string(),
+  orderId: z.string(),
   locale: z.string().optional(),
 });
 export const ControllerPagePaymentSchemaQuery = z.object({});
 
+type TypeMockPaymentOutcome = 'succeeded' | 'failed' | 'cancelled';
+
 @Controller()
 export class ControllerPagePayment extends BeanControllerPageBase {
+  @Use({ beanFullName: 'a-pay.model.paymentSession' })
+  $$modelPaymentSession: ModelPaymentSession;
+
+  @Use({ beanFullName: 'pay-mock.model.payMockPayment' })
+  $$modelPayMockPayment: ModelPayMockPayment;
+
   @Use()
-  $$modelPayment: ModelPayment;
+  $$modelOrderMine: ModelOrderMine;
 
+  paymentSessionId?: string;
+  orderId?: string;
   submitting = false;
-  idempotencyKeys: Partial<Record<'succeeded' | 'failed' | 'cancelled', string>> = {};
+  waitingForOrder = false;
+  message?: string;
+
+  protected async __init__() {
+    this.paymentSessionId = this.$computed(() => this.$params.paymentSessionId);
+    this.orderId = this.$computed(() => this.$params.orderId);
+    if (this.$ssr.isRuntimeSsrHydrated) {
+      await $QueryEnsureLoaded(() => this.queryPaymentSession);
+      await $QueryEnsureLoaded(() => this.queryOrder);
+    }
+  }
 
-  get attemptId() {
-    return this.$params.attemptId;
+  get queryPaymentSession() {
+    return this.$$modelPaymentSession.view(this.paymentSessionId!);
+  }
+
+  get queryOrder() {
+    return this.$$modelOrderMine.viewMine(this.orderId!);
+  }
+
+  async start() {
+    if (!this.paymentSessionId || this.submitting) return;
+    this.submitting = true;
+    this.message = undefined;
+    try {
+      await this.$$modelPaymentSession.start(this.paymentSessionId).mutateAsync();
+      await this.queryPaymentSession?.refetch();
+    } catch (error: any) {
+      this.message = error.message;
+    } finally {
+      this.submitting = false;
+    }
   }
 
-  async settle(outcome: 'succeeded' | 'failed' | 'cancelled') {
-    if (this.submitting) return;
+  async settle(outcome: TypeMockPaymentOutcome) {
+    if (!this.paymentSessionId || this.submitting) return;
     this.submitting = true;
+    this.message = undefined;
     try {
-      const idempotencyKey =
-        this.idempotencyKeys[outcome] ?? `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
-      this.idempotencyKeys[outcome] = idempotencyKey;
-      const result = await this.$$modelPayment.outcome().mutateAsync({
-        attemptId: this.attemptId,
-        body: { outcome, idempotencyKey },
-      });
-      this.$router.push({
-        name: 'commerce-trade:order',
-        params: { id: String(result.orderId) },
-      });
+      await this.$$modelPayMockPayment.complete(this.paymentSessionId).mutateAsync({ outcome });
+      await this._waitForSettlement(outcome);
+    } catch (error: any) {
+      this.message = error.message;
     } finally {
       this.submitting = false;
     }
   }
 
+  private async _waitForSettlement(outcome: TypeMockPaymentOutcome) {
+    this.waitingForOrder = true;
+    const terminalSessionState = outcome;
+    const terminalOrderState = outcome === 'succeeded' ? 'paid' : 'cancelled';
+    try {
+      for (let attempt = 0; attempt < 60; attempt++) {
+        const session = await this.queryPaymentSession?.refetch();
+        const order = await this.scope.api.commerceTradeOrder.viewMine({
+          params: { id: this.orderId! },
+        });
+        if (session?.data?.state === terminalSessionState && order?.state === terminalOrderState) {
+          await this.queryOrder?.refetch();
+          await this.$router.push({
+            name: 'commerce-trade:order',
+            params: { id: this.orderId, locale: this.$params.locale },
+          });
+          return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 500));
+      }
+      this.message =
+        'Payment confirmation is still pending. Open the order to check its latest status.';
+    } finally {
+      this.waitingForOrder = false;
+    }
+  }
+
   protected render() {
     if (!this.$ssr.isRuntimeSsrHydrated) {
       return (
@@ -51,36 +116,84 @@ export class ControllerPagePayment extends BeanControllerPageBase {
         </ZPage>
       );
     }
+    const session = this.queryPaymentSession?.data;
+    const isMockSession = session?.providerName === 'pay-mock:mock';
+    const isCreated = session?.state === 'created';
+    const isActionable = session?.state === 'requires_action';
     return (
       <ZPage>
         <section class="mx-auto max-w-xl p-6">
-          <h1 class="text-3xl font-semibold">Mock payment</h1>
+          <h1 class="text-3xl font-semibold">Payment</h1>
           <p class="mt-3 text-base-content/70">
-            Choose a server-authoritative mock payment outcome for this order.
+            Payment status is verified before Commerce updates the order.
           </p>
-          <div class="mt-6 flex flex-wrap gap-3">
+          {isCreated && (
             <button
-              class="btn btn-primary"
+              class="btn btn-primary mt-6"
               disabled={this.submitting}
-              onClick={() => this.settle('succeeded')}
+              onClick={() => this.start()}
             >
-              Payment succeeded
+              Start payment
             </button>
-            <button
-              class="btn btn-outline"
+          )}
+          {!isCreated && !this.waitingForOrder && (
+            <ZPaymentNextAction
+              action={session?.nextAction}
               disabled={this.submitting}
-              onClick={() => this.settle('failed')}
-            >
-              Payment failed
-            </button>
-            <button
-              class="btn btn-error btn-outline"
-              disabled={this.submitting}
-              onClick={() => this.settle('cancelled')}
-            >
-              Cancel payment
-            </button>
-          </div>
+              onRefresh={async () => {
+                await this.queryPaymentSession?.refetch();
+              }}
+            />
+          )}
+          {isMockSession && isActionable && (
+            <section class="mt-6 rounded border border-dashed border-base-300 p-4">
+              <h2 class="font-semibold">Mock payment simulator</h2>
+              <p class="mt-1 text-sm text-base-content/70">
+                Available only when the server enables the development/test mock provider.
+              </p>
+              <div class="mt-3 flex flex-wrap gap-3">
+                <button
+                  class="btn btn-primary"
+                  disabled={this.submitting || this.waitingForOrder}
+                  onClick={() => this.settle('succeeded')}
+                >
+                  Payment succeeded
+                </button>
+                <button
+                  class="btn btn-outline"
+                  disabled={this.submitting || this.waitingForOrder}
+                  onClick={() => this.settle('failed')}
+                >
+                  Payment failed
+                </button>
+                <button
+                  class="btn btn-error btn-outline"
+                  disabled={this.submitting || this.waitingForOrder}
+                  onClick={() => this.settle('cancelled')}
+                >
+                  Cancel payment
+                </button>
+              </div>
+            </section>
+          )}
+          {this.waitingForOrder && (
+            <p class="mt-6 text-base-content/70" aria-live="polite">
+              Waiting for verified provider confirmation and order settlement…
+            </p>
+          )}
+          {session && !isCreated && !isActionable && !this.waitingForOrder && (
+            <p class="mt-6 text-base-content/70">Payment session state: {session.state}</p>
+          )}
+          {this.message && (
+            <div class="alert alert-error mt-6" role="alert">
+              <span>{this.message}</span>
+            </div>
+          )}
+          {this.queryPaymentSession?.error && (
+            <div class="alert alert-error mt-6" role="alert">
+              <span>{this.queryPaymentSession.error.message}</span>
+            </div>
+          )}
         </section>
       </ZPage>
     );

package/zova/src/suite/a-commerce/modules/commerce-trade/src/routes.ts

@@ -21,7 +21,7 @@ export const routes: IModuleRoute[] = [
   },
   {
     name: 'payment',
-    path: 'payment/:attemptId/:locale?',
+    path: 'payment/:paymentSessionId/:orderId/:locale?',
     component: ZPagePayment,
     meta: { locale: true, requiresAuth: true },
   },

package/zova/src/suite-vendor/a-pay/modules/a-pay/cli/openapi.config.ts

@@ -0,0 +1,9 @@
+import type { ZovaOpenapiConfigModule } from 'zova-openapi';
+
+export default function (): ZovaOpenapiConfigModule {
+  return {
+    operations: {
+      match: ['PaymentSession_start', 'PaymentSession_view'],
+    },
+  };
+}

package/zova/src/suite-vendor/a-pay/modules/a-pay/package.json

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

package/zova/src/suite-vendor/a-pay/modules/a-pay/src/.metadata/component/paymentNextAction.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerPaymentNextActionProps } from '../../component/paymentNextAction/controller.jsx';
+
+import { ControllerPaymentNextAction } from '../../component/paymentNextAction/controller.jsx';
+export type ZPaymentNextActionProps = {
+  controllerRef?: (ref: ControllerPaymentNextAction) => void;
+} & ControllerPaymentNextActionProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerPaymentNextActionProps,
+  keyof typeof ControllerPaymentNextAction.$propsDefault
+>;
+declare module 'zova-module-a-pay' {
+  export interface ControllerPaymentNextAction {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZPaymentNextAction = defineComponent((_props: ZPaymentNextActionProps) => {
+  useController(ControllerPaymentNextAction, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions());
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'a-pay:paymentNextAction': ControllerPaymentNextActionProps;
+  }
+}

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

@@ -0,0 +1,217 @@
+// eslint-disable
+/** model: begin */
+export * from '../model/paymentSession.js';
+import { IModelOptionsPaymentSession } from '../model/paymentSession.js';
+import 'zova-module-a-model';
+declare module 'zova-module-a-model' {
+  
+    export interface IModelRecord {
+      'a-pay:paymentSession': IModelOptionsPaymentSession;
+    }
+
+  
+}
+declare module 'zova-module-a-pay' {
+  
+        export interface ModelPaymentSession {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+        export interface ModelPaymentSession {
+          get $beanFullName(): 'a-pay.model.paymentSession';
+          get $onionName(): 'a-pay:paymentSession';
+          get $onionOptions(): IModelOptionsPaymentSession;
+        } 
+}
+/** model: end */
+/** model: begin */
+import { ModelPaymentSession } from '../model/paymentSession.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-pay.model.paymentSession': ModelPaymentSession;
+  }
+}
+/** model: end */
+/** api: begin */
+export * from '../api/paymentSession.js';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-a-pay' {
+  
+        export interface ApiPaymentSession {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+        export interface ApiPaymentSession {
+          get $beanFullName(): 'a-pay.api.paymentSession';
+          get $onionName(): 'a-pay:paymentSession';
+          
+        } 
+}
+/** api: end */
+/** api: begin */
+import { ApiPaymentSession } from '../api/paymentSession.js';
+export interface IModuleApi {
+  'paymentSession': ApiPaymentSession;
+}
+/** api: end */
+/** api: begin */
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-pay.api.paymentSession': ApiPaymentSession;
+  }
+}
+/** api: end */
+/** openapi: begin */
+export * from '../api/openapi/index.js';
+/** openapi: end */
+/** apiSchema: begin */
+export * from '../apiSchema/paymentSession.js';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-a-pay' {
+  
+        export interface ApiSchemaPaymentSession {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+        export interface ApiSchemaPaymentSession {
+          get $beanFullName(): 'a-pay.apiSchema.paymentSession';
+          get $onionName(): 'a-pay:paymentSession';
+          
+        } 
+}
+/** apiSchema: end */
+/** apiSchema: begin */
+import { ApiSchemaPaymentSession } from '../apiSchema/paymentSession.js';
+export interface IModuleApiSchema {
+  'paymentSession': ApiSchemaPaymentSession;
+}
+/** apiSchema: end */
+/** apiSchema: begin */
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-pay.apiSchema.paymentSession': ApiSchemaPaymentSession;
+  }
+}
+/** apiSchema: end */
+/** service: begin */
+export * from '../service/paymentCoordinator.js';
+
+import 'zova-module-a-bean';
+declare module 'zova-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'a-pay:paymentCoordinator': never;
+    }
+
+  
+}
+declare module 'zova-module-a-pay' {
+  
+        export interface ServicePaymentCoordinator {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+        export interface ServicePaymentCoordinator {
+          get $beanFullName(): 'a-pay.service.paymentCoordinator';
+          get $onionName(): 'a-pay:paymentCoordinator';
+          
+        } 
+}
+/** service: end */
+/** service: begin */
+import { ServicePaymentCoordinator } from '../service/paymentCoordinator.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-pay.service.paymentCoordinator': ServicePaymentCoordinator;
+  }
+}
+/** service: end */
+/** controller: begin */
+export * from '../component/paymentNextAction/controller.jsx';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-a-pay' {
+  
+        export interface ControllerPaymentNextAction {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        } 
+}
+/** controller: end */
+/** controller: begin */
+import { ControllerPaymentNextAction } from '../component/paymentNextAction/controller.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordLocal {
+    'a-pay.controller.paymentNextAction': ControllerPaymentNextAction;
+  }
+}
+/** controller: end */
+
+/** components: begin */
+export * from './component/paymentNextAction.js';
+import { ZPaymentNextAction } from './component/paymentNextAction.js';
+export const components = {
+  'paymentNextAction': ZPaymentNextAction,
+};
+import 'zova';
+declare module 'zova' {
+export interface IComponentRecord {
+  'a-pay:paymentNextAction': ControllerPaymentNextAction;
+}
+export interface IZovaComponentRecord {
+  'a-pay:paymentNextAction': typeof ZPaymentNextAction;
+}
+}
+/** components: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'zova';
+import { Scope } from 'zova-module-a-bean';
+
+@Scope()
+export class ScopeModuleAPay extends BeanScopeBase {}
+
+export interface ScopeModuleAPay {
+  util: BeanScopeUtil;
+api: IModuleApi;
+apiSchema: IModuleApiSchema;
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'a-pay': ScopeModuleAPay;
+  }
+  
+  
+
+  
+
+  
+}
+
+/** scope: end */

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

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-pay';
+export { ScopeModuleAPay as ScopeModule } from './index.js';

package/zova/src/suite-vendor/a-pay/modules/a-pay/src/api/openapi/baseURL.ts

@@ -0,0 +1,5 @@
+import type { ZovaSys } from 'zova';
+
+export const OpenApiBaseURL = (sys: ZovaSys) => {
+  return sys.util.getOpenApiBaseURL('OPENAPI_BASE_URL_A_PAY');
+};

package/zova/src/suite-vendor/a-pay/modules/a-pay/src/api/openapi/index.ts

@@ -0,0 +1,3 @@
+export * from './baseURL.js';
+export * from './schemas.js';
+export * from './types.js';