cabloy 5.1.131 → 5.1.133

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

@@ -0,0 +1,358 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
+import { DtoOrderSelectResItem, DtoOrderView } from 'vona-module-commerce-trade';
+
+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 getEntryToolbar(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;
+}
+
+function getListFilter(component: any) {
+  const page = component?.rest?.blocks?.[0];
+  const [filter, table, pager] = page?.options?.blocks ?? [];
+  assert.equal(page?.render, 'basic-page:blockPage');
+  assert.equal(filter?.render, 'basic-page:blockFilter');
+  assert.equal(table?.render, 'basic-page:blockTable');
+  assert.equal(pager?.render, 'basic-page:blockPager');
+  return filter;
+}
+
+function assertCurrencyRenderer(field: any) {
+  const options = { fixed: 2, exp: 2, zero: 2 };
+  assert.equal(field.rest.form.render, 'basic-currency:formFieldCurrency');
+  assert.deepEqual(field.rest.form.options, options);
+  assert.equal(field.rest.table.render, 'basic-currency:currency');
+  assert.deepEqual(field.rest.table.columnProps, options);
+}
+
+interface IFixture {
+  orderId?: number;
+  userId?: number;
+}
+
+async function cleanup(fixture: IFixture) {
+  const trade = app.scope('commerce-trade');
+  if (fixture.orderId !== undefined) {
+    await trade.model.shipment.delete({ orderId: fixture.orderId });
+    const lines = await trade.model.orderLine.select({ where: { orderId: fixture.orderId } });
+    for (const line of lines) {
+      await trade.model.stockReservation.delete({ orderLineId: line.id });
+    }
+    await trade.model.orderLine.delete({ orderId: fixture.orderId });
+    await trade.model.order.delete({ id: fixture.orderId });
+  }
+  if (fixture.userId !== undefined) {
+    await app.scope('home-user').model.roleUser.delete({ userId: fixture.userId });
+    await app.bean.user.removeById(fixture.userId);
+  }
+}
+
+describe('orderPresentation.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-commerce');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
+  it('action:order:presentationMetadata', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const currencyOptions = { fixed: 2, exp: 2, zero: 2 };
+      const viewJson = await app.bean.openapi.generateJsonOfClass(DtoOrderView);
+      const viewComponent = findComponent(viewJson, properties => {
+        return properties?.lines && properties?.addressSnapshot && properties?.shipment;
+      });
+      assert.deepEqual(Object.keys(viewComponent.properties).sort(), [
+        '_lines',
+        'addressSnapshot',
+        'couponSnapshot',
+        'createdAt',
+        'currency',
+        'discountCents',
+        'eligibleSubtotalCents',
+        'id',
+        'lines',
+        'payableTotalCents',
+        'reservationExpiresAt',
+        'shipment',
+        'state',
+        'updatedAt',
+      ]);
+      for (const field of ['iid', 'deleted', 'userId', 'addressId', 'correlationId', 'refund']) {
+        assert.equal(viewComponent.properties[field], undefined);
+      }
+      assert.equal(
+        viewComponent.properties.lines.rest.form.render,
+        'basic-details:formFieldDetails',
+      );
+      assert.equal(viewComponent.properties._lines.rest.visible, false);
+      assert.equal(viewComponent.properties.state.rest.form.render, 'basic-select:formFieldSelect');
+      assert.equal(viewComponent.properties.state.rest.table.render, 'basic-select:select');
+      assert.deepEqual(
+        viewComponent.properties.state.rest.form.options.items.map((item: any) => item.value),
+        [
+          'awaiting_payment',
+          'paid',
+          'refund_requested',
+          'refund_approved',
+          'refund_rejected',
+          'shipped',
+          'refunded',
+          'cancelled',
+          'expired',
+        ],
+      );
+      for (const field of ['eligibleSubtotalCents', 'discountCents', 'payableTotalCents']) {
+        assertCurrencyRenderer(viewComponent.properties[field]);
+      }
+      assert.equal(
+        viewComponent.properties.reservationExpiresAt.rest.form.render,
+        'basic-date:formFieldDate',
+      );
+      assert.equal(
+        viewComponent.properties.reservationExpiresAt.rest.table.render,
+        'basic-date:date',
+      );
+      assert.equal(viewComponent.properties.createdAt.rest.form.render, 'basic-date:formFieldDate');
+      assert.equal(viewComponent.properties.updatedAt.rest.table.render, 'basic-date:date');
+      assert.deepEqual(
+        getEntryToolbar(viewComponent).options.actions.map((action: any) => action.render),
+        ['basic-form:actionBack'],
+      );
+
+      const lineComponent = findComponent(viewJson, properties => {
+        return (
+          properties?.skuCodeSnapshot &&
+          properties?.eligibleSubtotalCents &&
+          properties?.lineTotalCents
+        );
+      });
+      assert.deepEqual(Object.keys(lineComponent.properties).sort(), [
+        'eligibleSubtotalCents',
+        'id',
+        'lineTotalCents',
+        'quantity',
+        'skuAttributesSnapshot',
+        'skuCodeSnapshot',
+        'titleSnapshot',
+        'unitPriceCents',
+      ]);
+      for (const field of ['orderId', 'skuId', 'productId', 'sku', 'product', '_operationsRow']) {
+        assert.equal(lineComponent.properties[field], undefined);
+      }
+      assert.equal(lineComponent.properties.id.rest.visible, false);
+      assertCurrencyRenderer(lineComponent.properties.unitPriceCents);
+      assertCurrencyRenderer(lineComponent.properties.eligibleSubtotalCents);
+      assertCurrencyRenderer(lineComponent.properties.lineTotalCents);
+      assert.equal(lineComponent.rest.blocks[0].render, 'basic-details:blockDetails');
+      assert.deepEqual(
+        lineComponent.rest.blocks[0].options.blocks.map((block: any) => block.render),
+        ['basic-details:blockTable'],
+      );
+
+      const listJson = await app.bean.openapi.generateJsonOfClass(DtoOrderSelectResItem);
+      const listComponent = findComponent(listJson, properties => properties?._operationsRow);
+      assert.deepEqual(Object.keys(listComponent.properties).sort(), [
+        '_operationsRow',
+        'createdAt',
+        'id',
+        'payableTotalCents',
+        'reservationExpiresAt',
+        'state',
+      ]);
+      for (const field of [
+        'iid',
+        'deleted',
+        'userId',
+        'addressId',
+        'correlationId',
+        'addressSnapshot',
+        'couponSnapshot',
+        'lines',
+        'shipment',
+      ]) {
+        assert.equal(listComponent.properties[field], undefined);
+      }
+      assert.equal(listComponent.properties.id.rest.table.render, 'basic-table:actionView');
+      assert.equal(listComponent.properties.state.rest.table.render, 'basic-select:select');
+      assert.deepEqual(
+        listComponent.properties.state.rest.table.columnProps.items.map((item: any) => item.value),
+        viewComponent.properties.state.rest.form.options.items.map((item: any) => item.value),
+      );
+      assert.equal(
+        listComponent.properties.payableTotalCents.rest.table.render,
+        'basic-currency:currency',
+      );
+      assert.deepEqual(
+        listComponent.properties.payableTotalCents.rest.table.columnProps,
+        currencyOptions,
+      );
+      assert.equal(
+        listComponent.properties.reservationExpiresAt.rest.table.render,
+        'basic-date:date',
+      );
+      assert.equal(listComponent.properties.createdAt.rest.table.render, 'basic-date:date');
+      assert.deepEqual(
+        listComponent.properties._operationsRow.rest.table.columnProps.actions.map(
+          (action: any) => action.render,
+        ),
+        ['commerce-trade:actionShip', 'commerce-trade:actionRefund', 'basic-table:actionView'],
+      );
+      const filter = getListFilter(listComponent);
+      const section = filter.options.blocks[0].options.formLayout.children[0];
+      assert.equal(section.type, 'section');
+      assert.equal(section.layout, 'flow');
+      assert.deepEqual(
+        section.children.slice(0, 2).map((field: any) => field.name),
+        ['state', 'createdAt'],
+      );
+      assert.equal(section.children[2].block.render, 'basic-page:blockFilterActions');
+    });
+  });
+
+  it('action:order:runtimeBoundary', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      const suffix = randomUUID().slice(0, 12);
+      const trade = app.scope('commerce-trade');
+      try {
+        const user = await app.bean.user.register({ name: `order-presentation-${suffix}` }, true);
+        fixture.userId = user.id as number;
+        const order = await trade.model.order.insert({
+          userId: fixture.userId,
+          addressId: 1,
+          correlationId: `order-presentation-${suffix}`,
+          addressSnapshot: {
+            recipientName: 'Order Presentation',
+            phone: '15555550123',
+            countryCode: 'US',
+            region: 'California',
+            city: 'San Francisco',
+            postalCode: '94105',
+            addressLine1: '1 Market Street',
+          },
+          couponSnapshot: {
+            couponGrantId: 1,
+            couponTemplateId: 1,
+            couponCode: `ORDER-${suffix}`,
+            templateName: 'Order Presentation Coupon',
+            currency: 'USD',
+            fixedDiscountCents: 100,
+            minSpendCents: 1,
+            appliedDiscountCents: 100,
+          },
+          state: 'paid',
+          currency: 'USD',
+          eligibleSubtotalCents: 2_000,
+          discountCents: 100,
+          payableTotalCents: 1_900,
+          reservationExpiresAt: new Date(Date.now() + 60_000),
+        });
+        fixture.orderId = order.id as number;
+        await trade.model.orderLine.insert({
+          orderId: fixture.orderId,
+          skuId: 1,
+          productId: 1,
+          skuCodeSnapshot: `order-presentation-sku-${suffix}`,
+          titleSnapshot: 'Order Presentation Product',
+          skuAttributesSnapshot: [{ name: 'Color', value: 'Black' }],
+          unitPriceCents: 1_000,
+          quantity: 2,
+          eligibleSubtotalCents: 2_000,
+          lineTotalCents: 1_900,
+        });
+        await trade.model.shipment.insert({
+          orderId: fixture.orderId,
+          carrier: 'Cabloy Express',
+          trackingNumber: `CAB-${suffix}`,
+          operatorId: fixture.userId,
+          shippedAt: new Date(),
+          correlationId: `order-presentation-shipment-${suffix}`,
+        });
+
+        await app.bean.passport.signinMock();
+        const view: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/trade/order/:id',
+          { params: { id: fixture.orderId }, innerAccess: false },
+        );
+        assert.deepEqual(Object.keys(view).sort(), [
+          'addressSnapshot',
+          'couponSnapshot',
+          'createdAt',
+          'currency',
+          'discountCents',
+          'eligibleSubtotalCents',
+          'id',
+          'lines',
+          'payableTotalCents',
+          'reservationExpiresAt',
+          'shipment',
+          'state',
+          'updatedAt',
+        ]);
+        for (const field of ['iid', 'deleted', 'userId', 'addressId', 'correlationId', 'refund']) {
+          assert.equal(view[field], undefined);
+        }
+        assert.equal(view.addressSnapshot.city, 'San Francisco');
+        assert.equal(view.couponSnapshot.couponCode, `ORDER-${suffix}`);
+        assert.deepEqual(view.shipment, {
+          id: view.shipment.id,
+          carrier: 'Cabloy Express',
+          trackingNumber: `CAB-${suffix}`,
+          shippedAt: view.shipment.shippedAt,
+        });
+        assert.deepEqual(view.lines, [
+          {
+            id: view.lines[0].id,
+            skuCodeSnapshot: `order-presentation-sku-${suffix}`,
+            titleSnapshot: 'Order Presentation Product',
+            skuAttributesSnapshot: [{ name: 'Color', value: 'Black' }],
+            unitPriceCents: 1_000,
+            quantity: 2,
+            eligibleSubtotalCents: 2_000,
+            lineTotalCents: 1_900,
+          },
+        ]);
+        for (const field of ['orderId', 'skuId', 'productId', 'sku', 'product']) {
+          assert.equal(view.lines[0][field], undefined);
+        }
+
+        const select: any = await app.bean.executor.performAction('get', '/commerce/trade/order', {
+          query: { state: 'paid' },
+          innerAccess: false,
+        });
+        const row = select.list.find((item: any) => String(item.id) === String(fixture.orderId));
+        assert.ok(row);
+        assert.deepEqual(Object.keys(row).sort(), [
+          'createdAt',
+          'id',
+          'payableTotalCents',
+          'reservationExpiresAt',
+          'state',
+        ]);
+        assert.equal(row.state, 'paid');
+        assert.equal(row.payableTotalCents, 1_900);
+      } finally {
+        await cleanup(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

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

@@ -110,15 +110,15 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
             },
           },
         );
-        fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
-          body: {
+        fixture.skuId = (
+          await app.scope('commerce-catalog').model.sku.insert({
             productId: fixture.productId,
             code: `snapshot-sku-${suffix}`,
             priceCents: 1299,
             attributes: [{ name: 'Color', value: 'Black' }],
             lifecycle: 'active',
-          },
-        });
+          })
+        ).id as number;
         await app.scope('commerce-trade').service.stockBalance.adjustStock({
           skuId: fixture.skuId,
           delta: 2,
@@ -272,15 +272,15 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
             body: { categoryId: fixture.categoryId, title: original.productTitle, published: true },
           },
         );
-        fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
-          body: {
+        fixture.skuId = (
+          await app.scope('commerce-catalog').model.sku.insert({
             productId: fixture.productId,
             code: original.skuCode,
             priceCents: 1299,
             attributes: original.attributes,
             lifecycle: 'active',
-          },
-        });
+          })
+        ).id as number;
         await app.scope('commerce-trade').service.stockBalance.adjustStock({
           skuId: fixture.skuId,
           delta: 1,

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

@@ -189,8 +189,12 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
       try {
         Object.assign(fixture, await createCheckoutFixture(randomUUID().slice(0, 12)));
         const eventId = `provider-${randomUUID().slice(0, 12)}`;
+        const paymentSession = await app
+          .scope('a-pay')
+          .model.paymentSession.getById(fixture.paymentSessionId!);
+        assert.ok(paymentSession);
         const rawBody = JSON.stringify({
-          paymentSessionId: String(fixture.paymentSessionId),
+          providerCorrelationReference: paymentSession.providerCorrelationReference,
           currency: 'USD',
           amountMinor: 799,
           eventType: 'payment.succeeded',

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

@@ -31,9 +31,18 @@ async function cleanup(fixture: IFixture) {
       where: { paymentSessionId: fixture.paymentSessionId },
     });
     for (const refundOperation of refundOperations) {
-      await pay.model.providerOperation.delete({ refundOperationId: refundOperation.id });
+      const providerOperation = await pay.model.providerOperation.get({
+        refundOperationId: refundOperation.id,
+        kind: 'refund',
+      });
+      if (providerOperation) {
+        await pay.model.providerOperationRecoveryAudit.delete({
+          providerOperationId: providerOperation.id,
+        });
+      }
       await pay.model.outboxEvent.delete({ refundOperationId: refundOperation.id });
       await pay.model.webhookInbox.delete({ refundOperationId: refundOperation.id });
+      await pay.model.providerOperation.delete({ refundOperationId: refundOperation.id });
       await pay.model.refundOperation.delete({ id: refundOperation.id });
     }
     await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
@@ -335,6 +344,46 @@ describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('requires recovery instead of creating a second refund operation', 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 recovery',
+          idempotencyKey: 'provider-recovery-request-1',
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock();
+        await order.approveRefund(fixture.orderId!, {
+          reason: 'provider recovery approved',
+          idempotencyKey: 'provider-recovery-approve-1',
+        });
+        const executed = await order.executeRefund(fixture.orderId!);
+        await assert.rejects(order.executeRefund(fixture.orderId!), { status: 409 });
+        const pay = app.scope('a-pay');
+        const refundOperation = await pay.model.refundOperation.getById(executed.refundOperationId);
+        const providerOperation = await pay.model.providerOperation.get({
+          refundOperationId: refundOperation?.id,
+          kind: 'refund',
+        });
+        assert.ok(providerOperation);
+        assert.equal(
+          (
+            await pay.model.refundOperation.select({
+              where: { paymentSessionId: fixture.paymentSessionId },
+            })
+          ).length,
+          1,
+        );
+      } finally {
+        await app.bean.passport.signout();
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('settles an executed mock-provider refund through the durable outbox', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};