cabloy 5.1.122 → 5.1.124

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

@@ -159,6 +159,77 @@ async function createPaidOrder(suffix: string): Promise<IFixture> {
   return fixture;
 }
 
+async function runInMockCtx<TResult>(
+  customerName: string | undefined,
+  operation: () => Promise<TResult>,
+): Promise<TResult> {
+  return await app.bean.executor.mockCtx(async () => {
+    if (customerName === undefined) {
+      await app.bean.passport.signinMock();
+    } else {
+      await app.bean.passport.signinMock(customerName as any);
+    }
+    try {
+      return await operation();
+    } finally {
+      await app.bean.passport.signout();
+    }
+  });
+}
+
+async function withTimeout<TResult>(promise: Promise<TResult>, message: string): Promise<TResult> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(message)), 5_000);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+async function waitForHolderStage(
+  entered: Promise<void>,
+  holder: Promise<unknown>,
+  label: string,
+): Promise<void> {
+  return await withTimeout(
+    Promise.race([
+      entered,
+      holder.then(
+        () =>
+          Promise.reject(new Error(`${label} completed before reaching its lock-holding stage`)),
+        error => Promise.reject(error),
+      ),
+    ]),
+    `${label} did not reach its lock-holding stage`,
+  );
+}
+
+async function waitForPostgresWaiter(waiterPid: number, holderPid: number): Promise<void> {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    const result = await app.bean.database.current.connection.raw(
+      `
+        select wait_event_type
+          from pg_stat_activity
+         where pid = ?
+           and ? = any(pg_blocking_pids(pid))
+      `,
+      [waiterPid, holderPid],
+    );
+    if (result.rows[0]) {
+      assert.equal(result.rows[0].wait_event_type, 'Lock');
+      return;
+    }
+    await new Promise(resolve => setTimeout(resolve, 10));
+  }
+  assert.fail(`PostgreSQL backend ${waiterPid} was not blocked by backend ${holderPid}`);
+}
+
 describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, () => {
   let releaseTestLock: (() => void) | undefined;
 
@@ -295,6 +366,247 @@ describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('accepts one concurrent PostgreSQL refund success without duplicate effects', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+    const fixture: IFixture = {};
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        await app.bean.passport.signout();
+      });
+      await runInMockCtx(fixture.customerName, async () => {
+        await app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+          reason: 'concurrent outcome request',
+          idempotencyKey: 'concurrent-outcome-request-1',
+        });
+      });
+      await runInMockCtx(undefined, async () => {
+        await app.scope('commerce-trade').service.order.approveRefund(fixture.orderId!, {
+          reason: 'concurrent outcome approval',
+          idempotencyKey: 'concurrent-outcome-approval-1',
+        });
+      });
+
+      const entered = Promise.withResolvers<void>();
+      const release = Promise.withResolvers<void>();
+      let holderPid: number | undefined;
+      const holder = runInMockCtx(undefined, async () => {
+        return await app
+          .scope('commerce-trade')
+          .service.order.applyRefundOutcomeForTest(
+            fixture.orderId!,
+            { outcome: 'succeeded', idempotencyKey: 'concurrent-outcome-success-1' },
+            async stage => {
+              if (stage !== 'afterRefundAttemptState') return;
+              const result = await app.bean.database.current.connection.raw(
+                'select pg_backend_pid() as pid',
+              );
+              holderPid = result.rows[0].pid;
+              entered.resolve();
+              await release.promise;
+            },
+          );
+      });
+      const waiterReady = Promise.withResolvers<void>();
+      const releaseWaiter = Promise.withResolvers<void>();
+      let waiterPid: number | undefined;
+      let waiter: Promise<unknown> | undefined;
+      let results: PromiseSettledResult<unknown>[] | undefined;
+      try {
+        await waitForHolderStage(entered.promise, holder, 'refund success holder');
+        assert.notEqual(holderPid, undefined);
+        waiter = runInMockCtx(undefined, async () => {
+          return await app
+            .scope('commerce-trade')
+            .service.order.applyRefundOutcomeForTest(
+              fixture.orderId!,
+              { outcome: 'succeeded', idempotencyKey: 'concurrent-outcome-success-1' },
+              async stage => {
+                if (stage !== 'beforeRefundOutcomeOrderLock') return;
+                const result = await app.bean.database.current.connection.raw(
+                  'select pg_backend_pid() as pid',
+                );
+                waiterPid = result.rows[0].pid;
+                waiterReady.resolve();
+                await releaseWaiter.promise;
+              },
+            );
+        });
+        await waitForHolderStage(waiterReady.promise, waiter, 'refund success waiter');
+        assert.notEqual(waiterPid, undefined);
+        releaseWaiter.resolve();
+        await app.bean.executor.mockCtx(async () => {
+          await waitForPostgresWaiter(waiterPid!, holderPid!);
+        });
+      } finally {
+        releaseWaiter.resolve();
+        release.resolve();
+        results = await Promise.allSettled([holder, waiter].filter(Boolean));
+      }
+      assert.equal(
+        results!.filter(result => result.status === 'fulfilled').length,
+        2,
+        JSON.stringify(results),
+      );
+      const [first, second] = results!;
+      if (first.status !== 'fulfilled' || second.status !== 'fulfilled') return;
+      assert.deepEqual(second.value, first.value);
+      await app.bean.executor.mockCtx(async () => {
+        const trade = app.scope('commerce-trade');
+        const payment = app.scope('commerce-payment');
+        const line = await trade.model.orderLine.get({ orderId: fixture.orderId });
+        const reservation = await trade.model.stockReservation.get({ orderLineId: line?.id });
+        const balance = await trade.model.stockBalance.getById(fixture.balanceId!);
+        const grant = await app
+          .scope('commerce-promotion')
+          .model.couponGrant.getById(fixture.grantId!);
+        const requests = await payment.model.refundRequest.select({
+          where: { orderId: fixture.orderId },
+        });
+        const attempts = await payment.model.refundAttempt.select({
+          where: { refundRequestId: requests[0]?.id },
+        });
+        const refundAudits = await payment.model.refundAudit.select({
+          where: { orderId: fixture.orderId },
+        });
+        const orderAudits = await trade.model.orderAudit.select({
+          where: { orderId: fixture.orderId },
+        });
+        const stockAudits = await trade.model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.deepEqual(
+          [requests.length, requests[0]?.state, attempts.length, attempts[0]?.state],
+          [1, 'refunded', 1, 'succeeded'],
+        );
+        assert.equal(reservation?.state, 'restored');
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 0, 1]);
+        assert.equal(grant?.state, 'redeemed');
+        assert.equal(refundAudits.filter(audit => audit.toRefundState === 'refunded').length, 1);
+        assert.equal(orderAudits.filter(audit => audit.operation === 'refunded').length, 1);
+        assert.equal(stockAudits.filter(audit => audit.operation === 'restore').length, 1);
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await cleanup(fixture);
+      });
+    }
+  });
+
+  it('treats foreign customers and instances as absent without creating refund effects', async () => {
+    const fixture: IFixture = {};
+    let foreignUserId: number | undefined;
+    let foreignInstanceUserId: number | undefined;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        const foreignName = `refund-foreign-${randomUUID().slice(0, 12)}`;
+        const foreign = await app.bean.user.register({ name: foreignName }, true);
+        foreignUserId = foreign.id as number;
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock(foreignName as any);
+        try {
+          assert.equal(
+            await app.scope('commerce-trade').service.order.viewMine(fixture.orderId!),
+            undefined,
+          );
+          await assert.rejects(
+            app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+              reason: 'foreign customer',
+              idempotencyKey: 'foreign-customer-refund-1',
+            }),
+            (error: any) => error.code === 404,
+          );
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+      await app.bean.executor.mockCtx(
+        async () => {
+          const foreignName = `refund-instance-${randomUUID().slice(0, 12)}`;
+          const foreign = await app.bean.user.register({ name: foreignName }, true);
+          foreignInstanceUserId = foreign.id as number;
+          await app.bean.passport.signinMock(foreignName as any);
+          try {
+            assert.equal(
+              await app.scope('commerce-trade').service.order.viewMine(fixture.orderId!),
+              undefined,
+            );
+            await assert.rejects(
+              app.scope('commerce-trade').service.order.requestRefund(fixture.orderId!, {
+                reason: 'foreign instance request',
+                idempotencyKey: 'foreign-instance-refund-request-1',
+              }),
+              (error: any) => error.code === 404,
+            );
+            await app.bean.passport.signout();
+            await app.bean.passport.signinMock();
+            for (const operation of [
+              () =>
+                app.scope('commerce-trade').service.order.approveRefund(fixture.orderId!, {
+                  reason: 'foreign instance approval',
+                  idempotencyKey: 'foreign-instance-refund-approval-1',
+                }),
+              () =>
+                app.scope('commerce-trade').service.order.applyRefundOutcome(fixture.orderId!, {
+                  outcome: 'succeeded',
+                  idempotencyKey: 'foreign-instance-refund-outcome-1',
+                }),
+            ]) {
+              await assert.rejects(operation(), (error: any) => error.code === 404);
+            }
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+      await app.bean.executor.mockCtx(async () => {
+        const order = await app.scope('commerce-trade').model.order.getById(fixture.orderId!);
+        const requests = await app.scope('commerce-payment').model.refundRequest.select({
+          where: { orderId: fixture.orderId },
+        });
+        const line = await app
+          .scope('commerce-trade')
+          .model.orderLine.get({ orderId: fixture.orderId });
+        const reservation = await app.scope('commerce-trade').model.stockReservation.get({
+          orderLineId: line?.id,
+        });
+        const balance = await app
+          .scope('commerce-trade')
+          .model.stockBalance.getById(fixture.balanceId!);
+        const grant = await app
+          .scope('commerce-promotion')
+          .model.couponGrant.getById(fixture.grantId!);
+        assert.equal(order?.state, 'paid');
+        assert.equal(requests.length, 0);
+        assert.equal(reservation?.state, 'consumed');
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [0, 0, 0]);
+        assert.equal(grant?.state, 'redeemed');
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        if (foreignUserId !== undefined) {
+          await app.scope('home-user').model.roleUser.delete({ userId: foreignUserId });
+          await app.bean.user.removeById(foreignUserId);
+        }
+        await cleanup(fixture);
+      });
+      await app.bean.executor.mockCtx(
+        async () => {
+          if (foreignInstanceUserId !== undefined) {
+            await app.scope('home-user').model.roleUser.delete({ userId: foreignInstanceUserId });
+            await app.bean.user.removeById(foreignInstanceUserId);
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+    }
+  });
+
   it('denies anonymous and non-admin refund actions', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};

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

@@ -0,0 +1,76 @@
+{
+  "name": "vona-module-a-pay",
+  "version": "5.0.1",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src",
+    "cli"
+  ],
+  "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": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "a-pay",
+  "vonaModule": {
+    "fileVersion": 1,
+    "dependencies": {
+      "a-core": "5.0.0",
+      "a-index": "5.0.0",
+      "a-orm": "5.0.0",
+      "a-ormutils": "5.0.0",
+      "a-queue": "5.0.0",
+      "a-redlock": "5.0.0",
+      "a-schedule": "5.0.0",
+      "a-user": "5.0.0",
+      "a-vona": "5.0.0",
+      "a-web": "5.0.0"
+    },
+    "onions": {
+      "payProvider": {
+        "optionsGlobalInterfaceName": "IDecoratorPayProviderOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-pay",
+        "scopeResource": true,
+        "boilerplate": "payProvider/boilerplate"
+      },
+      "payScene": {
+        "optionsGlobalInterfaceName": "IDecoratorPaySceneOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-pay",
+        "boilerplate": "payScene/boilerplate"
+      }
+    }
+  }
+}