cabloy 5.1.111 → 5.1.113

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

@@ -1,6 +1,337 @@
 // eslint-disable
+import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields,TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TableIdentity } from 'table-identity';
+/** entity: begin */
+export * from '../entity/address.tsx';
+import type { IEntityOptionsAddress } from '../entity/address.tsx';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+
+    export interface IEntityRecord {
+      'commerce-member:address': IEntityOptionsAddress;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+}
+/** entity: end */
+/** entity: begin */
+import type { EntityAddress } from '../entity/address.tsx';
+export interface IModuleEntity {
+  'address': EntityAddressMeta;
+}
+/** entity: end */
+/** entity: begin */
+export type EntityAddressTableName = 'commerceMemberAddress';
+export type EntityAddressMeta=TypeEntityMeta<EntityAddress,EntityAddressTableName>;
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    'commerceMemberAddress': EntityAddressMeta;
+  }
+}
+declare module 'vona-module-commerce-member' {
+
+    export interface IEntityOptionsAddress {
+      fields?: TypeEntityOptionsFields<EntityAddress, IEntityOptionsAddress[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** entity: end */
+/** model: begin */
+export * from '../model/address.ts';
+import type { IModelOptionsAddress } from '../model/address.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
+
+    export interface IModelRecord {
+      'commerce-member:address': IModelOptionsAddress;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+        export interface ModelAddress {
+          /** @internal */
+          get scope(): ScopeModuleCommerceMember;
+        }
+
+          export interface ModelAddress {
+            get $beanFullName(): 'commerce-member.model.address';
+            get $onionName(): 'commerce-member:address';
+            get $onionOptions(): IModelOptionsAddress;
+          }
+}
+/** model: end */
+/** model: begin */
+import type { ModelAddress } from '../model/address.ts';
+export interface IModuleModel {
+  'address': ModelAddress;
+}
+/** model: end */
+/** model: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'commerce-member.model.address': ModelAddress;
+  }
+}
+/** 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-member' {
+
+  export interface ModelAddress {
+      [SymbolKeyEntity]: EntityAddress;
+      [SymbolKeyEntityMeta]: EntityAddressMeta;
+      [SymbolKeyModelOptions]: IModelOptionsAddress;
+      get<T extends IModelGetOptions<EntityAddress,ModelAddress>>(where: TypeModelWhere<EntityAddress>, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityAddress,ModelAddress>>(where: TypeModelWhere<EntityAddress>, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityAddress,ModelAddress>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+      mget<T extends IModelGetOptions<EntityAddress,ModelAddress>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityAddress, ModelAddress, T>>;
+      select<T extends IModelSelectParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T>[]>;
+      insert<T extends IModelInsertOptions<EntityAddress,ModelAddress>>(data?: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>, options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T, true>>;
+      insertBulk<T extends IModelInsertOptions<EntityAddress,ModelAddress>>(items: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T, true>[]>;
+      update<T extends IModelUpdateOptions<EntityAddress,ModelAddress>>(data: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>, options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T>>;
+      updateBulk<T extends IModelUpdateOptions<EntityAddress,ModelAddress>>(items: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T>[]>;
+      delete<T extends IModelDeleteOptions<EntityAddress,ModelAddress>>(where?: TypeModelWhere<EntityAddress>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<EntityAddress,ModelAddress>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<EntityAddress,ModelAddress>>(data?: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>, options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T>>;
+      mutateBulk<T extends IModelMutateOptions<EntityAddress,ModelAddress>>(items: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T>[]>;
+      count<T extends IModelSelectCountParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      increment<T extends IModelIncrementParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      decrement<T extends IModelIncrementParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<number>;
+      aggregate<T extends IModelSelectAggrParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityAddress, T>[]>;
+      getById<T extends IModelGetOptions<EntityAddress,ModelAddress>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+updateById<T extends IModelUpdateOptions<EntityAddress,ModelAddress>>(id: TableIdentity, data: TypeModelMutateRelationData<EntityAddress,ModelAddress, T>, options?: T): Promise<TypeModelMutateRelationData<EntityAddress,ModelAddress, T>>;
+deleteById<T extends IModelDeleteOptions<EntityAddress,ModelAddress>>(id: TableIdentity, options?: T): Promise<void>;
+getByName<T extends IModelGetOptions<EntityAddress,ModelAddress>>(name?: string, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+getByNameEqI<T extends IModelGetOptions<EntityAddress,ModelAddress>>(name?: string, options?: T): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T> | undefined>;
+selectByName<T extends IModelSelectParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T>[]>;
+selectByNameEqI<T extends IModelSelectParams<EntityAddress,ModelAddress,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(name?: string, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAddress, ModelAddress, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    'commerce-member:address': ModelAddress;
+  }
+}
+/** model: end */
+/** service: begin */
+export * from '../service/address.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+
+    export interface IServiceRecord {
+      'commerce-member:address': never;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+        export interface ServiceAddress {
+          /** @internal */
+          get scope(): ScopeModuleCommerceMember;
+        }
+
+          export interface ServiceAddress {
+            get $beanFullName(): 'commerce-member.service.address';
+            get $onionName(): 'commerce-member:address';
+
+          }
+}
+/** service: end */
+/** service: begin */
+import type { ServiceAddress } from '../service/address.ts';
+export interface IModuleService {
+  'address': ServiceAddress;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'commerce-member.service.address': ServiceAddress;
+  }
+}
+/** 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-member:index': IMetaOptionsIndex;
+'commerce-member:version': never;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+        export interface MetaIndex {
+          /** @internal */
+          get scope(): ScopeModuleCommerceMember;
+        }
+
+          export interface MetaIndex {
+            get $beanFullName(): 'commerce-member.meta.index';
+            get $onionName(): 'commerce-member:index';
+            get $onionOptions(): IMetaOptionsIndex;
+          }
+
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleCommerceMember;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'commerce-member.meta.version';
+            get $onionName(): 'commerce-member:version';
+
+          }
+}
+/** meta: end */
+/** dto: begin */
+export * from '../dto/addressCreate.tsx';
+export * from '../dto/addressSelectReq.tsx';
+export * from '../dto/addressSelectRes.tsx';
+export * from '../dto/addressSelectResItem.tsx';
+export * from '../dto/addressUpdate.tsx';
+export * from '../dto/addressView.tsx';
+import type { IDtoOptionsAddressCreate } from '../dto/addressCreate.tsx';
+import type { IDtoOptionsAddressSelectReq } from '../dto/addressSelectReq.tsx';
+import type { IDtoOptionsAddressSelectRes } from '../dto/addressSelectRes.tsx';
+import type { IDtoOptionsAddressSelectResItem } from '../dto/addressSelectResItem.tsx';
+import type { IDtoOptionsAddressUpdate } from '../dto/addressUpdate.tsx';
+import type { IDtoOptionsAddressView } from '../dto/addressView.tsx';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+
+    export interface IDtoRecord {
+      'commerce-member:addressCreate': IDtoOptionsAddressCreate;
+'commerce-member:addressSelectReq': IDtoOptionsAddressSelectReq;
+'commerce-member:addressSelectRes': IDtoOptionsAddressSelectRes;
+'commerce-member:addressSelectResItem': IDtoOptionsAddressSelectResItem;
+'commerce-member:addressUpdate': IDtoOptionsAddressUpdate;
+'commerce-member:addressView': IDtoOptionsAddressView;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoAddressCreate } from '../dto/addressCreate.tsx';
+import type { DtoAddressSelectReq } from '../dto/addressSelectReq.tsx';
+import type { DtoAddressSelectRes } from '../dto/addressSelectRes.tsx';
+import type { DtoAddressSelectResItem } from '../dto/addressSelectResItem.tsx';
+import type { DtoAddressUpdate } from '../dto/addressUpdate.tsx';
+import type { DtoAddressView } from '../dto/addressView.tsx';
+declare module 'vona-module-commerce-member' {
+
+    export interface IDtoOptionsAddressCreate {
+      fields?: TypeEntityOptionsFields<DtoAddressCreate, IDtoOptionsAddressCreate[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsAddressSelectReq {
+      fields?: TypeEntityOptionsFields<DtoAddressSelectReq, IDtoOptionsAddressSelectReq[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsAddressSelectRes {
+      fields?: TypeEntityOptionsFields<DtoAddressSelectRes, IDtoOptionsAddressSelectRes[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsAddressSelectResItem {
+      fields?: TypeEntityOptionsFields<DtoAddressSelectResItem, IDtoOptionsAddressSelectResItem[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsAddressUpdate {
+      fields?: TypeEntityOptionsFields<DtoAddressUpdate, IDtoOptionsAddressUpdate[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsAddressView {
+      fields?: TypeEntityOptionsFields<DtoAddressView, IDtoOptionsAddressView[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
+/** controller: begin */
+export * from '../controller/address.ts';
+import type { IControllerOptionsAddress } from '../controller/address.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+
+    export interface IControllerRecord {
+      'commerce-member:address': IControllerOptionsAddress;
+    }
+
+
+}
+declare module 'vona-module-commerce-member' {
+
+        export interface ControllerAddress {
+          /** @internal */
+          get scope(): ScopeModuleCommerceMember;
+        }
+
+          export interface ControllerAddress {
+            get $beanFullName(): 'commerce-member.controller.address';
+            get $onionName(): 'commerce-member:address';
+            get $onionOptions(): IControllerOptionsAddress;
+          }
+}
+/** controller: end */
+/** controller: begin */
+// @ts-ignore ignore
+import type { ControllerAddress } from '../controller/address.ts';
+declare module 'vona-module-commerce-member' {
+
+    export interface IControllerOptionsAddress {
+      actions?: TypeControllerOptionsActions<ControllerAddress>;
+    }
+}
+declare module 'vona-module-a-web' {
+  export interface IApiPathPostRecord{
+        '/commerce/member/address': undefined;
+    }
+export interface IApiPathGetRecord{
+        '/commerce/member/address': undefined;
+'/commerce/member/address/:id': undefined;
+    }
+export interface IApiPathPatchRecord{
+        '/commerce/member/address/:id': undefined;
+    }
+export interface IApiPathDeleteRecord{
+        '/commerce/member/address/:id': undefined;
+    }
+
+}
+import 'vona-module-a-openapi';
+  declare module 'vona-module-a-openapi' {
+    export interface IResourceRecord {
+      'commerce-member:address': never;
+    }
+  }
+
+/** controller: end */
+/** locale: begin */
+import { locales } from './locales.ts';
+/** locale: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
 import { Scope } from 'vona-module-a-bean';
 
 @Scope()
@@ -8,6 +339,10 @@ export class ScopeModuleCommerceMember extends BeanScopeBase {}
 
 export interface ScopeModuleCommerceMember {
   util: BeanScopeUtil;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+entity: IModuleEntity;
+model: IModuleModel;
+service: IModuleService;
 }
 
 import 'vona';
@@ -19,11 +354,13 @@ declare module 'vona' {
   export interface IBeanScopeContainer {
     commerceMember: ScopeModuleCommerceMember;
   }
-  
-  
 
-  
 
-  
+
+  export interface IBeanScopeLocale {
+    'commerce-member': (typeof locales)[TypeLocaleBase];
+  }
+
+
 }
 /** scope: end */

package/vona/src/suite/a-commerce/modules/commerce-member/src/.metadata/locales.ts

@@ -0,0 +1,18 @@
+import type { TypeLocaleBase } from 'vona';
+
+import { $makeLocaleMagic } from 'vona';
+
+import locale_en_us from '../config/locale/en-us.ts';
+import locale_zh_cn from '../config/locale/zh-cn.ts';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};
+
+export function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(
+  key: K,
+  ...args: any[]
+): any {
+  return $makeLocaleMagic(`commerce-member::${key}`, ...args);
+}

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

@@ -0,0 +1,12 @@
+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('commerceMemberAddress', ['userId', 'recipientName']),
+  },
+})
+export class MetaIndex extends BeanBase {}

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

@@ -0,0 +1,31 @@
+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) {
+      const entityAddress = this.scope.entity.address;
+      await this.bean.model.createTable(entityAddress.$table, table => {
+        table.comment(entityAddress.$comment.$table);
+        table.basicFields();
+        table.userId(entityAddress.userId).comment(entityAddress.$comment.userId);
+        table
+          .string(entityAddress.recipientName, 100)
+          .comment(entityAddress.$comment.recipientName);
+        table.string(entityAddress.phone, 50).comment(entityAddress.$comment.phone);
+        table.string(entityAddress.countryCode, 10).comment(entityAddress.$comment.countryCode);
+        table.string(entityAddress.region, 100).comment(entityAddress.$comment.region);
+        table.string(entityAddress.city, 100).comment(entityAddress.$comment.city);
+        table.string(entityAddress.postalCode, 30).comment(entityAddress.$comment.postalCode);
+        table.string(entityAddress.addressLine1, 255).comment(entityAddress.$comment.addressLine1);
+        table
+          .string(entityAddress.addressLine2, 255)
+          .nullable()
+          .comment(entityAddress.$comment.addressLine2);
+      });
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+export default {
+  Address: 'Address',
+  AddressLine1: 'Address Line 1',
+  AddressLine2: 'Address Line 2',
+  City: 'City',
+  CountryCode: 'Country Code',
+  Operations: 'Operations',
+  Phone: 'Phone',
+  PostalCode: 'Postal Code',
+  RecipientName: 'Recipient Name',
+  Region: 'Region',
+};

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

@@ -0,0 +1,12 @@
+export default {
+  Address: '地址',
+  AddressLine1: '地址第一行',
+  AddressLine2: '地址第二行',
+  City: '城市',
+  CountryCode: '国家/地区代码',
+  Operations: '操作',
+  Phone: '联系电话',
+  PostalCode: '邮政编码',
+  RecipientName: '收件人姓名',
+  Region: '省/州/地区',
+};

package/vona/src/suite/a-commerce/modules/commerce-member/src/controller/address.ts

@@ -0,0 +1,59 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, Resource, v } from 'vona-module-a-openapiutils';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { z } from 'zod';
+
+import type { ModelAddress } from '../model/address.ts';
+
+import { DtoAddressCreate } from '../dto/addressCreate.tsx';
+import { DtoAddressSelectReq } from '../dto/addressSelectReq.tsx';
+import { DtoAddressSelectRes } from '../dto/addressSelectRes.tsx';
+import { DtoAddressUpdate } from '../dto/addressUpdate.tsx';
+import { DtoAddressView } from '../dto/addressView.tsx';
+
+export interface IControllerOptionsAddress extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsAddress>('address')
+@Resource()
+export class ControllerAddress extends BeanBase {
+  @Web.post()
+  @Api.body(v.tableIdentity())
+  async create(@Arg.body() address: DtoAddressCreate): Promise<TableIdentity> {
+    return (await this.scope.service.address.create(address)).id;
+  }
+
+  @Web.get()
+  @Api.body(DtoAddressSelectRes)
+  async select(
+    @Arg.filter(DtoAddressSelectReq) params: IQueryParams<ModelAddress>,
+  ): Promise<DtoAddressSelectRes> {
+    return await this.scope.service.address.select(params);
+  }
+
+  @Web.get(':id')
+  @Api.body(v.optional(), v.object(DtoAddressView))
+  async view(
+    @Arg.param('id', v.tableIdentity()) id: TableIdentity,
+  ): Promise<DtoAddressView | undefined> {
+    return await this.scope.service.address.view(id);
+  }
+
+  @Web.patch(':id')
+  @Api.body(z.null())
+  async update(
+    @Arg.param('id', v.tableIdentity()) id: TableIdentity,
+    @Arg.body() address: DtoAddressUpdate,
+  ): Promise<void> {
+    await this.scope.service.address.update(id, address);
+  }
+
+  @Web.delete(':id')
+  @Api.body(z.null())
+  async delete(@Arg.param('id', v.tableIdentity()) id: TableIdentity): Promise<void> {
+    await this.scope.service.address.delete(id);
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressCreate.tsx

@@ -0,0 +1,39 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { ModelAddress } from '../model/address.ts';
+
+export interface IDtoOptionsAddressCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressCreate>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionSubmit', {
+              permission: { actionInherit: 'update', formScene: ['create', 'edit'] },
+            }),
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoAddressCreate extends $Dto.create(() => ModelAddress, {
+  columns: [
+    'recipientName',
+    'phone',
+    'countryCode',
+    'region',
+    'city',
+    'postalCode',
+    'addressLine1',
+    'addressLine2',
+  ],
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressSelectReq.tsx

@@ -0,0 +1,30 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeSchema, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { EntityAddress } from '../entity/address.tsx';
+
+export interface IDtoOptionsAddressSelectReq extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressSelectReq>({
+  openapi: { filter: { table: 'commerceMemberAddress' } },
+  fields: {
+    recipientName: $makeSchema(v.optional(), z.string()),
+    phone: $makeSchema(v.optional(), z.string()),
+    createdAt: $makeSchema(
+      ZovaRender.field('basic-date:formFieldDateRange'),
+      v.filterTransform('a-web:dateRange'),
+      v.optional(),
+      z.string(),
+    ),
+  },
+})
+export class DtoAddressSelectReq extends $Dto.queryPage(EntityAddress, [
+  'recipientName',
+  'phone',
+  'createdAt',
+]) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressSelectRes.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoAddressSelectResItem } from './addressSelectResItem.tsx';
+
+export interface IDtoOptionsAddressSelectRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressSelectRes>()
+export class DtoAddressSelectRes extends $Dto.listAndCount(DtoAddressSelectResItem) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressSelectResItem.tsx

@@ -0,0 +1,53 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelAddress } from '../model/address.ts';
+
+export interface IDtoOptionsAddressSelectResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressSelectResItem>({
+  blocks: [
+    ZovaRender.block('basic-page:blockPage', {
+      blocks: [
+        ZovaRender.block('basic-page:blockFilter'),
+        ZovaRender.block('basic-page:blockToolbarBulk', {
+          actions: [ZovaRender.tableActionBulk('basic-table:actionCreate')],
+        }),
+        ZovaRender.block('basic-page:blockTable'),
+        ZovaRender.block('basic-page:blockPager'),
+      ],
+    }),
+  ],
+})
+export class DtoAddressSelectResItem extends $Dto.get(() => ModelAddress, {
+  columns: [
+    'id',
+    'recipientName',
+    'phone',
+    'countryCode',
+    'region',
+    'city',
+    'postalCode',
+    'addressLine1',
+    'addressLine2',
+    'createdAt',
+    'updatedAt',
+  ],
+}) {
+  @Api.field(
+    v.title($locale('Operations')),
+    ZovaRender.order(1, 'max'),
+    ZovaRender.cell('basic-table:actionOperationsRow', {
+      actions: [
+        ZovaRender.tableActionRow('basic-table:actionUpdate'),
+        ZovaRender.tableActionRow('basic-table:actionDelete'),
+      ],
+    }),
+  )
+  _operationsRow?: unknown;
+}