cabloy 5.1.113 → 5.1.114

package/vona/src/suite/a-commerce/modules/commerce-member/test/addressOwnership.test.ts

@@ -6,11 +6,16 @@ import type {
 
 import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
 const actionPath = '/commerce/member/address';
 
+function createTestId() {
+  return randomUUID().slice(0, 12);
+}
+
 function createAddress(suffix: string): DtoAddressCreate {
   return {
     recipientName: `Recipient ${suffix}`,
@@ -60,7 +65,7 @@ describe('address.test.ts', () => {
 
   it('derives ownership from the authenticated customer and scopes every action', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const suffix = createTestId();
       const customerA = await registerAndSignin(`address-a-${suffix}`);
       const customerB = await registerAndSignin(`address-b-${suffix}`);
       const addressData = createAddress(suffix);

package/vona/src/suite/a-commerce/modules/commerce-payment/package.json

@@ -47,6 +47,7 @@
   "vonaModule": {
     "dependencies": {
       "a-vona": "5.0.0"
-    }
+    },
+    "fileVersion": 1
   }
 }

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

@@ -1,4 +1,229 @@
 // eslint-disable
+import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { TableIdentity } from 'table-identity';
+/** entity: begin */
+export * from '../entity/paymentAttempt.tsx';
+import type { IEntityOptionsPaymentAttempt } from '../entity/paymentAttempt.tsx';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IEntityRecord {
+      'commerce-payment:paymentAttempt': IEntityOptionsPaymentAttempt;
+    }
+
+  
+}
+declare module 'vona-module-commerce-payment' {
+   
+}
+/** entity: end */
+/** entity: begin */
+import type { EntityPaymentAttempt } from '../entity/paymentAttempt.tsx';
+export interface IModuleEntity {
+  'paymentAttempt': EntityPaymentAttemptMeta;
+}
+/** entity: end */
+/** entity: begin */
+export type EntityPaymentAttemptTableName = 'commercePaymentAttempt';
+export type EntityPaymentAttemptMeta=TypeEntityMeta<EntityPaymentAttempt,EntityPaymentAttemptTableName>;
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    'commercePaymentAttempt': EntityPaymentAttemptMeta;
+  }
+}
+declare module 'vona-module-commerce-payment' {
+  
+    export interface IEntityOptionsPaymentAttempt {
+      fields?: TypeEntityOptionsFields<EntityPaymentAttempt, IEntityOptionsPaymentAttempt[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** entity: end */
+/** model: begin */
+export * from '../model/paymentAttempt.ts';
+import type { IModelOptionsPaymentAttempt } from '../model/paymentAttempt.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+  
+    export interface IModelRecord {
+      'commerce-payment:paymentAttempt': IModelOptionsPaymentAttempt;
+    }
+
+  
+}
+declare module 'vona-module-commerce-payment' {
+  
+        export interface ModelPaymentAttempt {
+          /** @internal */
+          get scope(): ScopeModuleCommercePayment;
+        }
+
+          export interface ModelPaymentAttempt {
+            get $beanFullName(): 'commerce-payment.model.paymentAttempt';
+            get $onionName(): 'commerce-payment:paymentAttempt';
+            get $onionOptions(): IModelOptionsPaymentAttempt;
+          } 
+}
+/** model: end */
+/** model: begin */
+import type { ModelPaymentAttempt } from '../model/paymentAttempt.ts';
+export interface IModuleModel {
+  'paymentAttempt': ModelPaymentAttempt;
+}
+/** model: end */
+/** model: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'commerce-payment.model.paymentAttempt': ModelPaymentAttempt;
+  }
+}
+/** model: end */
+/** model: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelIncrementParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-commerce-payment' {
+  
+  export interface ModelPaymentAttempt {
+      [SymbolKeyEntity]: EntityPaymentAttempt;
+      [SymbolKeyEntityMeta]: EntityPaymentAttemptMeta;
+      [SymbolKeyModelOptions]: IModelOptionsPaymentAttempt;
+      get<T extends IModelGetOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(where: TypeModelWhere<EntityPaymentAttempt>, options?: T): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(where: TypeModelWhere<EntityPaymentAttempt>, options?: T): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityPaymentAttempt, ModelPaymentAttempt, T>>;
+      select<T extends IModelSelectParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T>[]>;
+      insert<T extends IModelInsertOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(data?: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(items: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(data: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(items: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(where?: TypeModelWhere<EntityPaymentAttempt>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(data?: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(items: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>[]>;
+      count<T extends IModelSelectCountParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityPaymentAttempt,ModelPaymentAttempt,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityPaymentAttempt, T>[]>;
+      getById<T extends IModelGetOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityPaymentAttempt, ModelPaymentAttempt, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPaymentAttempt,ModelPaymentAttempt, T>>;
+deleteById<T extends IModelDeleteOptions<EntityPaymentAttempt,ModelPaymentAttempt>>(id: TableIdentity, options?: T): Promise<void>;
+    }
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    'commerce-payment:paymentAttempt': ModelPaymentAttempt;
+  }
+}
+/** model: end */
+/** service: begin */
+export * from '../service/paymentAttempt.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'commerce-payment:paymentAttempt': never;
+    }
+
+  
+}
+declare module 'vona-module-commerce-payment' {
+  
+        export interface ServicePaymentAttempt {
+          /** @internal */
+          get scope(): ScopeModuleCommercePayment;
+        }
+
+          export interface ServicePaymentAttempt {
+            get $beanFullName(): 'commerce-payment.service.paymentAttempt';
+            get $onionName(): 'commerce-payment:paymentAttempt';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServicePaymentAttempt } from '../service/paymentAttempt.ts';
+export interface IModuleService {
+  'paymentAttempt': ServicePaymentAttempt;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'commerce-payment.service.paymentAttempt': ServicePaymentAttempt;
+  }
+}
+/** service: end */
+/** meta: begin */
+export * from '../bean/meta.index.ts';
+export * from '../bean/meta.version.ts';
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+import 'vona-module-a-meta';
+declare module 'vona-module-a-meta' {
+  
+    export interface IMetaRecord {
+      'commerce-payment:index': IMetaOptionsIndex;
+'commerce-payment:version': never;
+    }
+
+  
+}
+declare module 'vona-module-commerce-payment' {
+  
+        export interface MetaIndex {
+          /** @internal */
+          get scope(): ScopeModuleCommercePayment;
+        }
+
+          export interface MetaIndex {
+            get $beanFullName(): 'commerce-payment.meta.index';
+            get $onionName(): 'commerce-payment:index';
+            get $onionOptions(): IMetaOptionsIndex;
+          }
+
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleCommercePayment;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'commerce-payment.meta.version';
+            get $onionName(): 'commerce-payment:version';
+            
+          } 
+}
+/** meta: end */
+/** dto: begin */
+export * from '../dto/paymentAttemptView.tsx';
+import type { IDtoOptionsPaymentAttemptView } from '../dto/paymentAttemptView.tsx';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+  
+    export interface IDtoRecord {
+      'commerce-payment:paymentAttemptView': IDtoOptionsPaymentAttemptView;
+    }
+
+  
+}
+declare module 'vona-module-commerce-payment' {
+   
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoPaymentAttemptView } from '../dto/paymentAttemptView.tsx';
+declare module 'vona-module-commerce-payment' {
+  
+    export interface IDtoOptionsPaymentAttemptView {
+      fields?: TypeEntityOptionsFields<DtoPaymentAttemptView, IDtoOptionsPaymentAttemptView[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
 /** scope: begin */
 import { BeanScopeBase, type BeanScopeUtil } from 'vona';
 import { Scope } from 'vona-module-a-bean';
@@ -8,6 +233,9 @@ export class ScopeModuleCommercePayment extends BeanScopeBase {}
 
 export interface ScopeModuleCommercePayment {
   util: BeanScopeUtil;
+entity: IModuleEntity;
+model: IModuleModel;
+service: IModuleService;
 }
 
 import 'vona';

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

@@ -0,0 +1,15 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+import { $tableColumns } from 'vona-module-a-ormutils';
+
+@Meta<IMetaOptionsIndex>({
+  indexes: {
+    ...$tableColumns('commercePaymentAttempt', 'orderId'),
+    ...$tableColumns('commercePaymentAttempt', 'userId'),
+    ...$tableColumns('commercePaymentAttempt', 'state'),
+    ...$tableColumns('commercePaymentAttempt', 'correlationId'),
+  },
+})
+export class MetaIndex extends BeanBase {}

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

@@ -0,0 +1,35 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version !== 1) return;
+
+    const entityPaymentAttempt = this.scope.entity.paymentAttempt;
+    await this.bean.model.createTable(entityPaymentAttempt.$table, table => {
+      table.comment(entityPaymentAttempt.$comment.$table);
+      table.basicFields();
+      table
+        .tableIdentity(entityPaymentAttempt.orderId)
+        .comment(entityPaymentAttempt.$comment.orderId);
+      table.userId(entityPaymentAttempt.userId).comment(entityPaymentAttempt.$comment.userId);
+      table.string(entityPaymentAttempt.state, 20).comment(entityPaymentAttempt.$comment.state);
+      table
+        .string(entityPaymentAttempt.currency, 3)
+        .comment(entityPaymentAttempt.$comment.currency);
+      table
+        .integer(entityPaymentAttempt.amountCents)
+        .comment(entityPaymentAttempt.$comment.amountCents);
+      table
+        .string(entityPaymentAttempt.correlationId, 100)
+        .comment(entityPaymentAttempt.$comment.correlationId);
+      table
+        .dateTime(entityPaymentAttempt.cancelledAt)
+        .nullable()
+        .comment(entityPaymentAttempt.$comment.cancelledAt);
+    });
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/dto/paymentAttemptView.tsx

@@ -0,0 +1,26 @@
+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 IDtoOptionsPaymentAttemptView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPaymentAttemptView>()
+export class DtoPaymentAttemptView {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(z.enum(['created', 'cancelled']))
+  state: 'created' | 'cancelled';
+
+  @Api.field(z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(z.number().int().nonnegative())
+  amountCents: number;
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/entity/paymentAttempt.tsx

@@ -0,0 +1,34 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+
+export type TypePaymentAttemptState = 'created' | 'cancelled';
+
+export interface IEntityOptionsPaymentAttempt extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPaymentAttempt>('commercePaymentAttempt')
+export class EntityPaymentAttempt extends EntityBase {
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(z.enum(['created', 'cancelled']))
+  state: TypePaymentAttemptState;
+
+  @Api.field(z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(z.number().int().nonnegative())
+  amountCents: number;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  correlationId: string;
+
+  @Api.field(v.optional())
+  cancelledAt?: Date;
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/model/paymentAttempt.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityPaymentAttempt } from '../entity/paymentAttempt.tsx';
+
+export interface IModelOptionsPaymentAttempt extends IDecoratorModelOptions<EntityPaymentAttempt> {}
+
+@Model<IModelOptionsPaymentAttempt>({ entity: EntityPaymentAttempt })
+export class ModelPaymentAttempt extends BeanModelBase<EntityPaymentAttempt> {}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/service/paymentAttempt.ts

@@ -0,0 +1,41 @@
+import type { TableIdentity } from 'table-identity';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { EntityPaymentAttempt } from '../entity/paymentAttempt.tsx';
+
+export interface IPaymentAttemptCreateCommand {
+  orderId: TableIdentity;
+  userId: TableIdentity;
+  currency: 'USD';
+  amountCents: number;
+  correlationId: string;
+}
+
+@Service()
+export class ServicePaymentAttempt extends BeanBase {
+  async create(command: IPaymentAttemptCreateCommand): Promise<EntityPaymentAttempt> {
+    return await this.scope.model.paymentAttempt.insert({
+      orderId: command.orderId,
+      userId: command.userId,
+      state: 'created',
+      currency: command.currency,
+      amountCents: command.amountCents,
+      correlationId: command.correlationId,
+    });
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async cancel(orderId: TableIdentity): Promise<EntityPaymentAttempt | undefined> {
+    const attempt = await this.scope.model.paymentAttempt.getForUpdate({ orderId });
+    if (!attempt || attempt.state === 'cancelled') return attempt;
+    const cancelledAt = new Date();
+    await this.scope.model.paymentAttempt.updateById(attempt.id, {
+      state: 'cancelled',
+      cancelledAt,
+    });
+    return { ...attempt, state: 'cancelled', cancelledAt };
+  }
+}

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

@@ -0,0 +1,33 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('paymentAttempt.test.ts', { concurrency: false }, () => {
+  it('creates and internally cancels an attempt exactly once', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scope = app.scope('commerce-payment');
+      const suffix = randomUUID().slice(0, 12);
+      let attemptId: number | undefined;
+      try {
+        const user = await app.bean.user.register({ name: `payment-${suffix}` }, true);
+        const created = await scope.service.paymentAttempt.create({
+          orderId: 900_001,
+          userId: user.id,
+          currency: 'USD',
+          amountCents: 1299,
+          correlationId: `payment-${suffix}`,
+        });
+        attemptId = created.id as number;
+        assert.equal(created.state, 'created');
+        const cancelled = await scope.service.paymentAttempt.cancel(created.orderId);
+        assert.equal(cancelled?.state, 'cancelled');
+        const replay = await scope.service.paymentAttempt.cancel(created.orderId);
+        assert.equal(replay?.id, created.id);
+        assert.equal(replay?.state, 'cancelled');
+      } finally {
+        if (attemptId !== undefined) await scope.model.paymentAttempt.delete({ id: attemptId });
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-promotion/package.json

@@ -46,7 +46,9 @@
   "title": "commerce-promotion",
   "vonaModule": {
     "dependencies": {
-      "a-vona": "5.0.0"
-    }
+      "a-vona": "5.0.0",
+      "commerce-siteadmin": "5.0.0"
+    },
+    "fileVersion": 1
   }
 }