cabloy 5.1.126 → 5.1.127

package/vona/src/suite/a-commerce/modules/commerce-catalog/test/categoryPresentation.test.ts

@@ -0,0 +1,218 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import {
+  DtoCategoryCreate,
+  DtoCategorySelectResItem,
+  DtoCategoryUpdate,
+  DtoCategoryView,
+} from 'vona-module-commerce-catalog';
+
+function findComponent(apiJson: any, predicate: (properties: any) => boolean) {
+  return Object.values(apiJson.components!.schemas as any).find(item => {
+    return predicate((item as any).properties);
+  }) as any;
+}
+
+function getEntryForm(component: any) {
+  const pageEntry = component?.rest?.blocks?.[0];
+  const formBlock = pageEntry?.options?.blocks?.[0];
+  const toolbarBlock = pageEntry?.options?.blocks?.[1];
+  assert.equal(pageEntry?.render, 'basic-pageentry:blockPageEntry');
+  assert.equal(formBlock?.render, 'basic-pageentry:blockForm');
+  assert.equal(toolbarBlock?.render, 'basic-pageentry:blockToolbarRow');
+  return toolbarBlock;
+}
+
+describe('categoryPresentation.test.ts', () => {
+  it('action:category:presentationMetadata', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const createJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryCreate);
+      const createComponent = findComponent(createJson, properties => {
+        return (
+          properties?.name &&
+          properties?.parentId &&
+          properties?.published &&
+          properties?.description
+        );
+      });
+      const createProperties = createComponent.properties;
+      assert.deepEqual(Object.keys(createProperties).sort(), [
+        'description',
+        'name',
+        'parentId',
+        'published',
+      ]);
+      assert.equal(
+        createProperties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.deepEqual(createProperties.parentId.rest.form.options, {
+        resource: 'commerce-catalog:category',
+        relationName: 'parent',
+      });
+      assert.equal(createProperties.published.rest.form.render, 'basic-select:formFieldSelect');
+      assert.deepEqual(
+        createProperties.published.rest.form.options.items.map((item: any) => item.value),
+        [false, true],
+      );
+      assert.ok(
+        createProperties.published.rest.form.options.items.every(
+          (item: any) => item.title?.toJSON && item.title?.toString,
+        ),
+      );
+      const createToolbar = getEntryForm(createComponent);
+      assert.deepEqual(
+        createToolbar.options.actions.map((action: any) => action.render),
+        ['basic-form:actionSubmit', 'basic-form:actionBack'],
+      );
+
+      const updateJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryUpdate);
+      const updateComponent = findComponent(updateJson, properties => {
+        return (
+          properties?.name &&
+          properties?.parentId &&
+          properties?.published &&
+          properties?.description
+        );
+      });
+      assert.deepEqual(Object.keys(updateComponent.properties).sort(), [
+        'description',
+        'name',
+        'parentId',
+        'published',
+      ]);
+      assert.equal(
+        updateComponent.properties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.equal(
+        updateComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+
+      const viewJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryView);
+      const viewComponent = findComponent(viewJson, properties => {
+        return (
+          properties?.id && properties?.parentId && properties?.parent && properties?.published
+        );
+      });
+      assert.deepEqual(Object.keys(viewComponent.properties.parent.properties).sort(), [
+        'id',
+        'name',
+      ]);
+      assert.equal(viewComponent.properties.iid.rest.visible, false);
+      assert.equal(viewComponent.properties.deleted.rest.visible, false);
+      assert.equal(
+        viewComponent.properties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.equal(
+        viewComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+      const viewToolbar = getEntryForm(viewComponent);
+      assert.deepEqual(
+        viewToolbar.options.actions.map((action: any) => action.render),
+        ['basic-form:actionBack'],
+      );
+
+      const listJson = await app.bean.openapi.generateJsonOfClass(DtoCategorySelectResItem);
+      const listComponent = findComponent(listJson, properties => properties?._operationsRow);
+      const listProperties = listComponent.properties;
+      assert.deepEqual(Object.keys(listProperties.parent.properties).sort(), ['id', 'name']);
+      assert.equal(listProperties.parentId.rest.table.render, 'basic-resource:resourcePicker');
+      assert.deepEqual(listProperties.parentId.rest.table.columnProps, {
+        resource: 'commerce-catalog:category',
+        relationName: 'parent',
+      });
+      assert.equal(listProperties.published.rest.table.render, 'basic-select:select');
+      assert.deepEqual(
+        listProperties.published.rest.table.columnProps.items.map((item: any) => item.value),
+        [false, true],
+      );
+      assert.deepEqual(
+        listProperties._operationsRow.rest.table.columnProps.actions.map(
+          (action: any) => action.render,
+        ),
+        ['basic-table:actionUpdate', 'basic-table:actionDelete'],
+      );
+
+      const filterBlock = listComponent.rest.blocks[0].options.blocks[0];
+      const filterLayout = filterBlock.options.blocks[0].options.formLayout;
+      const section = filterLayout.children[0];
+      assert.equal(section.type, 'section');
+      assert.equal(section.layout, 'flow');
+      assert.deepEqual(
+        section.children.slice(0, 2).map((field: any) => field.name),
+        ['name', 'createdAt'],
+      );
+      assert.equal(section.children[2].block.render, 'basic-page:blockFilterActions');
+    });
+  });
+
+  it('action:category:parentProjection', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      let parentId: number | string | undefined;
+      let childId: number | string | undefined;
+      await app.bean.passport.signinMock();
+      try {
+        parentId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+          body: { name: `presentation-parent-${suffix}`, published: false },
+        });
+        childId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+          body: {
+            name: `presentation-child-${suffix}`,
+            parentId,
+            published: true,
+          },
+        });
+
+        const view: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/category/:id',
+          { params: { id: childId } },
+        );
+        assert.equal(String(view.parentId), String(parentId));
+        assert.deepEqual(view.parent, { id: parentId, name: `presentation-parent-${suffix}` });
+        assert.equal(view.published, true);
+
+        const select: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/category',
+        );
+        const root = select.list.find((item: any) => String(item.id) === String(parentId));
+        const child = select.list.find((item: any) => String(item.id) === String(childId));
+        assert.equal(root.parent, undefined);
+        assert.equal(root.published, false);
+        assert.equal(String(child.parentId), String(parentId));
+        assert.deepEqual(child.parent, { id: parentId, name: `presentation-parent-${suffix}` });
+        assert.equal(child.published, true);
+
+        await assert.rejects(
+          app.bean.executor.performAction('patch', '/commerce/catalog/category/:id', {
+            params: { id: childId },
+            body: {
+              name: `presentation-child-${suffix}`,
+              parentId: childId,
+              published: true,
+            },
+          }),
+        );
+      } finally {
+        if (childId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/category/:id', {
+            params: { id: childId },
+          });
+        }
+        if (parentId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/category/:id', {
+            params: { id: parentId },
+          });
+        }
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/refundResult.tsx

@@ -18,6 +18,9 @@ export class DtoRefundResult {
   @Api.field(v.optional(), v.tableIdentity())
   refundAttemptId?: TableIdentity;
 
+  @Api.field(v.optional(), v.tableIdentity())
+  refundOperationId?: TableIdentity;
+
   @Api.field(z.enum(['paid', 'refund_requested', 'refund_approved', 'refund_rejected', 'refunded']))
   orderState: 'paid' | 'refund_requested' | 'refund_approved' | 'refund_rejected' | 'refunded';
 

package/vona/src/suite/a-commerce/modules/commerce-trade/src/service/order.ts

@@ -1157,7 +1157,7 @@ export class ServiceOrder extends BeanBase {
   private _refundResult(
     order: Pick<EntityOrder, 'id' | 'state' | 'currency'>,
     refundRequest: Pick<EntityRefundRequest, 'id' | 'state' | 'amountCents'>,
-    refundAttempt?: Pick<EntityRefundAttempt, 'id' | 'state'>,
+    refundAttempt?: Pick<EntityRefundAttempt, 'id' | 'state' | 'refundOperationId'>,
   ): DtoRefundResult {
     if (
       order.state !== 'paid' &&
@@ -1172,6 +1172,7 @@ export class ServiceOrder extends BeanBase {
       orderId: order.id,
       refundRequestId: refundRequest.id,
       refundAttemptId: refundAttempt?.id,
+      refundOperationId: refundAttempt?.refundOperationId,
       orderState: order.state,
       refundState: refundRequest.state,
       refundAttemptState: refundAttempt?.state,

package/vona/src/suite/a-commerce/modules/commerce-trade/test/refundLifecycle.test.ts

@@ -16,6 +16,7 @@ interface IFixture {
   customerName?: string;
   orderId?: number;
   paymentAttemptId?: number;
+  paymentSessionId?: number;
 }
 
 async function cleanup(fixture: IFixture) {
@@ -24,6 +25,21 @@ async function cleanup(fixture: IFixture) {
   const promotion = app.scope('commerce-promotion');
   const catalog = app.scope('commerce-catalog');
   const member = app.scope('commerce-member');
+  const pay = app.scope('a-pay');
+  if (fixture.paymentSessionId !== undefined) {
+    const refundOperations = await pay.model.refundOperation.select({
+      where: { paymentSessionId: fixture.paymentSessionId },
+    });
+    for (const refundOperation of refundOperations) {
+      await pay.model.providerOperation.delete({ refundOperationId: refundOperation.id });
+      await pay.model.outboxEvent.delete({ refundOperationId: refundOperation.id });
+      await pay.model.webhookInbox.delete({ refundOperationId: refundOperation.id });
+      await pay.model.refundOperation.delete({ id: refundOperation.id });
+    }
+    await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.providerOperation.delete({ paymentSessionId: fixture.paymentSessionId });
+  }
   if (fixture.orderId !== undefined) {
     const requests = await payment.model.refundRequest.select({
       where: { orderId: fixture.orderId },
@@ -39,6 +55,8 @@ async function cleanup(fixture: IFixture) {
     await payment.model.paymentAudit.delete({ paymentAttemptId: fixture.paymentAttemptId });
     await payment.model.paymentAttempt.delete({ id: fixture.paymentAttemptId });
   }
+  if (fixture.paymentSessionId !== undefined)
+    await pay.model.paymentSession.delete({ id: fixture.paymentSessionId });
   if (fixture.orderId !== undefined)
     await trade.model.orderAudit.delete({ orderId: fixture.orderId });
   if (fixture.skuId !== undefined) await trade.model.stockAudit.delete({ skuId: fixture.skuId });
@@ -152,10 +170,17 @@ async function createPaidOrder(suffix: string): Promise<IFixture> {
   });
   fixture.orderId = checkout.orderId as number;
   fixture.paymentAttemptId = checkout.paymentAttemptId as number;
-  await app.scope('commerce-trade').service.order.applyPaymentOutcome(fixture.paymentAttemptId, {
-    outcome: 'succeeded',
-    idempotencyKey: `refund-payment-${suffix}`,
+  fixture.paymentSessionId = checkout.paymentSessionId as number;
+  const pay = app.scope('a-pay');
+  await pay.service.paymentSession.start(fixture.paymentSessionId);
+  await app
+    .scope('pay-mock')
+    .service.payMock.completePaymentSession(fixture.paymentSessionId, 'succeeded');
+  const outbox = await pay.model.outboxEvent.get({
+    paymentSessionId: fixture.paymentSessionId,
+    eventType: 'payment.outcome.v1',
   });
+  await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox!.id });
   return fixture;
 }
 
@@ -310,6 +335,89 @@ describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('settles an executed mock-provider refund through the durable outbox', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        const order = app.scope('commerce-trade').service.order;
+        await order.requestRefund(fixture.orderId!, {
+          reason: 'provider-backed refund',
+          idempotencyKey: 'provider-backed-request-1',
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock();
+        await order.approveRefund(fixture.orderId!, {
+          reason: 'provider-backed approval',
+          idempotencyKey: 'provider-backed-approve-1',
+        });
+        const executed = await order.executeRefund(fixture.orderId!);
+        assert.ok(executed.refundAttemptId);
+        assert.ok(executed.refundOperationId);
+        assert.deepEqual(
+          [executed.orderState, executed.refundState, executed.refundAttemptState],
+          ['refund_approved', 'approved', 'created'],
+        );
+        const pay = app.scope('a-pay');
+        const refundOperation = await pay.model.refundOperation.getById(executed.refundOperationId);
+        const refundAttempt = await app
+          .scope('commerce-payment')
+          .model.refundAttempt.getById(executed.refundAttemptId);
+        assert.equal(String(refundAttempt?.refundOperationId), String(executed.refundOperationId));
+        assert.equal(refundOperation?.state, 'pending');
+        const receipt = await app
+          .scope('pay-mock')
+          .service.payMock.completeRefundOperation(executed.refundOperationId, 'succeeded');
+        assert.deepEqual(receipt, {
+          refundOperationId: executed.refundOperationId,
+          accepted: true,
+        });
+        const outbox = await pay.model.outboxEvent.get({
+          refundOperationId: executed.refundOperationId,
+          eventType: 'refund.outcome.v1',
+        });
+        assert.ok(outbox);
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        const [
+          dispatched,
+          settledOrder,
+          settledRequest,
+          settledAttempt,
+          line,
+          balance,
+          grant,
+          audits,
+        ] = await Promise.all([
+          pay.model.outboxEvent.getById(outbox.id),
+          app.scope('commerce-trade').model.order.getById(fixture.orderId!),
+          app.scope('commerce-payment').model.refundRequest.getById(executed.refundRequestId),
+          app.scope('commerce-payment').model.refundAttempt.getById(executed.refundAttemptId),
+          app.scope('commerce-trade').model.orderLine.get({ orderId: fixture.orderId }),
+          app.scope('commerce-trade').model.stockBalance.getById(fixture.balanceId!),
+          app.scope('commerce-promotion').model.couponGrant.getById(fixture.grantId!),
+          app
+            .scope('commerce-payment')
+            .model.refundAudit.select({ where: { orderId: fixture.orderId } }),
+        ]);
+        const reservation = await app
+          .scope('commerce-trade')
+          .model.stockReservation.get({ orderLineId: line?.id });
+        assert.deepEqual([dispatched?.state, dispatched?.attemptCount], ['dispatched', 1]);
+        assert.deepEqual(
+          [settledOrder?.state, settledRequest?.state, settledAttempt?.state, reservation?.state],
+          ['refunded', 'refunded', 'succeeded', 'restored'],
+        );
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 0, 1]);
+        assert.equal(grant?.state, 'redeemed');
+        assert.equal(audits.filter(audit => audit.toRefundState === 'refunded').length, 1);
+      } finally {
+        await app.bean.passport.signout();
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('preserves rejected and failed cycles while permitting a fresh request', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};

package/vona/src/suite-vendor/a-vona/modules/a-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.47",
+  "version": "5.1.48",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.76",
+  "version": "5.1.77",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/zova/src/suite/a-commerce/modules/commerce-member/src/api/openapi/schemas.ts

@@ -165,10 +165,6 @@ export type ApiSchemaCommerceTradeDtoRefundReview =
   components['schemas']['commerce-trade.dto.refundReview'];
 export type ApiSchemaCommerceTradeDtoRefundReviewPartial =
   Partial<ApiSchemaCommerceTradeDtoRefundReview>;
-export type ApiSchemaCommerceTradeDtoRefundOutcomeCreate =
-  components['schemas']['commerce-trade.dto.refundOutcomeCreate'];
-export type ApiSchemaCommerceTradeDtoRefundOutcomeCreatePartial =
-  Partial<ApiSchemaCommerceTradeDtoRefundOutcomeCreate>;
 export type ApiSchemaCommerceTradeDtoShipmentView =
   components['schemas']['commerce-trade.dto.shipmentView'];
 export type ApiSchemaCommerceTradeDtoShipmentViewPartial =
@@ -461,6 +457,14 @@ export type ApiSchemaPayMockDtoMockPaymentComplete =
   components['schemas']['pay-mock.dto.mockPaymentComplete'];
 export type ApiSchemaPayMockDtoMockPaymentCompletePartial =
   Partial<ApiSchemaPayMockDtoMockPaymentComplete>;
+export type ApiSchemaPayMockDtoMockRefundReceipt =
+  components['schemas']['pay-mock.dto.mockRefundReceipt'];
+export type ApiSchemaPayMockDtoMockRefundReceiptPartial =
+  Partial<ApiSchemaPayMockDtoMockRefundReceipt>;
+export type ApiSchemaPayMockDtoMockRefundComplete =
+  components['schemas']['pay-mock.dto.mockRefundComplete'];
+export type ApiSchemaPayMockDtoMockRefundCompletePartial =
+  Partial<ApiSchemaPayMockDtoMockRefundComplete>;
 export type ApiSchemaAPaypalEntityPaypalRecord =
   components['schemas']['a-paypal.entity.paypalRecord'];
 export type ApiSchemaAPaypalEntityPaypalRecordPartial = Partial<ApiSchemaAPaypalEntityPaypalRecord>;

package/zova/src/suite/a-commerce/modules/commerce-member/src/api/openapi/types.ts

@@ -623,7 +623,7 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
-  '/api/commerce/trade/order/{id}/refundOutcome': {
+  '/api/commerce/trade/order/{id}/executeRefund': {
     parameters: {
       query?: never;
       header?: never;
@@ -632,7 +632,7 @@ export interface paths {
     };
     get?: never;
     put?: never;
-    post: operations['CommerceTradeOrder_refundOutcome'];
+    post: operations['CommerceTradeOrder_executeRefund'];
     delete?: never;
     options?: never;
     head?: never;
@@ -1264,6 +1264,22 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
+  '/api/pay/mock/payment-session/refund-operation/{id}/complete': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    post: operations['PayMockPayment_completeRefund'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   '/api/paypal/getRecord/{recordId}': {
     parameters: {
       query?: never;
@@ -2446,9 +2462,9 @@ export interface components {
        * @enum {string}
        */
       currency: 'USD';
-      /** @description Fixed Discount (Cents) */
+      /** @description Fixed Discount */
       discountCents: number;
-      /** @description Minimum Spend (Cents) */
+      /** @description Minimum Spend */
       minSpendCents: number;
       /**
        * Format: date-time
@@ -2511,9 +2527,9 @@ export interface components {
        * @enum {string}
        */
       currency: 'USD';
-      /** @description Fixed Discount (Cents) */
+      /** @description Fixed Discount */
       discountCents: number;
-      /** @description Minimum Spend (Cents) */
+      /** @description Minimum Spend */
       minSpendCents: number;
       /**
        * Format: date-time
@@ -2576,9 +2592,9 @@ export interface components {
            * @enum {string}
            */
           currency: 'USD';
-          /** @description Fixed Discount (Cents) */
+          /** @description Fixed Discount */
           discountCents: number;
-          /** @description Minimum Spend (Cents) */
+          /** @description Minimum Spend */
           minSpendCents: number;
           /**
            * Format: date-time
@@ -2761,6 +2777,7 @@ export interface components {
       orderId: number | string;
       refundRequestId: number | string;
       refundAttemptId?: number | string | undefined;
+      refundOperationId?: number | string | undefined;
       /** @enum {string} */
       orderState: 'paid' | 'refund_requested' | 'refund_approved' | 'refund_rejected' | 'refunded';
       /** @enum {string} */
@@ -2779,11 +2796,6 @@ export interface components {
       reason: string;
       idempotencyKey: string;
     };
-    'commerce-trade.dto.refundOutcomeCreate': {
-      /** @enum {string} */
-      outcome: 'succeeded' | 'failed';
-      idempotencyKey: string;
-    };
     'commerce-trade.dto.shipmentView': {
       /** @description ID */
       id: number | string;
@@ -4483,6 +4495,14 @@ export interface components {
       /** @enum {string} */
       outcome: 'succeeded' | 'failed' | 'cancelled';
     };
+    'pay-mock.dto.mockRefundReceipt': {
+      refundOperationId: number | string;
+      accepted: boolean;
+    };
+    'pay-mock.dto.mockRefundComplete': {
+      /** @enum {string} */
+      outcome: 'succeeded' | 'failed' | 'cancelled';
+    };
     'a-paypal.entity.paypalRecord': {
       /**
        * Format: date-time
@@ -6273,7 +6293,7 @@ export interface operations {
     };
     authToken: true;
   };
-  CommerceTradeOrder_refundOutcome: {
+  CommerceTradeOrder_executeRefund: {
     parameters: {
       query?: never;
       header?: never;
@@ -6282,11 +6302,7 @@ export interface operations {
       };
       cookie?: never;
     };
-    requestBody: {
-      content: {
-        'application/json': components['schemas']['commerce-trade.dto.refundOutcomeCreate'];
-      };
-    };
+    requestBody?: never;
     responses: {
       200: {
         headers: {
@@ -7854,6 +7870,36 @@ export interface operations {
     };
     authToken: true;
   };
+  PayMockPayment_completeRefund: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        id: number | string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': components['schemas']['pay-mock.dto.mockRefundComplete'];
+      };
+    };
+    responses: {
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            code: string;
+            message: string;
+            data: components['schemas']['pay-mock.dto.mockRefundReceipt'];
+          };
+        };
+      };
+    };
+    authToken: true;
+  };
   Paypal_getRecord: {
     parameters: {
       query?: never;

package/zova/src/suite/a-commerce/modules/commerce-trade/src/api/openapi/types.ts

@@ -2462,9 +2462,9 @@ export interface components {
        * @enum {string}
        */
       currency: 'USD';
-      /** @description Fixed Discount (Cents) */
+      /** @description Fixed Discount */
       discountCents: number;
-      /** @description Minimum Spend (Cents) */
+      /** @description Minimum Spend */
       minSpendCents: number;
       /**
        * Format: date-time
@@ -2527,9 +2527,9 @@ export interface components {
        * @enum {string}
        */
       currency: 'USD';
-      /** @description Fixed Discount (Cents) */
+      /** @description Fixed Discount */
       discountCents: number;
-      /** @description Minimum Spend (Cents) */
+      /** @description Minimum Spend */
       minSpendCents: number;
       /**
        * Format: date-time
@@ -2592,9 +2592,9 @@ export interface components {
            * @enum {string}
            */
           currency: 'USD';
-          /** @description Fixed Discount (Cents) */
+          /** @description Fixed Discount */
           discountCents: number;
-          /** @description Minimum Spend (Cents) */
+          /** @description Minimum Spend */
           minSpendCents: number;
           /**
            * Format: date-time
@@ -2777,6 +2777,7 @@ export interface components {
       orderId: number | string;
       refundRequestId: number | string;
       refundAttemptId?: number | string | undefined;
+      refundOperationId?: number | string | undefined;
       /** @enum {string} */
       orderState: 'paid' | 'refund_requested' | 'refund_approved' | 'refund_rejected' | 'refunded';
       /** @enum {string} */

package/zova/src/suite/cabloy-basic/modules/basic-select/src/bean/tableCell.select.tsx

@@ -26,13 +26,19 @@ export class TableCellSelect extends BeanBase implements ITableCellRender {
   render(
     options: ITableCellOptionsSelect,
     _renderContext: IJsxRenderContextTableCell,
-    next: NextTableCellRender,
+    _next: NextTableCellRender,
   ) {
-    const value = next();
-    const item = options.items?.find(
-      item => String(item[String(options.itemValue)]) === String(value),
-    );
-    const value2 = item?.[String(options.itemTitle)];
+    const value = _next();
+    const items = options.items;
+    const itemValue = options.itemValue;
+    const itemTitle = options.itemTitle;
+    const item = items?.find(item => {
+      const itemValue2 = item[String(itemValue)];
+      if (String(itemValue2) === String(value)) return true;
+      if (typeof itemValue2 !== 'boolean') return false;
+      return itemValue2 ? value === 1 || value === '1' : value === 0 || value === '0';
+    });
+    const value2 = item?.[String(itemTitle)];
     if (!options.class) return value2;
     return <div class={options.class}>{value2}</div>;
   }