cabloy 5.1.131 → 5.1.133

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

@@ -0,0 +1,70 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsRefundRecoveryView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRefundRecoveryView>()
+export class DtoRefundRecoveryView {
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  refundRequestId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  refundAttemptId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  refundOperationId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  providerOperationId: TableIdentity;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  providerName: string;
+
+  @Api.field(z.enum(['sandbox', 'live']))
+  environment: 'sandbox' | 'live';
+
+  @Api.field(z.enum(['created', 'submitting', 'pending', 'succeeded', 'failed', 'cancelled']))
+  refundOperationState: 'created' | 'submitting' | 'pending' | 'succeeded' | 'failed' | 'cancelled';
+
+  @Api.field(
+    z.enum(['created', 'claimed', 'submitted', 'succeeded', 'failed', 'reconciliation_required']),
+  )
+  providerOperationState:
+    | 'created'
+    | 'claimed'
+    | 'submitted'
+    | 'succeeded'
+    | 'failed'
+    | 'reconciliation_required';
+
+  @Api.field(z.number().int().nonnegative())
+  attemptCount: number;
+
+  @Api.field(v.optional(), v.max(255))
+  providerRefundId?: string;
+
+  @Api.field(v.optional(), v.max(100))
+  errorCode?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  errorSummary?: string;
+
+  @Api.field(v.optional())
+  submittedAt?: Date;
+
+  @Api.field(v.optional())
+  finalizedAt?: Date;
+
+  @Api.field(z.enum(['none', 'reconcile_only', 'query_only', 'retry_same_key']))
+  recoveryDisposition: 'none' | 'reconcile_only' | 'query_only' | 'retry_same_key';
+
+  @Api.field(v.required())
+  recoveryMessage: string;
+}

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

@@ -6,6 +6,7 @@ import { Dto } from 'vona-module-a-web';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { $locale } from '../.metadata/locales.ts';
+import { EntityStockAudit } from '../entity/stockAudit.tsx';
 import { ModelStockAudit } from '../model/stockAudit.ts';
 
 export interface IDtoOptionsStockAuditSelectResItem extends IDecoratorDtoOptions {}
@@ -43,7 +44,12 @@ export interface IDtoOptionsStockAuditSelectResItem extends IDecoratorDtoOptions
     }),
   ],
 })
-export class DtoStockAuditSelectResItem extends $Dto.get(() => ModelStockAudit) {
+export class DtoStockAuditSelectResItem extends $Dto.get(() => ModelStockAudit, {
+  columns: ['id', 'skuId', 'operation', 'delta', 'createdAt'],
+}) {
+  @Api.field(ZovaRender.order(1, 'core'), ZovaRender.cell('basic-table:actionView'))
+  declare id: EntityStockAudit['id'];
+
   @Api.field(
     v.title($locale('Operations')),
     ZovaRender.order(1, 'max'),

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

@@ -22,4 +22,24 @@ export interface IDtoOptionsStockAuditView extends IDecoratorDtoOptions {}
     }),
   ],
 })
-export class DtoStockAuditView extends $Dto.get(() => ModelStockAudit) {}
+export class DtoStockAuditView extends $Dto.get(() => ModelStockAudit, {
+  columns: [
+    'id',
+    'stockBalanceId',
+    'skuId',
+    'stockReservationId',
+    'actorId',
+    'operation',
+    'delta',
+    'reason',
+    'correlationId',
+    'priorOnHand',
+    'priorReserved',
+    'priorAvailable',
+    'onHand',
+    'reserved',
+    'available',
+    'createdAt',
+    'updatedAt',
+  ],
+}) {}

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

@@ -6,6 +6,7 @@ import { Dto } from 'vona-module-a-web';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { $locale } from '../.metadata/locales.ts';
+import { EntityStockBalance } from '../entity/stockBalance.tsx';
 import { ModelStockBalance } from '../model/stockBalance.ts';
 
 export interface IDtoOptionsStockBalanceSelectResItem extends IDecoratorDtoOptions {}
@@ -43,7 +44,12 @@ export interface IDtoOptionsStockBalanceSelectResItem extends IDecoratorDtoOptio
     }),
   ],
 })
-export class DtoStockBalanceSelectResItem extends $Dto.get(() => ModelStockBalance) {
+export class DtoStockBalanceSelectResItem extends $Dto.get(() => ModelStockBalance, {
+  columns: ['id', 'skuId', 'onHand', 'reserved', 'available'],
+}) {
+  @Api.field(ZovaRender.order(1, 'core'), ZovaRender.cell('basic-table:actionView'))
+  declare id: EntityStockBalance['id'];
+
   @Api.field(
     v.title($locale('Operations')),
     ZovaRender.order(1, 'max'),

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

@@ -22,4 +22,6 @@ export interface IDtoOptionsStockBalanceView extends IDecoratorDtoOptions {}
     }),
   ],
 })
-export class DtoStockBalanceView extends $Dto.get(() => ModelStockBalance) {}
+export class DtoStockBalanceView extends $Dto.get(() => ModelStockBalance, {
+  columns: ['id', 'skuId', 'onHand', 'reserved', 'available', 'createdAt', 'updatedAt'],
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/entity/order.tsx

@@ -10,6 +10,18 @@ import { $locale } from '../.metadata/locales.ts';
 import { DtoOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
 import { DtoOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
 
+export const orderStateItems = [
+  { value: 'awaiting_payment', title: $locale('OrderStateAwaitingPayment') },
+  { value: 'paid', title: $locale('OrderStatePaid') },
+  { value: 'refund_requested', title: $locale('OrderStateRefundRequested') },
+  { value: 'refund_approved', title: $locale('OrderStateRefundApproved') },
+  { value: 'refund_rejected', title: $locale('OrderStateRefundRejected') },
+  { value: 'shipped', title: $locale('OrderStateShipped') },
+  { value: 'refunded', title: $locale('OrderStateRefunded') },
+  { value: 'cancelled', title: $locale('OrderStateCancelled') },
+  { value: 'expired', title: $locale('OrderStateExpired') },
+];
+
 export type TypeOrderState =
   | 'awaiting_payment'
   | 'paid'

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

@@ -9,8 +9,21 @@ export interface IModelOptionsOrder extends IDecoratorModelOptions<EntityOrder>
 @Model<IModelOptionsOrder>({
   entity: EntityOrder,
   relations: {
-    lines: $relation.hasMany('commerce-trade:orderLine', 'orderId'),
-    shipment: $relation.hasOne('commerce-trade:shipment', 'orderId'),
+    lines: $relation.hasMany('commerce-trade:orderLine', 'orderId', {
+      columns: [
+        'id',
+        'skuCodeSnapshot',
+        'titleSnapshot',
+        'skuAttributesSnapshot',
+        'unitPriceCents',
+        'quantity',
+        'eligibleSubtotalCents',
+        'lineTotalCents',
+      ],
+    }),
+    shipment: $relation.hasOne('commerce-trade:shipment', 'orderId', {
+      columns: ['id', 'carrier', 'trackingNumber', 'shippedAt'],
+    }),
   },
 })
 export class ModelOrder extends BeanModelBase<EntityOrder> {}

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

@@ -15,6 +15,7 @@ import { Core } from 'vona-module-a-core';
 import type { DtoCheckoutCreate } from '../dto/checkoutCreate.tsx';
 import type { DtoCheckoutResult } from '../dto/checkoutResult.tsx';
 import type { DtoOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
+import type { DtoOrderAdminLineResItem } from '../dto/orderAdminLineResItem.tsx';
 import type { DtoOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
 import type { DtoOrderDetail } from '../dto/orderDetail.tsx';
 import type { DtoOrderLineSkuAttributeSnapshot } from '../dto/orderLineSkuAttributeSnapshot.tsx';
@@ -25,6 +26,8 @@ import type { DtoOrderView } from '../dto/orderView.tsx';
 import type { DtoPaymentOutcomeCreate } from '../dto/paymentOutcomeCreate.tsx';
 import type { DtoPaymentOutcomeResult } from '../dto/paymentOutcomeResult.tsx';
 import type { DtoRefundOutcomeCreate } from '../dto/refundOutcomeCreate.tsx';
+import type { DtoRefundRecoveryAction } from '../dto/refundRecoveryAction.tsx';
+import type { DtoRefundRecoveryView } from '../dto/refundRecoveryView.tsx';
 import type { DtoRefundRequestCreate } from '../dto/refundRequestCreate.tsx';
 import type { DtoRefundResult } from '../dto/refundResult.tsx';
 import type { DtoRefundReview } from '../dto/refundReview.tsx';
@@ -55,7 +58,13 @@ const serializationRetryOptions = {
   minTimeout: 0,
   maxTimeout: 0,
   randomize: false,
-  errorCodes: ['40001', 'ER_LOCK_DEADLOCK', 'ER_LOCK_WAIT_TIMEOUT'],
+  errorCodes: [
+    '40001',
+    'ER_LOCK_DEADLOCK',
+    'ER_LOCK_WAIT_TIMEOUT',
+    'SQLITE_BUSY',
+    'SQLITE_BUSY_SNAPSHOT',
+  ],
 };
 
 const checkoutSerializationRetryOptions = {
@@ -726,6 +735,43 @@ export class ServiceOrder extends BeanBase {
     return await this._reviewRefund(orderId, command, decision, onStage);
   }
 
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async refundRecovery(orderId: TableIdentity): Promise<DtoRefundRecoveryView> {
+    const linked = await this.refundRecoveryLinkage(orderId);
+    return this._refundRecoveryView(linked);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async reconcileRefund(
+    orderId: TableIdentity,
+    command: DtoRefundRecoveryAction,
+  ): Promise<DtoRefundRecoveryView> {
+    const linked = await this.refundRecoveryLinkage(orderId);
+    await this.$scope.pay.service.providerOperation.reconcileRefund(linked.providerOperation.id, {
+      ...command,
+      actorId: this.bean.passport.currentUser!.id,
+    });
+    return await this.refundRecovery(orderId);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async retryRefund(
+    orderId: TableIdentity,
+    command: DtoRefundRecoveryAction,
+  ): Promise<DtoRefundRecoveryView> {
+    const linked = await this.refundRecoveryLinkage(orderId);
+    await this.$scope.pay.service.providerOperation.retryRefund(linked.providerOperation.id, {
+      ...command,
+      actorId: this.bean.passport.currentUser!.id,
+    });
+    return await this.refundRecovery(orderId);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
   async executeRefund(orderId: TableIdentity): Promise<DtoRefundResult> {
     const prepared = await this._prepareRefundExecution(orderId);
     await this.$scope.commercePayment.service.commercePayScene.createRefundOperation(prepared.id);
@@ -743,6 +789,140 @@ export class ServiceOrder extends BeanBase {
 
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
   @Core.retryable(serializationRetryOptions)
+  async refundRecoveryLinkage(orderId: TableIdentity) {
+    const order = await this.scope.model.order.getByIdForUpdate(orderId);
+    if (!order) this.app.throw(404, 'order not found');
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getForUpdate({
+      orderId: order.id,
+      state: 'approved',
+    });
+    if (!refundRequest) this.app.throw(404, 'approved refund request not found');
+    const refundAttempt = await this.$scope.commercePayment.model.refundAttempt.getForUpdate({
+      refundRequestId: refundRequest.id,
+    });
+    if (!refundAttempt?.refundOperationId) this.app.throw(404, 'refund recovery is not available');
+    const paymentAttempt = await this.$scope.commercePayment.model.paymentAttempt.getForUpdate({
+      orderId: order.id,
+    });
+    if (!paymentAttempt?.paymentSessionId)
+      this.app.throw(404, 'commerce payment session not found');
+    const refundOperation = await this.$scope.pay.model.refundOperation.getByIdForUpdate(
+      refundAttempt.refundOperationId,
+    );
+    if (!refundOperation) this.app.throw(404, 'refund operation not found');
+    const paymentSession = await this.$scope.pay.model.paymentSession.getByIdForUpdate(
+      paymentAttempt.paymentSessionId,
+    );
+    if (!paymentSession) this.app.throw(404, 'payment session not found');
+    const providerOperation = await this.$scope.pay.model.providerOperation.getForUpdate({
+      refundOperationId: refundOperation.id,
+      kind: 'refund',
+    });
+    if (!providerOperation) this.app.throw(404, 'refund provider operation not found');
+    const unresolvedReconciliations =
+      await this.$scope.pay.model.providerOperationRecoveryAudit.select({
+        where: {
+          providerOperationId: providerOperation.id,
+          action: 'reconcile',
+          resolution: 'unresolved',
+        },
+        limit: 1,
+      });
+    if (
+      order.state !== 'refund_approved' ||
+      refundRequest.state !== 'approved' ||
+      refundAttempt.state !== 'created' ||
+      String(refundAttempt.orderId) !== String(order.id) ||
+      String(refundAttempt.refundRequestId) !== String(refundRequest.id) ||
+      String(refundOperation.paymentSessionId) !== String(paymentSession.id) ||
+      String(providerOperation.paymentSessionId) !== String(paymentSession.id) ||
+      refundOperation.businessReference !== String(refundAttempt.id) ||
+      refundAttempt.amountCents !== refundRequest.amountCents ||
+      refundAttempt.currency !== refundRequest.currency ||
+      refundOperation.amountMinor !== refundAttempt.amountCents ||
+      refundOperation.currency !== refundAttempt.currency ||
+      paymentSession.currency !== refundOperation.currency ||
+      !paymentSession.providerCaptureId
+    ) {
+      this.app.throw(409, 'refund recovery linkage conflicts with immutable payment facts');
+    }
+    return {
+      order,
+      refundRequest,
+      refundAttempt,
+      paymentAttempt,
+      paymentSession,
+      refundOperation,
+      providerOperation,
+      hasUnresolvedReconciliation: unresolvedReconciliations.length > 0,
+    };
+  }
+
+  private _refundRecoveryView(
+    linked: Awaited<ReturnType<typeof this.refundRecoveryLinkage>>,
+  ): DtoRefundRecoveryView {
+    const {
+      order,
+      refundRequest,
+      refundAttempt,
+      paymentSession,
+      refundOperation,
+      providerOperation,
+      hasUnresolvedReconciliation,
+    } = linked;
+    const canQuery = Boolean(
+      refundOperation.providerRefundId && providerOperation.state !== 'succeeded',
+    );
+    const canRetry =
+      !refundOperation.providerRefundId &&
+      providerOperation.state === 'reconciliation_required' &&
+      providerOperation.errorCode === 'refund_submission_outcome_unknown' &&
+      Boolean(providerOperation.submittedAt) &&
+      !providerOperation.recoveryRetryGrantedAt &&
+      hasUnresolvedReconciliation &&
+      providerOperation.submittedAt!.getTime() + 45 * 24 * 60 * 60 * 1_000 >= Date.now();
+    const canReconcile =
+      !refundOperation.providerRefundId &&
+      providerOperation.state === 'reconciliation_required' &&
+      providerOperation.errorCode === 'refund_submission_outcome_unknown' &&
+      Boolean(providerOperation.submittedAt) &&
+      !hasUnresolvedReconciliation;
+    const recoveryDisposition = canQuery
+      ? 'query_only'
+      : canRetry
+        ? 'retry_same_key'
+        : canReconcile
+          ? 'reconcile_only'
+          : 'none';
+    const recoveryMessage =
+      recoveryDisposition === 'query_only'
+        ? 'A verified provider refund identifier is available. Reconcile without resubmitting.'
+        : recoveryDisposition === 'reconcile_only'
+          ? 'Provider refund outcome is unknown. Record reconciliation before considering a retry.'
+          : recoveryDisposition === 'retry_same_key'
+            ? 'Reconciliation was unresolved. A single acknowledged retry may reuse the original provider request.'
+            : 'No provider refund submission is available. Do not create or manually declare a replacement refund.';
+    return {
+      orderId: order.id,
+      refundRequestId: refundRequest.id,
+      refundAttemptId: refundAttempt.id,
+      refundOperationId: refundOperation.id,
+      providerOperationId: providerOperation.id,
+      providerName: paymentSession.providerName,
+      environment: paymentSession.environment,
+      refundOperationState: refundOperation.state,
+      providerOperationState: providerOperation.state,
+      attemptCount: providerOperation.attemptCount,
+      providerRefundId: refundOperation.providerRefundId,
+      errorCode: providerOperation.errorCode,
+      errorSummary: providerOperation.errorSummary,
+      submittedAt: providerOperation.submittedAt,
+      finalizedAt: refundOperation.finalizedAt ?? providerOperation.finalizedAt,
+      recoveryDisposition,
+      recoveryMessage,
+    };
+  }
+
   private async _prepareRefundExecution(orderId: TableIdentity) {
     const order = await this.scope.model.order.getByIdForUpdate(orderId);
     if (!order) this.app.throw(404, 'order not found');
@@ -758,6 +938,9 @@ export class ServiceOrder extends BeanBase {
     if (order.state !== 'refund_approved' || attempt.state !== 'created') {
       this.app.throw(409, 'refund is not available for execution');
     }
+    if (attempt.refundOperationId) {
+      this.app.throw(409, 'refund submission requires recovery inspection');
+    }
     return attempt;
   }
 
@@ -939,14 +1122,43 @@ export class ServiceOrder extends BeanBase {
   }
 
   async select(params?: IQueryParams<ModelOrder>): Promise<DtoOrderSelectRes> {
-    return await this.scope.model.order.selectAndCount({
+    const result = await this.scope.model.order.selectAndCount({
       ...params,
+      columns: ['id', 'state', 'payableTotalCents', 'reservationExpiresAt', 'createdAt'],
       orders: params?.orders ?? [['id', 'desc']],
     });
+    return result as DtoOrderSelectRes;
   }
 
   async view(id: TableIdentity): Promise<DtoOrderView | undefined> {
-    return await this.scope.model.order.getById(id, { include: { shipment: true } });
+    const order = await this.scope.model.order.getById(id, {
+      columns: [
+        'id',
+        'state',
+        'currency',
+        'eligibleSubtotalCents',
+        'discountCents',
+        'payableTotalCents',
+        'reservationExpiresAt',
+        'addressSnapshot',
+        'couponSnapshot',
+        'createdAt',
+        'updatedAt',
+      ],
+      include: { shipment: true, lines: true },
+    });
+    if (!order) return;
+    const lines: DtoOrderAdminLineResItem[] = order.lines.map(line => ({
+      id: line.id,
+      skuCodeSnapshot: line.skuCodeSnapshot,
+      titleSnapshot: line.titleSnapshot,
+      skuAttributesSnapshot: line.skuAttributesSnapshot,
+      unitPriceCents: line.unitPriceCents,
+      quantity: line.quantity,
+      eligibleSubtotalCents: line.eligibleSubtotalCents,
+      lineTotalCents: line.lineTotalCents,
+    }));
+    return { ...order, lines } as DtoOrderView;
   }
 
   async mine(params?: IQueryParams<ModelOrder>): Promise<DtoOrderMineRes> {

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

@@ -11,10 +11,33 @@ import type { ModelStockAudit } from '../model/stockAudit.ts';
 @Service()
 export class ServiceStockAudit extends BeanBase {
   async select(params?: IQueryParams<ModelStockAudit>): Promise<DtoStockAuditSelectRes> {
-    return await this.scope.model.stockAudit.selectAndCount(params);
+    return await this.scope.model.stockAudit.selectAndCount({
+      ...params,
+      columns: ['id', 'skuId', 'operation', 'delta', 'createdAt'],
+    });
   }
 
   async view(id: TableIdentity): Promise<DtoStockAuditView | undefined> {
-    return await this.scope.model.stockAudit.getById(id);
+    return await this.scope.model.stockAudit.getById(id, {
+      columns: [
+        'id',
+        'stockBalanceId',
+        'skuId',
+        'stockReservationId',
+        'actorId',
+        'operation',
+        'delta',
+        'reason',
+        'correlationId',
+        'priorOnHand',
+        'priorReserved',
+        'priorAvailable',
+        'onHand',
+        'reserved',
+        'available',
+        'createdAt',
+        'updatedAt',
+      ],
+    });
   }
 }

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

@@ -34,18 +34,29 @@ const serializationRetryOptions = {
   minTimeout: 0,
   maxTimeout: 0,
   randomize: false,
-  errorCodes: ['40001', 'ER_LOCK_DEADLOCK', 'ER_LOCK_WAIT_TIMEOUT'],
+  errorCodes: [
+    '40001',
+    'ER_LOCK_DEADLOCK',
+    'ER_LOCK_WAIT_TIMEOUT',
+    'SQLITE_BUSY',
+    'SQLITE_BUSY_SNAPSHOT',
+  ],
   ownerOnly: true,
 };
 
 @Service()
 export class ServiceStockBalance extends BeanBase {
   async select(params?: IQueryParams<ModelStockBalance>): Promise<DtoStockBalanceSelectRes> {
-    return await this.scope.model.stockBalance.selectAndCount(params);
+    return await this.scope.model.stockBalance.selectAndCount({
+      ...params,
+      columns: ['id', 'skuId', 'onHand', 'reserved', 'available'],
+    });
   }
 
   async view(id: TableIdentity): Promise<DtoStockBalanceView | undefined> {
-    return await this.scope.model.stockBalance.getById(id);
+    return await this.scope.model.stockBalance.getById(id, {
+      columns: ['id', 'skuId', 'onHand', 'reserved', 'available', 'createdAt', 'updatedAt'],
+    });
   }
 
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })

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

@@ -426,15 +426,15 @@ describe('checkoutReservation.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: `checkout-snapshot-sku-${suffix}`,
             priceCents: 1299,
             attributes: [{ name: 'Color', value: 'Black' }],
             lifecycle: 'active',
-          },
-        });
+          })
+        ).id as number;
         fixture.balanceId = (
           await app.scope('commerce-trade').service.stockBalance.adjustStock({
             skuId: fixture.skuId,