cabloy 5.1.194 → 5.1.196

package/vona/src/suite/a-commerce/modules/commerce-payment/src/bean/meta.index.ts

@@ -6,26 +6,27 @@ import { $tableColumns } from 'vona-module-a-ormutils';
 
 @Meta<IMetaOptionsIndex>({
   indexes: {
-    ...$tableColumns('commercePaymentAttempt', 'orderId'),
-    ...$tableColumns('commercePaymentAttempt', 'userId'),
-    ...$tableColumns('commercePaymentAttempt', 'state'),
-    ...$tableColumns('commercePaymentAttempt', 'correlationId'),
-    ...$tableColumns('commercePaymentAudit', 'paymentAttemptId'),
-    ...$tableColumns('commercePaymentAudit', 'providerEventId'),
-    ...$tableColumns('commercePaymentAudit', 'orderId'),
-    ...$tableColumns('commercePaymentAudit', 'idempotencyKey'),
-    ...$tableColumns('commercePaymentRefundRequest', 'orderId'),
-    ...$tableColumns('commercePaymentRefundRequest', 'userId'),
-    ...$tableColumns('commercePaymentRefundRequest', 'state'),
-    ...$tableColumns('commercePaymentRefundRequest', 'correlationId'),
-    ...$tableColumns('commercePaymentRefundAttempt', 'refundRequestId'),
-    ...$tableColumns('commercePaymentRefundAttempt', 'orderId'),
-    ...$tableColumns('commercePaymentRefundAttempt', 'state'),
-    ...$tableColumns('commercePaymentRefundAudit', 'refundRequestId'),
-    ...$tableColumns('commercePaymentRefundAudit', 'refundAttemptId'),
-    ...$tableColumns('commercePaymentRefundAudit', 'orderId'),
-    ...$tableColumns('commercePaymentRefundAudit', 'idempotencyKey'),
-    ...$tableColumns('commercePaymentRefundAudit', 'correlationId'),
+    ...$tableColumns('commercePaymentAttempt', ['orderId', 'userId', 'state', 'correlationId']),
+    ...$tableColumns('commercePaymentAudit', [
+      'paymentAttemptId',
+      'providerEventId',
+      'orderId',
+      'idempotencyKey',
+    ]),
+    ...$tableColumns('commercePaymentRefundRequest', [
+      'orderId',
+      'userId',
+      'state',
+      'correlationId',
+    ]),
+    ...$tableColumns('commercePaymentRefundAttempt', ['refundRequestId', 'orderId', 'state']),
+    ...$tableColumns('commercePaymentRefundAudit', [
+      'refundRequestId',
+      'refundAttemptId',
+      'orderId',
+      'idempotencyKey',
+      'correlationId',
+    ]),
   },
 })
 export class MetaIndex extends BeanBase {}

package/vona/src/suite/a-commerce/modules/commerce-payment/test/paymentIndexes.test.ts

@@ -0,0 +1,165 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { appResource } from 'vona';
+import { app } from 'vona-mock';
+import { ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient } from 'vona-module-a-orm';
+
+const expectedIndexes = {
+  commercePaymentAttempt: ['orderId', 'userId', 'state', 'correlationId'],
+  commercePaymentAudit: ['paymentAttemptId', 'providerEventId', 'orderId', 'idempotencyKey'],
+  commercePaymentRefundRequest: ['orderId', 'userId', 'state', 'correlationId'],
+  commercePaymentRefundAttempt: ['refundRequestId', 'orderId', 'state'],
+  commercePaymentRefundAudit: [
+    'refundRequestId',
+    'refundAttemptId',
+    'orderId',
+    'idempotencyKey',
+    'correlationId',
+  ],
+};
+
+describe('paymentIndexes.test.ts', { concurrency: false }, () => {
+  it('registers all payment indexes without overwriting table keys', () => {
+    const options = appResource.getBean('commerce-payment.meta.index')
+      ?.options as IMetaOptionsIndex;
+    assert.ok(options);
+    assert.deepEqual(options.indexes, expectedIndexes);
+  });
+
+  it('creates non-unique single-column indexes and searches payment audit without a scan', async t => {
+    await app.bean.executor.mockCtx(async () => {
+      if (app.bean.database.current.dialectName !== 'better-sqlite3') {
+        t.skip('SQLite index introspection and query plan');
+        return;
+      }
+      const db = app.bean.database.current.connection;
+      for (const [table, fields] of Object.entries(expectedIndexes)) {
+        const indexList = (await db.raw(`PRAGMA index_list("${table}")`)) as Array<{
+          name: string;
+          unique: number;
+        }>;
+        for (const field of fields) {
+          const name = `idx_${table}_${field}`;
+          const index = indexList.find(item => item.name === name);
+          assert.ok(index, `missing ${name}`);
+          assert.equal(index.unique, 0, `${name} must not be unique`);
+          const columns = (await db.raw(`PRAGMA index_xinfo("${name}")`)) as Array<{
+            name: string;
+            key: number;
+          }>;
+          assert.deepEqual(
+            columns.filter(column => column.key === 1).map(column => column.name),
+            [field],
+          );
+        }
+      }
+
+      for (const eventField of ['providerEventId', 'idempotencyKey']) {
+        const queryPlan = (await db.raw(
+          `EXPLAIN QUERY PLAN SELECT id FROM commercePaymentAudit WHERE iid = ? AND deleted = ? AND paymentAttemptId = ? AND "${eventField}" = ?`,
+          [1, 0, 1, 'event'],
+        )) as Array<{ detail: string }>;
+        assert.ok(
+          queryPlan.some(step =>
+            /SEARCH commercePaymentAudit USING INDEX idx_commercePaymentAudit_/.test(step.detail),
+          ),
+          `${eventField}: ${JSON.stringify(queryPlan)}`,
+        );
+        assert.ok(
+          queryPlan.every(step => !/SCAN commercePaymentAudit/.test(step.detail)),
+          `${eventField}: ${JSON.stringify(queryPlan)}`,
+        );
+      }
+    });
+  });
+
+  it('recovers missing indexes on an isolated copy of an existing database without changing its data', async t => {
+    await app.bean.executor.mockCtx(async () => {
+      if (app.bean.database.current.dialectName !== 'better-sqlite3') {
+        t.skip('SQLite-only independent database copy');
+        return;
+      }
+      const directory = await mkdtemp(path.join(tmpdir(), 'commerce-index-recovery-'));
+      const filename = path.join(directory, 'existing.db');
+      const source = app.bean.database.current;
+      let client: ServiceDatabaseClient | undefined;
+      try {
+        await source.connection.raw('VACUUM main INTO ?', [filename]);
+        const selector = `index-recovery-${randomUUID()}`;
+        client = app.bean._newBean(ServiceDatabaseClient, selector, {
+          client: 'better-sqlite3',
+          connection: { filename },
+          useNullAsDefault: true,
+        });
+        const isolated = client.db;
+        await app.bean._getBean(ServiceDatabaseAsyncLocalStorage).run(isolated, async () => {
+          const db = isolated.connection;
+          const table = 'commercePaymentAudit';
+          const missingIndex = `idx_${table}_providerEventId`;
+          const retainedIndex = `idx_${table}_idempotencyKey`;
+          const marker = `index-recovery-${randomUUID()}`;
+          await db(table).insert({
+            iid: 1,
+            paymentAttemptId: 1,
+            orderId: 1,
+            userId: 1,
+            provider: 'test',
+            providerEventId: marker,
+            outcome: 'failed',
+            fromAttemptState: 'created',
+            toOrderState: 'cancelled',
+            idempotencyKey: marker,
+            correlationId: marker,
+            reason: 'test',
+            processedAt: new Date(),
+          });
+          const versionsBefore = await db('aVersion')
+            .where({ module: 'commerce-payment' })
+            .select('version');
+          await db.schema.alterTable(table, builder =>
+            builder.dropIndex('providerEventId', missingIndex),
+          );
+          const indexesBefore = (await db.raw(`PRAGMA index_list("${table}")`)) as Array<{
+            name: string;
+          }>;
+          assert.equal(
+            indexesBefore.some(item => item.name === missingIndex),
+            false,
+          );
+          assert.ok(indexesBefore.some(item => item.name === retainedIndex));
+
+          const update = async () => {
+            await app.bean._getBean('a-index.meta.version').update({ version: -1 });
+          };
+          for (let pass = 0; pass < 2; pass++) {
+            await update();
+            const indexes = (await db.raw(`PRAGMA index_list("${table}")`)) as Array<{
+              name: string;
+            }>;
+            assert.equal(indexes.filter(item => item.name === missingIndex).length, 1);
+            assert.equal(indexes.filter(item => item.name === retainedIndex).length, 1);
+            const rows = await db(table).where({ providerEventId: marker, idempotencyKey: marker });
+            assert.equal(rows.length, 1);
+            assert.equal(rows[0].paymentAttemptId, 1);
+            assert.deepEqual(
+              await db('aVersion').where({ module: 'commerce-payment' }).select('version'),
+              versionsBefore,
+            );
+          }
+        });
+      } finally {
+        try {
+          if (client) await client.connection.destroy();
+        } finally {
+          await rm(directory, { recursive: true, force: true });
+        }
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/bean/meta.index.ts

@@ -6,19 +6,22 @@ import { $tableColumns } from 'vona-module-a-ormutils';
 
 @Meta<IMetaOptionsIndex>({
   indexes: {
-    ...$tableColumns('commercePromotionCouponTemplate', 'state'),
-    ...$tableColumns('commercePromotionCouponTemplate', 'validUntil'),
-    ...$tableColumns('commercePromotionCouponGrant', 'templateId'),
-    ...$tableColumns('commercePromotionCouponGrant', 'userId'),
-    ...$tableColumns('commercePromotionCouponGrant', 'state'),
-    ...$tableColumns('commercePromotionCouponGrant', 'validUntilSnapshot'),
-    ...$tableColumns('commercePromotionCouponGrant', 'reservationOrderId'),
-    ...$tableColumns('commercePromotionCouponGrant', 'reservationCorrelationId'),
-    ...$tableColumns('commercePromotionCouponGrant', 'redeemedOrderId'),
-    ...$tableColumns('commercePromotionCouponAudit', 'couponGrantId'),
-    ...$tableColumns('commercePromotionCouponAudit', 'templateId'),
-    ...$tableColumns('commercePromotionCouponAudit', 'orderId'),
-    ...$tableColumns('commercePromotionCouponAudit', 'correlationId'),
+    ...$tableColumns('commercePromotionCouponTemplate', ['state', 'validUntil']),
+    ...$tableColumns('commercePromotionCouponGrant', [
+      'templateId',
+      'userId',
+      'state',
+      'validUntilSnapshot',
+      'reservationOrderId',
+      'reservationCorrelationId',
+      'redeemedOrderId',
+    ]),
+    ...$tableColumns('commercePromotionCouponAudit', [
+      'couponGrantId',
+      'templateId',
+      'orderId',
+      'correlationId',
+    ]),
   },
 })
 export class MetaIndex extends BeanBase {}

package/vona/src/suite/a-commerce/modules/commerce-promotion/test/promotionIndexes.test.ts

@@ -0,0 +1,82 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { appResource } from 'vona';
+import { app } from 'vona-mock';
+
+const expectedIndexes = {
+  commercePromotionCouponTemplate: ['state', 'validUntil'],
+  commercePromotionCouponGrant: [
+    'templateId',
+    'userId',
+    'state',
+    'validUntilSnapshot',
+    'reservationOrderId',
+    'reservationCorrelationId',
+    'redeemedOrderId',
+  ],
+  commercePromotionCouponAudit: ['couponGrantId', 'templateId', 'orderId', 'correlationId'],
+};
+
+describe('promotionIndexes.test.ts', { concurrency: false }, () => {
+  it('registers every coupon index without overwriting table keys', () => {
+    const options = appResource.getBean('commerce-promotion.meta.index')
+      ?.options as IMetaOptionsIndex;
+    assert.ok(options);
+    assert.deepEqual(options.indexes, expectedIndexes);
+  });
+
+  it('creates non-unique single-column coupon indexes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const database = app.bean.database.current;
+      const db = database.connection;
+      for (const [table, fields] of Object.entries(expectedIndexes)) {
+        const indexes = await database.dialect.fetchIndexes(db.schema, table);
+        for (const field of fields) {
+          const name = `idx_${table}_${field}`;
+          assert.ok(
+            indexes.some(index => index.indexName === name),
+            `missing ${name}`,
+          );
+          if (database.dialectName === 'better-sqlite3') {
+            const details = (await db.raw(`PRAGMA index_list("${table}")`)) as Array<{
+              name: string;
+              unique: number;
+            }>;
+            assert.equal(details.find(index => index.name === name)?.unique, 0);
+            const columns = (await db.raw(`PRAGMA index_xinfo("${name}")`)) as Array<{
+              name: string;
+              key: number;
+            }>;
+            assert.deepEqual(
+              columns.filter(column => column.key === 1).map(column => column.name),
+              [field],
+            );
+          } else if (database.dialectName === 'mysql2') {
+            const [details] = (await db.raw(`SHOW INDEX FROM \`${table}\``)) as [
+              Array<{
+                Key_name: string;
+                Non_unique: number;
+                Seq_in_index: number;
+                Column_name: string;
+              }>,
+            ];
+            const columns = details.filter(index => index.Key_name === name);
+            assert.ok(columns.length, `missing ${name}`);
+            assert.ok(
+              columns.every(index => index.Non_unique === 1),
+              `${name} must not be unique`,
+            );
+            assert.deepEqual(
+              columns
+                .sort((a, b) => a.Seq_in_index - b.Seq_in_index)
+                .map(index => index.Column_name),
+              [field],
+            );
+          }
+        }
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-trade/src/bean/meta.index.ts

@@ -7,28 +7,30 @@ import { $tableColumns } from 'vona-module-a-ormutils';
 @Meta<IMetaOptionsIndex>({
   indexes: {
     ...$tableColumns('commerceTradeCart', 'userId'),
-    ...$tableColumns('commerceTradeCartItem', 'cartId'),
-    ...$tableColumns('commerceTradeCartItem', 'skuId'),
-    ...$tableColumns('commerceTradeOrder', 'userId'),
-    ...$tableColumns('commerceTradeOrder', 'correlationId'),
-    ...$tableColumns('commerceTradeOrder', 'state'),
-    ...$tableColumns('commerceTradeOrder', 'reservationExpiresAt'),
-    ...$tableColumns('commerceTradeOrderLine', 'orderId'),
-    ...$tableColumns('commerceTradeShipment', 'orderId'),
-    ...$tableColumns('commerceTradeShipment', 'correlationId'),
-    ...$tableColumns('commerceTradeOrderAudit', 'orderId'),
-    ...$tableColumns('commerceTradeOrderAudit', 'correlationId'),
-    ...$tableColumns('commerceTradeOrderLine', 'skuId'),
-    ...$tableColumns('commerceTradeStockAudit', 'stockBalanceId'),
-    ...$tableColumns('commerceTradeStockAudit', 'skuId'),
-    ...$tableColumns('commerceTradeStockAudit', 'stockReservationId'),
-    ...$tableColumns('commerceTradeStockAudit', 'correlationId'),
+    ...$tableColumns('commerceTradeCartItem', ['cartId', 'skuId']),
+    ...$tableColumns('commerceTradeOrder', [
+      'userId',
+      'correlationId',
+      'state',
+      'reservationExpiresAt',
+    ]),
+    ...$tableColumns('commerceTradeOrderLine', ['orderId', 'skuId']),
+    ...$tableColumns('commerceTradeShipment', ['orderId', 'correlationId']),
+    ...$tableColumns('commerceTradeOrderAudit', ['orderId', 'correlationId']),
+    ...$tableColumns('commerceTradeStockAudit', [
+      'stockBalanceId',
+      'skuId',
+      'stockReservationId',
+      'correlationId',
+    ]),
     ...$tableColumns('commerceTradeStockBalance', 'skuId'),
-    ...$tableColumns('commerceTradeStockReservation', 'stockBalanceId'),
-    ...$tableColumns('commerceTradeStockReservation', 'skuId'),
-    ...$tableColumns('commerceTradeStockReservation', 'orderLineId'),
-    ...$tableColumns('commerceTradeStockReservation', 'correlationId'),
-    ...$tableColumns('commerceTradeStockReservation', 'state'),
+    ...$tableColumns('commerceTradeStockReservation', [
+      'stockBalanceId',
+      'skuId',
+      'orderLineId',
+      'correlationId',
+      'state',
+    ]),
   },
 })
 export class MetaIndex extends BeanBase {}

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

@@ -0,0 +1,86 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { appResource } from 'vona';
+import { app } from 'vona-mock';
+
+const expectedIndexes = {
+  commerceTradeCart: 'userId',
+  commerceTradeCartItem: ['cartId', 'skuId'],
+  commerceTradeOrder: ['userId', 'correlationId', 'state', 'reservationExpiresAt'],
+  commerceTradeOrderLine: ['orderId', 'skuId'],
+  commerceTradeShipment: ['orderId', 'correlationId'],
+  commerceTradeOrderAudit: ['orderId', 'correlationId'],
+  commerceTradeStockAudit: ['stockBalanceId', 'skuId', 'stockReservationId', 'correlationId'],
+  commerceTradeStockBalance: 'skuId',
+  commerceTradeStockReservation: [
+    'stockBalanceId',
+    'skuId',
+    'orderLineId',
+    'correlationId',
+    'state',
+  ],
+};
+
+describe('tradeIndexes.test.ts', { concurrency: false }, () => {
+  it('registers every trade index without overwriting table keys', () => {
+    const options = appResource.getBean('commerce-trade.meta.index')?.options as IMetaOptionsIndex;
+    assert.ok(options);
+    assert.deepEqual(options.indexes, expectedIndexes);
+  });
+
+  it('creates non-unique single-column trade indexes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const database = app.bean.database.current;
+      const db = database.connection;
+      for (const [table, value] of Object.entries(expectedIndexes)) {
+        const fields = Array.isArray(value) ? value : [value];
+        const indexes = await database.dialect.fetchIndexes(db.schema, table);
+        for (const field of fields) {
+          const name = `idx_${table}_${field}`;
+          assert.ok(
+            indexes.some(index => index.indexName === name),
+            `missing ${name}`,
+          );
+          if (database.dialectName === 'better-sqlite3') {
+            const details = (await db.raw(`PRAGMA index_list("${table}")`)) as Array<{
+              name: string;
+              unique: number;
+            }>;
+            assert.equal(details.find(index => index.name === name)?.unique, 0);
+            const columns = (await db.raw(`PRAGMA index_xinfo("${name}")`)) as Array<{
+              name: string;
+              key: number;
+            }>;
+            assert.deepEqual(
+              columns.filter(column => column.key === 1).map(column => column.name),
+              [field],
+            );
+          } else if (database.dialectName === 'mysql2') {
+            const [details] = (await db.raw(`SHOW INDEX FROM \`${table}\``)) as [
+              Array<{
+                Key_name: string;
+                Non_unique: number;
+                Seq_in_index: number;
+                Column_name: string;
+              }>,
+            ];
+            const columns = details.filter(index => index.Key_name === name);
+            assert.ok(columns.length, `missing ${name}`);
+            assert.ok(
+              columns.every(index => index.Non_unique === 1),
+              `${name} must not be unique`,
+            );
+            assert.deepEqual(
+              columns
+                .sort((a, b) => a.Seq_in_index - b.Seq_in_index)
+                .map(index => index.Column_name),
+              [field],
+            );
+          }
+        }
+      }
+    });
+  });
+});