cabloy 5.1.112 → 5.1.114

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

@@ -377,6 +377,7 @@ export * from '../dto/productSelectRes.tsx';
 export * from '../dto/productSelectResItem.tsx';
 export * from '../dto/productUpdate.tsx';
 export * from '../dto/productView.tsx';
+export * from '../dto/skuAttribute.tsx';
 export * from '../dto/skuCreate.tsx';
 export * from '../dto/skuSelectReq.tsx';
 export * from '../dto/skuSelectRes.tsx';
@@ -399,6 +400,7 @@ import type { IDtoOptionsProductSelectRes } from '../dto/productSelectRes.tsx';
 import type { IDtoOptionsProductSelectResItem } from '../dto/productSelectResItem.tsx';
 import type { IDtoOptionsProductUpdate } from '../dto/productUpdate.tsx';
 import type { IDtoOptionsProductView } from '../dto/productView.tsx';
+import type { IDtoOptionsSkuAttribute } from '../dto/skuAttribute.tsx';
 import type { IDtoOptionsSkuCreate } from '../dto/skuCreate.tsx';
 import type { IDtoOptionsSkuSelectReq } from '../dto/skuSelectReq.tsx';
 import type { IDtoOptionsSkuSelectRes } from '../dto/skuSelectRes.tsx';
@@ -425,6 +427,7 @@ declare module 'vona-module-a-web' {
 'commerce-catalog:productSelectResItem': IDtoOptionsProductSelectResItem;
 'commerce-catalog:productUpdate': IDtoOptionsProductUpdate;
 'commerce-catalog:productView': IDtoOptionsProductView;
+'commerce-catalog:skuAttribute': IDtoOptionsSkuAttribute;
 'commerce-catalog:skuCreate': IDtoOptionsSkuCreate;
 'commerce-catalog:skuSelectReq': IDtoOptionsSkuSelectReq;
 'commerce-catalog:skuSelectRes': IDtoOptionsSkuSelectRes;
@@ -456,6 +459,7 @@ import type { DtoProductSelectRes } from '../dto/productSelectRes.tsx';
 import type { DtoProductSelectResItem } from '../dto/productSelectResItem.tsx';
 import type { DtoProductUpdate } from '../dto/productUpdate.tsx';
 import type { DtoProductView } from '../dto/productView.tsx';
+import type { DtoSkuAttribute } from '../dto/skuAttribute.tsx';
 import type { DtoSkuCreate } from '../dto/skuCreate.tsx';
 import type { DtoSkuSelectReq } from '../dto/skuSelectReq.tsx';
 import type { DtoSkuSelectRes } from '../dto/skuSelectRes.tsx';
@@ -528,6 +532,10 @@ declare module 'vona-module-commerce-catalog' {
       fields?: TypeEntityOptionsFields<DtoProductView, IDtoOptionsProductView[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsSkuAttribute {
+      fields?: TypeEntityOptionsFields<DtoSkuAttribute, IDtoOptionsSkuAttribute[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsSkuCreate {
       fields?: TypeEntityOptionsFields<DtoSkuCreate, IDtoOptionsSkuCreate[TypeSymbolKeyFieldsMore]>;
     }

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

@@ -42,6 +42,7 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
         table.tableIdentity(entitySku.productId).comment(entitySku.$comment.productId);
         table.string(entitySku.code, 100).comment(entitySku.$comment.code);
         table.integer(entitySku.priceCents).comment(entitySku.$comment.priceCents);
+        table.json(entitySku.attributes).comment(entitySku.$comment.attributes);
         table.string(entitySku.lifecycle, 20).comment(entitySku.$comment.lifecycle);
         table.index([entitySku.productId], `idx_${entitySku.$table}_productId`);
         table.index([entitySku.lifecycle], `idx_${entitySku.$table}_lifecycle`);

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/config/locale/en-us.ts

@@ -10,6 +10,9 @@ export default {
   ProductTitle: 'Product title',
   Published: 'Published',
   Sku: 'SKU',
+  SkuAttributeName: 'SKU attribute name',
+  SkuAttributeValue: 'SKU attribute value',
+  SkuAttributes: 'SKU attributes',
   SkuCode: 'SKU code',
   SkuLifecycle: 'SKU lifecycle',
   SkuLifecycleActive: 'Active',

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/config/locale/zh-cn.ts

@@ -10,6 +10,9 @@ export default {
   ProductTitle: '商品标题',
   Published: '已发布',
   Sku: 'SKU',
+  SkuAttributeName: 'SKU 属性名',
+  SkuAttributeValue: 'SKU 属性值',
+  SkuAttributes: 'SKU 属性',
   SkuCode: 'SKU 编码',
   SkuLifecycle: 'SKU 生命周期',
   SkuLifecycleActive: '已启用',

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/dto/skuAttribute.tsx

@@ -0,0 +1,17 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IDtoOptionsSkuAttribute extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSkuAttribute>()
+export class DtoSkuAttribute {
+  @Api.field(v.title($locale('SkuAttributeName')), v.required(), v.min(1), v.max(100))
+  name: string;
+
+  @Api.field(v.title($locale('SkuAttributeValue')), v.required(), v.min(1), v.max(255))
+  value: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/entity/sku.tsx

@@ -7,6 +7,7 @@ import z from 'zod';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { $locale } from '../.metadata/locales.ts';
+import { DtoSkuAttribute } from '../dto/skuAttribute.tsx';
 
 export const skuLifecycleItems = [
   { value: 'draft', title: $locale('SkuLifecycleDraft') },
@@ -56,10 +57,18 @@ export class EntitySku extends EntityBase {
   )
   priceCents: number;
 
+  @Api.field(
+    v.title($locale('SkuAttributes')),
+    v.default([]),
+    v.array(v.object(DtoSkuAttribute)),
+    ZovaRender.order(4),
+  )
+  attributes: DtoSkuAttribute[];
+
   @Api.field(
     v.title($locale('SkuLifecycle')),
     v.default('draft'),
-    ZovaRender.order(4),
+    ZovaRender.order(5),
     z.enum(['draft', 'active', 'inactive', 'archived']),
   )
   lifecycle: 'draft' | 'active' | 'inactive' | 'archived';

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

@@ -1,3 +1,4 @@
+import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
@@ -355,4 +356,237 @@ describe('catalog.test.ts', () => {
       { instanceName: 'shareTest' as any },
     );
   });
+
+  it('treats foreign operator catalogue resources as absent', async () => {
+    const prefix = `__catalog-foreign-${Date.now()}__`;
+    let defaultCatalog!: Awaited<ReturnType<typeof createCatalog>>;
+    await app.bean.executor.mockCtx(async () => {
+      defaultCatalog = await createCatalog(prefix, 'active');
+    });
+
+    await app.bean.executor.mockCtx(
+      async () => {
+        await app.bean.passport.signinMock();
+        try {
+          const resources = [
+            ['category', defaultCatalog.categoryId, { name: 'foreign category', published: false }],
+            [
+              'product',
+              defaultCatalog.productId,
+              {
+                categoryId: defaultCatalog.categoryId,
+                title: 'foreign product',
+                published: false,
+              },
+            ],
+            [
+              'sku',
+              defaultCatalog.skuId,
+              {
+                productId: defaultCatalog.productId,
+                code: 'foreign-sku',
+                priceCents: 100,
+                lifecycle: 'inactive',
+              },
+            ],
+          ] as const;
+          for (const [resource, id, body] of resources) {
+            assert.equal(
+              await app.bean.executor.performAction('get', `/commerce/catalog/${resource}/:id`, {
+                params: { id },
+              }),
+              undefined,
+            );
+            const selected = await app.bean.executor.performAction(
+              'get',
+              `/commerce/catalog/${resource}`,
+            );
+            assert.equal(
+              selected.list.some((item: { id: unknown }) => String(item.id) === String(id)),
+              false,
+            );
+            const update = () =>
+              app.bean.executor.performAction('patch', `/commerce/catalog/${resource}/:id`, {
+                params: { id },
+                body,
+              });
+            if (resource === 'category') {
+              assert.equal(await update(), null);
+            } else {
+              await assert.rejects(update);
+            }
+            assert.equal(
+              await app.bean.executor.performAction('delete', `/commerce/catalog/${resource}/:id`, {
+                params: { id },
+              }),
+              null,
+            );
+          }
+        } finally {
+          await app.bean.passport.signout();
+        }
+      },
+      { instanceName: 'shareTest' as any },
+    );
+
+    await app.bean.executor.mockCtx(async () => {
+      const category = await app
+        .scope('commerce-catalog')
+        .model.category.getById(defaultCatalog.categoryId);
+      const product = await app
+        .scope('commerce-catalog')
+        .model.product.getById(defaultCatalog.productId);
+      const sku = await app.scope('commerce-catalog').model.sku.getById(defaultCatalog.skuId);
+      assert.equal(category?.name, `${prefix} category`);
+      assert.equal(product?.title, `${prefix} product`);
+      assert.equal(sku?.code, `${prefix}-sku`);
+    });
+  });
+
+  it('rejects foreign catalogue relation identifiers without local writes', async () => {
+    const suffix = `${Date.now()}`;
+    let foreignCatalog!: Awaited<ReturnType<typeof createCatalog>>;
+    await app.bean.executor.mockCtx(
+      async () => {
+        foreignCatalog = await createCatalog(`crf-${suffix}`, 'active');
+      },
+      { instanceName: 'shareTest' as any },
+    );
+
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        const parentCategoryId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/catalog/category',
+          { body: { name: `relation-parent-${suffix}`, published: true } },
+        );
+        const categoryId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/catalog/category',
+          {
+            body: {
+              name: `relation-category-${suffix}`,
+              parentId: parentCategoryId,
+              published: true,
+            },
+          },
+        );
+        const productId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/catalog/product',
+          {
+            body: {
+              categoryId,
+              title: `relation-product-${suffix}`,
+              published: true,
+            },
+          },
+        );
+        const skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+          body: {
+            productId,
+            code: `relation-sku-${suffix}`,
+            priceCents: 100,
+            lifecycle: 'draft',
+          },
+        });
+        const operations = [
+          () =>
+            app.bean.executor.performAction('post', '/commerce/catalog/category', {
+              body: {
+                name: `foreign-parent-category-${suffix}`,
+                parentId: foreignCatalog.categoryId,
+                published: true,
+              },
+            }),
+          () =>
+            app.bean.executor.performAction('patch', '/commerce/catalog/category/:id', {
+              params: { id: categoryId },
+              body: {
+                name: `relation-category-updated-${suffix}`,
+                parentId: foreignCatalog.categoryId,
+                published: false,
+              },
+            }),
+          () =>
+            app.bean.executor.performAction('post', '/commerce/catalog/product', {
+              body: {
+                categoryId: foreignCatalog.categoryId,
+                title: `foreign-category-product-${suffix}`,
+                published: true,
+              },
+            }),
+          () =>
+            app.bean.executor.performAction('patch', '/commerce/catalog/product/:id', {
+              params: { id: productId },
+              body: {
+                categoryId: foreignCatalog.categoryId,
+                title: `relation-product-updated-${suffix}`,
+                published: false,
+              },
+            }),
+          () =>
+            app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+              body: {
+                productId: foreignCatalog.productId,
+                code: `foreign-product-sku-${suffix}`,
+                priceCents: 100,
+                lifecycle: 'draft',
+              },
+            }),
+          () =>
+            app.bean.executor.performAction('patch', '/commerce/catalog/sku/:id', {
+              params: { id: skuId },
+              body: {
+                productId: foreignCatalog.productId,
+                code: `relation-sku-updated-${suffix}`,
+                priceCents: 200,
+                lifecycle: 'active',
+              },
+            }),
+        ];
+        for (const operation of operations) {
+          const [_, err] = await catchError(operation);
+          assert.equal(err?.code, 404);
+        }
+
+        const category = await app.scope('commerce-catalog').model.category.getById(categoryId);
+        const product = await app.scope('commerce-catalog').model.product.getById(productId);
+        const sku = await app.scope('commerce-catalog').model.sku.getById(skuId);
+        assert.deepEqual(
+          [category?.name, category?.parentId, category?.published],
+          [`relation-category-${suffix}`, parentCategoryId, true],
+        );
+        assert.deepEqual(
+          [product?.categoryId, product?.title, product?.published],
+          [categoryId, `relation-product-${suffix}`, true],
+        );
+        assert.deepEqual(
+          [sku?.productId, sku?.code, sku?.priceCents, sku?.lifecycle],
+          [productId, `relation-sku-${suffix}`, 100, 'draft'],
+        );
+        assert.equal(
+          await app.scope('commerce-catalog').model.category.get({
+            name: `foreign-parent-category-${suffix}`,
+          }),
+          undefined,
+        );
+        assert.equal(
+          await app.scope('commerce-catalog').model.product.get({
+            title: `foreign-category-product-${suffix}`,
+          }),
+          undefined,
+        );
+        assert.equal(
+          await app.scope('commerce-catalog').model.sku.get({
+            code: `foreign-product-sku-${suffix}`,
+          }),
+          undefined,
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
 });

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 {}