cabloy 5.1.194 → 5.1.196

package/vona/packages-cli/cli-set-api/cli/templates/tools/crudBasic/snippets/2-meta.index.ts

@@ -1,4 +1,5 @@
 import { metadataCustomSnippet } from '@cabloy/cli';
+import { mergeMetaIndex } from 'vona-cli-set-api/mergeMetaIndex';
 import { catchError } from '@cabloy/utils';
 import fs from 'node:fs';
 
@@ -9,7 +10,7 @@ declare module '@cabloy/cli' {
 }
 
 const __snippet_import1 = "import { $tableColumns } from 'vona-module-a-ormutils';";
-const __snippet_update = "...$tableColumns('<%=argv.moduleResourceName%>', 'name'),";
+const __snippet_table = '<%=argv.moduleResourceName%>';
 
 export default metadataCustomSnippet({
   file: 'src/bean/meta.index.ts',
@@ -35,14 +36,7 @@ export default metadataCustomSnippet({
         `import { Meta } from 'vona-module-a-meta';\n${code}`,
       );
     }
-    // update
-    const code = await cli.template.renderContent({ content: __snippet_update });
-    if (ast.includes('indexes: {}')) {
-      ast = ast.replace('indexes: {', `indexes: {\n    ${code}\n  `);
-    } else {
-      ast = ast.replace('indexes: {', `indexes: {\n    ${code}`);
-    }
-    // ok
-    return ast;
+    const table = await cli.template.renderContent({ content: __snippet_table });
+    return mergeMetaIndex(ast, table, 'name');
   },
 });

package/vona/packages-cli/cli-set-api/cli/templates/tools/crudStart/snippets/2-meta.index.ts

@@ -1,4 +1,5 @@
 import { metadataCustomSnippet } from '@cabloy/cli';
+import { mergeMetaIndex } from 'vona-cli-set-api/mergeMetaIndex';
 import { catchError } from '@cabloy/utils';
 import fs from 'node:fs';
 
@@ -9,7 +10,7 @@ declare module '@cabloy/cli' {
 }
 
 const __snippet_import1 = "import { $tableColumns } from 'vona-module-a-ormutils';";
-const __snippet_update = "...$tableColumns('<%=argv.moduleResourceName%>', 'name'),";
+const __snippet_table = '<%=argv.moduleResourceName%>';
 
 export default metadataCustomSnippet({
   file: 'src/bean/meta.index.ts',
@@ -35,14 +36,7 @@ export default metadataCustomSnippet({
         `import { Meta } from 'vona-module-a-meta';\n${code}`,
       );
     }
-    // update
-    const code = await cli.template.renderContent({ content: __snippet_update });
-    if (ast.includes('indexes: {}')) {
-      ast = ast.replace('indexes: {', `indexes: {\n    ${code}\n  `);
-    } else {
-      ast = ast.replace('indexes: {', `indexes: {\n    ${code}`);
-    }
-    // ok
-    return ast;
+    const table = await cli.template.renderContent({ content: __snippet_table });
+    return mergeMetaIndex(ast, table, 'name');
   },
 });

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.154",
+  "version": "1.1.155",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [
@@ -26,6 +26,11 @@
       "import": "./src/index.ts",
       "default": "./dist/index.js"
     },
+    "./mergeMetaIndex": {
+      "types": "./dist/lib/mergeMetaIndex.d.ts",
+      "import": "./src/lib/mergeMetaIndex.ts",
+      "default": "./dist/index.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -86,7 +91,8 @@
     "remove": [
       "clean-package",
       "devDependencies",
-      "exports.\\..import"
+      "exports.\\..import",
+      "exports.\\./mergeMetaIndex.import"
     ]
   }
 }

package/vona/packages-cli/cli-set-api/src/index.ts

@@ -1,3 +1,4 @@
 export * from './lib/beans.ts';
 export * from './lib/commands.ts';
 export * from './lib/utils.ts';
+export { mergeMetaIndex } from './lib/mergeMetaIndex.ts';

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.tools.masterDetail.ts

@@ -4,6 +4,7 @@ import { BeanCliBase } from '@cabloy/cli';
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { mergeMetaIndex } from '../mergeMetaIndex.ts';
 import { __ThisSetName__ } from '../this.ts';
 
 type DetailMode = 'aggregate' | 'standalone';
@@ -179,13 +180,14 @@ export class CliToolsMasterDetail extends BeanCliBase {
 
   private async _patchDetailMetaIndex() {
     const { argv } = this.context;
-    await this._patchFileByMarker({
-      fileName: this._detailPaths().metaIndex,
-      existsNeedle: `'${argv.fk}'`,
-      marker: '  indexes: {\n',
-      line: this._detailMetaIndexLine(),
-      shapeName: 'detail meta.index',
-    });
+    const fileName = this._detailPaths().metaIndex;
+    const content = this._readFile(fileName);
+    const table = this.helper.combineModuleNameAndResource(
+      argv.detailModuleInfo.relativeName,
+      argv.detailResourceName,
+    );
+    const updated = mergeMetaIndex(content, table, argv.fk);
+    if (updated !== content) await this._saveFile(fileName, updated);
   }
 
   private _detailMetaVersionLine() {
@@ -193,11 +195,6 @@ export class CliToolsMasterDetail extends BeanCliBase {
     return `        table.tableIdentity(entity${argv.detailResourceNameCapitalize}.${argv.fk}).comment(entity${argv.detailResourceNameCapitalize}.$comment.${argv.fk});\n`;
   }
 
-  private _detailMetaIndexLine() {
-    const { argv } = this.context;
-    return `    ...$tableColumns('${this.helper.combineModuleNameAndResource(argv.detailModuleInfo.relativeName, argv.detailResourceName)}', '${argv.fk}'),\n`;
-  }
-
   private async _patchFileByMarker({
     fileName,
     existsNeedle,

package/vona/packages-cli/cli-set-api/src/lib/mergeMetaIndex.ts

@@ -0,0 +1,121 @@
+import gogocode from 'gogocode';
+
+interface AstNode {
+  type: string;
+  start: number;
+  end: number;
+  [key: string]: any;
+}
+
+function propertyName(node: AstNode): string | undefined {
+  if (node.computed) return;
+  if (node.key?.type === 'Identifier') return node.key.name;
+  if (node.key?.type === 'StringLiteral') return node.key.value;
+}
+
+function literalValue(node: AstNode): string | undefined {
+  return node?.type === 'StringLiteral' ? node.value : undefined;
+}
+
+function indexObject(source: string): AstNode {
+  const file = gogocode(source, {
+    parseOptions: { sourceType: 'module', plugins: ['typescript', 'decorators-legacy'] },
+  }).node as AstNode;
+  const objects: AstNode[] = [];
+  for (const statement of file.program.body as AstNode[]) {
+    const declaration = statement.declaration ?? statement;
+    for (const decorator of declaration.decorators ?? []) {
+      const call = decorator.expression;
+      if (call.type !== 'CallExpression' || call.callee.name !== 'Meta') continue;
+      const options = call.arguments[0];
+      if (options?.type !== 'ObjectExpression') continue;
+      for (const property of options.properties as AstNode[]) {
+        if (property.type === 'ObjectProperty' && propertyName(property) === 'indexes') {
+          if (property.value.type !== 'ObjectExpression') {
+            throw new Error('meta.index indexes must be an object literal');
+          }
+          objects.push(property.value);
+        }
+      }
+    }
+  }
+  if (objects.length !== 1) throw new Error('expected exactly one @Meta indexes object');
+  return objects[0];
+}
+
+function quote(value: string): string {
+  return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+}
+
+export function mergeMetaIndex(source: string, tableName: string, field: string): string {
+  const indexes = indexObject(source);
+  const declarations: AstNode[] = [];
+  const fields: string[] = [];
+  for (const property of indexes.properties as AstNode[]) {
+    if (property.type === 'ObjectProperty') {
+      const key = propertyName(property);
+      if (!key || key === tableName) {
+        throw new Error(`unsupported index property for ${tableName}`);
+      }
+      continue;
+    }
+    if (property.type !== 'SpreadElement') {
+      throw new Error(`unsupported index declaration for ${tableName}`);
+    }
+    const call = property.argument;
+    if (call.type !== 'CallExpression' || call.callee.name !== '$tableColumns') {
+      throw new Error(`unsupported index spread for ${tableName}`);
+    }
+    const name = literalValue(call.arguments[0]);
+    if (!name) throw new Error(`index table name must be a string literal: ${tableName}`);
+    if (name !== tableName) continue;
+    const value = call.arguments[1];
+    let values: AstNode[];
+    if (value?.type === 'StringLiteral') values = [value];
+    else if (value?.type === 'ArrayExpression') values = value.elements;
+    else throw new Error(`unsupported index fields for ${tableName}`);
+    for (const item of values) {
+      const text = literalValue(item);
+      if (text === undefined) throw new Error(`unsupported index fields for ${tableName}`);
+      for (const spec of text.split(',')) {
+        if (!fields.includes(spec)) fields.push(spec);
+      }
+    }
+    declarations.push(property);
+  }
+  if (!fields.includes(field)) fields.push(field);
+  if (declarations.length === 1) {
+    const value = declarations[0].argument.arguments[1];
+    if (value.type === 'StringLiteral' && fields.length === 1 && value.value === field)
+      return source;
+    if (value.type === 'ArrayExpression') {
+      const values = value.elements.map(literalValue);
+      if (
+        values.length === fields.length &&
+        values.every((item, index) => item === fields[index])
+      ) {
+        return source;
+      }
+    }
+  }
+  const columns = fields.length === 1 ? quote(fields[0]) : `[${fields.map(quote).join(', ')}]`;
+  const declaration = `...$tableColumns(${quote(tableName)}, ${columns})`;
+  if (!declarations.length) {
+    const content = source.slice(indexes.start + 1, indexes.end - 1);
+    if (content.trim() && !content.trimEnd().endsWith(',')) {
+      throw new Error(`indexes object must use trailing commas before adding ${tableName}`);
+    }
+    return `${source.slice(0, indexes.start + 1)}\n    ${declaration},${source.slice(indexes.start + 1)}`;
+  }
+  const patches = declarations.map((item, index) => {
+    if (!index) return { start: item.start, end: item.end, text: declaration };
+    let end = item.end;
+    while (/\s/.test(source[end]) && end < indexes.end) end++;
+    if (source[end] === ',') end++;
+    return { start: item.start, end, text: '' };
+  });
+  for (const patch of patches.reverse()) {
+    source = `${source.slice(0, patch.start)}${patch.text}${source.slice(patch.end)}`;
+  }
+  return source;
+}

package/vona/packages-cli/cli-set-api/test/indexSnippets.test.ts

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import basic from '../cli/templates/tools/crudBasic/snippets/2-meta.index.ts';
+import start from '../cli/templates/tools/crudStart/snippets/2-meta.index.ts';
+import { mergeMetaIndex } from '../src/lib/mergeMetaIndex.ts';
+
+const initial = `import { Meta } from 'vona-module-a-meta';
+@Meta({ indexes: { ...$tableColumns('trainingRecord', 'studentId'), } }) class MetaIndex {}
+`;
+
+const cli = {
+  template: {
+    renderContent: async ({ content }: { content: string }) =>
+      content.replace('<%=argv.moduleResourceName%>', 'trainingRecord'),
+  },
+};
+
+describe('CRUD index snippets', () => {
+  it('resolves the shared index helper from source', async () => {
+    assert.equal(
+      import.meta.resolve('vona-cli-set-api/mergeMetaIndex'),
+      new URL('../src/lib/mergeMetaIndex.ts', import.meta.url).href,
+    );
+    const { mergeMetaIndex: exported } = await import('vona-cli-set-api/mergeMetaIndex');
+    assert.equal(exported, mergeMetaIndex);
+  });
+
+  for (const [edition, snippet] of [
+    ['basic', basic],
+    ['start', start],
+  ] as const) {
+    it(`${edition} merges name into an existing detail index`, async () => {
+      const result = await snippet.transform({ cli, ast: initial } as never);
+      assert.equal(result.match(/\.\.\.\$tableColumns\('trainingRecord'/g)?.length, 1);
+      assert.match(result, /\['studentId', 'name'\]/);
+      assert.equal(await snippet.transform({ cli, ast: result } as never), result);
+      assert.equal(mergeMetaIndex(result, 'trainingRecord', 'studentId'), result);
+    });
+  }
+});

package/vona/packages-cli/cli-set-api/test/mergeMetaIndex.test.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { mergeMetaIndex } from '../src/lib/mergeMetaIndex.ts';
+
+const source = (indexes: string) => `import { Meta } from 'vona-module-a-meta';
+@Meta({
+  indexes: {
+${indexes}
+  },
+})
+class MetaIndex {}
+`;
+
+function declarations(code: string, table: string) {
+  const matcher = /\.\.\.\$tableColumns\('([^']+)', (\[[^\]]+\]|'[^']+')\)/g;
+  const found = [...code.matchAll(matcher)].filter(match => {
+    const line = code.slice(code.lastIndexOf('\n', match.index) + 1, match.index);
+    return match[1] === table && !line.includes('//');
+  });
+  assert.equal(found.length, 1, code);
+  const fields = found[0][2];
+  return fields.startsWith('[')
+    ? Array.from(fields.matchAll(/'([^']+)'/g), match => match[1])
+    : [fields.slice(1, -1)];
+}
+
+describe('mergeMetaIndex', () => {
+  it('adds name and foreign-key indexes independently to a new table', () => {
+    const input = source('');
+    const withName = mergeMetaIndex(input, 'trainingRecord', 'name');
+    const withForeignKey = mergeMetaIndex(withName, 'trainingRecord', 'studentId');
+    assert.deepEqual(declarations(withForeignKey, 'trainingRecord'), ['name', 'studentId']);
+    assert.equal(mergeMetaIndex(withForeignKey, 'trainingRecord', 'studentId'), withForeignKey);
+  });
+
+  it('merges existing arrays, composites, and repeated table spreads without changing other tables', () => {
+    const input = source(`    ...$tableColumns('other', 'studentId'),
+    ...$tableColumns('trainingRecord', ['name', 'state+expiresAt']),
+    ...$tableColumns('trainingRecord', 'studentId'),`);
+    const output = mergeMetaIndex(input, 'trainingRecord', 'studentId');
+    assert.deepEqual(declarations(output, 'trainingRecord'), [
+      'name',
+      'state+expiresAt',
+      'studentId',
+    ]);
+    assert.deepEqual(declarations(output, 'other'), ['studentId']);
+    assert.equal(mergeMetaIndex(output, 'trainingRecord', 'studentId'), output);
+  });
+
+  it('repairs previously generated declarations even if the requested field appears first', () => {
+    const input = source(`    ...$tableColumns('trainingRecord', 'studentId'),
+    ...$tableColumns('trainingRecord', 'name'),`);
+    const output = mergeMetaIndex(input, 'trainingRecord', 'studentId');
+    assert.deepEqual(declarations(output, 'trainingRecord'), ['studentId', 'name']);
+    assert.equal(mergeMetaIndex(output, 'trainingRecord', 'studentId'), output);
+  });
+
+  it('does not confuse another table or comment with an existing target index', () => {
+    const input = source(`    // ...$tableColumns('trainingRecord', 'studentId'),
+    ...$tableColumns('other', 'studentId'),`);
+    const output = mergeMetaIndex(input, 'trainingRecord', 'studentId');
+    assert.deepEqual(declarations(output, 'trainingRecord'), ['studentId']);
+    assert.match(output, /\.\.\.\$tableColumns\('other', 'studentId'\)/);
+  });
+
+  it('rejects ambiguous same-table expressions', () => {
+    const input = source("    ...$tableColumns('trainingRecord', fields),");
+    assert.throws(
+      () => mergeMetaIndex(input, 'trainingRecord', 'studentId'),
+      /unsupported index fields/,
+    );
+    assert.throws(
+      () => mergeMetaIndex(source("    trainingRecord: ['name'],"), 'trainingRecord', 'studentId'),
+      /unsupported index property/,
+    );
+  });
+});

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.102",
+  "version": "5.1.103",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/pnpm-lock.yaml

@@ -1652,7 +1652,7 @@ importers:
         specifier: ^5.0.3
         version: link:modules/a-markdown
       vona-module-a-rbac:
-        specifier: ^5.0.7
+        specifier: ^5.0.8
         version: link:modules/a-rbac
       vona-module-a-socket:
         specifier: workspace:^
@@ -1956,16 +1956,16 @@ importers:
   src/suite-vendor/a-pay:
     dependencies:
       vona-module-a-pay:
-        specifier: ^5.0.8
+        specifier: ^5.0.10
         version: link:modules/a-pay
       vona-module-pay-mock:
-        specifier: ^5.0.8
+        specifier: ^5.0.10
         version: link:modules/pay-mock
       vona-module-pay-paypal:
-        specifier: ^5.0.8
+        specifier: ^5.0.10
         version: link:modules/pay-paypal
       vona-module-pay-stripe:
-        specifier: ^5.0.8
+        specifier: ^5.0.10
         version: link:modules/pay-stripe
 
   src/suite-vendor/a-pay/modules/a-pay:
@@ -2031,7 +2031,7 @@ importers:
         specifier: ^5.0.3
         version: link:modules/test-markdown
       vona-module-test-pay:
-        specifier: ^5.0.7
+        specifier: ^5.0.9
         version: link:modules/test-pay
 
   src/suite-vendor/a-test/modules/test-auth:

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/sku.ts

@@ -19,8 +19,27 @@ const allowedLifecycleTransitions: Record<EntitySku['lifecycle'], EntitySku['lif
   archived: [],
 };
 
+const serializationRetryOptions = {
+  retries: 6,
+  factor: 2,
+  minTimeout: 10,
+  maxTimeout: 160,
+  randomize: true,
+  errorCodes: [
+    '40001',
+    '40P01',
+    'ER_LOCK_DEADLOCK',
+    'ER_LOCK_WAIT_TIMEOUT',
+    'SQLITE_BUSY',
+    'SQLITE_BUSY_SNAPSHOT',
+  ],
+  ownerOnly: true,
+};
+
 @Service()
 export class ServiceSku extends BeanBase {
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
   async create(sku: DtoSkuCreate): Promise<EntitySku> {
     await this._ensureProductExists(sku.productId);
     await this._ensureCodeAvailable(sku.code);
@@ -64,6 +83,7 @@ export class ServiceSku extends BeanBase {
   }
 
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
   async update(id: TableIdentity, sku: DtoSkuUpdate) {
     if (sku.lifecycle !== undefined) {
       const currentSku = await this.scope.model.sku.getByIdForUpdate(id);
@@ -96,9 +116,10 @@ export class ServiceSku extends BeanBase {
   }
 
   private async _ensureCodeAvailable(code: string, excludedId?: TableIdentity) {
-    const sku = await this.scope.model.sku.get({ code });
-    if (sku && String(sku.id) !== String(excludedId)) {
-      this.app.throw(409, `SKU code already exists: ${code}`);
-    }
+    const sku = await this.scope.model.sku.get(
+      { code, ...(excludedId === undefined ? {} : { id: { _notEq_: excludedId } }) },
+      { disableCacheEntity: true, disableCacheQuery: true },
+    );
+    if (sku) this.app.throw(409, `SKU code already exists: ${code}`);
   }
 }

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

@@ -0,0 +1,161 @@
+import type { TableIdentity } from 'table-identity';
+
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
+
+interface ISkuFixture {
+  categoryId?: TableIdentity;
+  productIds: TableIdentity[];
+  codes: string[];
+}
+
+async function runInContext<T>(operation: () => Promise<T>): Promise<T> {
+  return await app.bean.executor.mockCtx(operation);
+}
+
+async function createFixture(fixture: ISkuFixture, suffix: string, products = 1) {
+  await runInContext(async () => {
+    const catalog = app.scope('commerce-catalog');
+    const category = await catalog.model.category.insert({
+      name: `sku-unique-category-${suffix}`,
+      published: false,
+    });
+    fixture.categoryId = category.id;
+    for (let index = 0; index < products; index++) {
+      const product = await catalog.model.product.insert({
+        categoryId: category.id,
+        title: `sku-unique-product-${suffix}-${index}`,
+        published: false,
+      });
+      fixture.productIds.push(product.id);
+    }
+  });
+}
+
+async function cleanupFixture(fixture: ISkuFixture) {
+  await runInContext(async () => {
+    const catalog = app.scope('commerce-catalog');
+    for (const productId of fixture.productIds) {
+      for (const code of fixture.codes) {
+        const skus = await catalog.model.sku.select(
+          { where: { productId, code } },
+          { disableDeleted: true },
+        );
+        for (const sku of skus) {
+          await catalog.model.sku.delete({ id: sku.id }, { disableDeleted: true });
+        }
+      }
+      await catalog.model.product.delete({ id: productId }, { disableDeleted: true });
+    }
+    if (fixture.categoryId !== undefined) {
+      await catalog.model.category.delete({ id: fixture.categoryId }, { disableDeleted: true });
+    }
+  });
+}
+
+function assertOneBusinessConflict(results: PromiseSettledResult<unknown>[]) {
+  assert.equal(
+    results.filter(result => result.status === 'fulfilled').length,
+    1,
+    JSON.stringify(results),
+  );
+  const rejected = results.filter(result => result.status === 'rejected');
+  assert.equal(rejected.length, 1, JSON.stringify(results));
+  assert.equal((rejected[0] as PromiseRejectedResult).reason?.code, 409);
+}
+
+describe('skuUniqueness.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-commerce');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
+  it('keeps exactly one SKU after competing same-tenant creates across products', async () => {
+    const fixture: ISkuFixture = { productIds: [], codes: [] };
+    const suffix = randomUUID().slice(0, 12);
+    const code = `sku-unique-create-${suffix}`;
+    fixture.codes.push(code);
+    try {
+      await createFixture(fixture, suffix, 2);
+      const results = await Promise.allSettled(
+        fixture.productIds.map(productId =>
+          runInContext(() =>
+            app.scope('commerce-catalog').service.sku.create({
+              productId,
+              code,
+              priceCents: 100,
+              lifecycle: 'draft',
+            }),
+          ),
+        ),
+      );
+      assertOneBusinessConflict(results);
+      await runInContext(async () => {
+        const skus = await app.scope('commerce-catalog').model.sku.select({ where: { code } });
+        assert.equal(skus.length, 1);
+        assert.ok(
+          fixture.productIds.some(productId => String(productId) === String(skus[0]!.productId)),
+        );
+      });
+    } finally {
+      await cleanupFixture(fixture);
+    }
+  });
+
+  it('keeps exactly one target code after competing updates', async () => {
+    const fixture: ISkuFixture = { productIds: [], codes: [] };
+    const suffix = randomUUID().slice(0, 12);
+    const targetCode = `sku-unique-update-${suffix}`;
+    const sourceCodes = [0, 1].map(index => `sku-unique-source-${suffix}-${index}`);
+    fixture.codes.push(targetCode, ...sourceCodes);
+    try {
+      await createFixture(fixture, suffix, 2);
+      const sourceIds = await runInContext(async () => {
+        const catalog = app.scope('commerce-catalog');
+        const skus = [];
+        for (let index = 0; index < 2; index++) {
+          skus.push(
+            await catalog.service.sku.create({
+              productId: fixture.productIds[index]!,
+              code: sourceCodes[index]!,
+              priceCents: 100,
+              lifecycle: 'draft',
+            }),
+          );
+        }
+        return skus.map(sku => sku.id);
+      });
+      const results = await Promise.allSettled(
+        sourceIds.map((skuId, index) =>
+          runInContext(() =>
+            app.scope('commerce-catalog').service.sku.update(skuId, {
+              productId: fixture.productIds[index]!,
+              code: targetCode,
+              priceCents: 200,
+              lifecycle: 'draft',
+            }),
+          ),
+        ),
+      );
+      assertOneBusinessConflict(results);
+      await runInContext(async () => {
+        const catalog = app.scope('commerce-catalog');
+        const targetSkus = await catalog.model.sku.select({ where: { code: targetCode } });
+        assert.equal(targetSkus.length, 1);
+        const allSkus = await catalog.model.sku.select({ where: { id: sourceIds } });
+        assert.equal(allSkus.length, 2);
+        assert.equal(allSkus.filter(sku => sourceCodes.includes(sku.code!)).length, 1);
+        assert.equal(allSkus.find(sku => sku.code === targetCode)?.priceCents, 200);
+      });
+    } finally {
+      await cleanupFixture(fixture);
+    }
+  });
+});