cabloy 5.1.111 → 5.1.113

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressUpdate.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 IDtoOptionsAddressUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressUpdate>({
+  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 DtoAddressUpdate extends $Dto.update(() => ModelAddress, {
+  columns: [
+    'recipientName',
+    'phone',
+    'countryCode',
+    'region',
+    'city',
+    'postalCode',
+    'addressLine1',
+    'addressLine2',
+  ],
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressView.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 IDtoOptionsAddressView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAddressView>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoAddressView extends $Dto.get(() => ModelAddress, {
+  columns: [
+    'id',
+    'recipientName',
+    'phone',
+    'countryCode',
+    'region',
+    'city',
+    'postalCode',
+    'addressLine1',
+    'addressLine2',
+    'createdAt',
+    'updatedAt',
+  ],
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/entity/address.tsx

@@ -0,0 +1,76 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsAddress extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsAddress>('commerceMemberAddress', {
+  openapi: { title: $locale('Address') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    userId: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(
+      ZovaRender.order(-1, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+  },
+})
+export class EntityAddress extends EntityBase {
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(
+    v.title($locale('RecipientName')),
+    v.required(),
+    v.min(2),
+    v.max(100),
+    ZovaRender.order(1),
+  )
+  recipientName: string;
+
+  @Api.field(v.title($locale('Phone')), v.required(), v.min(1), v.max(50), ZovaRender.order(2))
+  phone: string;
+
+  @Api.field(
+    v.title($locale('CountryCode')),
+    v.required(),
+    v.min(2),
+    v.max(10),
+    ZovaRender.order(3),
+  )
+  countryCode: string;
+
+  @Api.field(v.title($locale('Region')), v.required(), v.min(1), v.max(100), ZovaRender.order(4))
+  region: string;
+
+  @Api.field(v.title($locale('City')), v.required(), v.min(1), v.max(100), ZovaRender.order(5))
+  city: string;
+
+  @Api.field(v.title($locale('PostalCode')), v.required(), v.min(1), v.max(30), ZovaRender.order(6))
+  postalCode: string;
+
+  @Api.field(
+    v.title($locale('AddressLine1')),
+    v.required(),
+    v.min(1),
+    v.max(255),
+    ZovaRender.order(7),
+  )
+  addressLine1: string;
+
+  @Api.field(v.title($locale('AddressLine2')), v.optional(), v.max(255), ZovaRender.order(8))
+  addressLine2?: string;
+}

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

@@ -1 +1,2 @@
+export * from './.metadata/locales.ts';
 export * from './.metadata/index.ts';

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

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

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

@@ -0,0 +1,84 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { DtoAddressCreate } from '../dto/addressCreate.tsx';
+import type { DtoAddressSelectRes } from '../dto/addressSelectRes.tsx';
+import type { DtoAddressUpdate } from '../dto/addressUpdate.tsx';
+import type { DtoAddressView } from '../dto/addressView.tsx';
+import type { ModelAddress } from '../model/address.ts';
+
+@Service()
+export class ServiceAddress extends BeanBase {
+  async create(address: DtoAddressCreate) {
+    return await this.scope.model.address.insert({
+      ...address,
+      userId: this._getCurrentUserId(),
+    });
+  }
+
+  async select(params?: IQueryParams<ModelAddress>): Promise<DtoAddressSelectRes> {
+    return await this.scope.model.address.selectAndCount({
+      columns: [
+        'id',
+        'recipientName',
+        'phone',
+        'countryCode',
+        'region',
+        'city',
+        'postalCode',
+        'addressLine1',
+        'addressLine2',
+        'createdAt',
+        'updatedAt',
+      ],
+      where: { ...params?.where, userId: this._getCurrentUserId() },
+      orders: [['id', 'asc']],
+      limit: params?.limit ?? 20,
+      offset: params?.offset ?? 0,
+    });
+  }
+
+  async view(id: TableIdentity): Promise<DtoAddressView | undefined> {
+    return await this._getOwnedAddress(id);
+  }
+
+  async update(id: TableIdentity, address: DtoAddressUpdate) {
+    const ownedAddress = await this._getOwnedAddress(id);
+    if (!ownedAddress) return;
+    await this.scope.model.address.updateById(ownedAddress.id, address);
+  }
+
+  async delete(id: TableIdentity) {
+    const ownedAddress = await this._getOwnedAddress(id);
+    if (!ownedAddress) return;
+    await this.scope.model.address.deleteById(ownedAddress.id);
+  }
+
+  private _getCurrentUserId(): TableIdentity {
+    return this.bean.passport.currentUser!.id;
+  }
+
+  private async _getOwnedAddress(id: TableIdentity) {
+    return await this.scope.model.address.get(
+      { id, userId: this._getCurrentUserId() },
+      {
+        columns: [
+          'id',
+          'recipientName',
+          'phone',
+          'countryCode',
+          'region',
+          'city',
+          'postalCode',
+          'addressLine1',
+          'addressLine2',
+          'createdAt',
+          'updatedAt',
+        ],
+      },
+    );
+  }
+}

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

@@ -0,0 +1,203 @@
+import type {
+  DtoAddressCreate,
+  DtoAddressUpdate,
+  EntityAddress,
+} from 'vona-module-commerce-member';
+
+import { catchError } from '@cabloy/utils';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+const actionPath = '/commerce/member/address';
+
+function createAddress(suffix: string): DtoAddressCreate {
+  return {
+    recipientName: `Recipient ${suffix}`,
+    phone: '15555550123',
+    countryCode: 'US',
+    region: 'California',
+    city: 'San Francisco',
+    postalCode: '94105',
+    addressLine1: `1 Market Street ${suffix}`,
+    addressLine2: 'Suite 100',
+  };
+}
+
+async function performAs(accessToken: string, method: string, path: string, options = {}) {
+  return await app.bean.executor.newCtxIsolate(async () => {
+    return await app.bean.executor.performAction(method, path, {
+      ...options,
+      authToken: accessToken,
+      innerAccess: false,
+    });
+  });
+}
+
+async function registerAndSignin(name: string) {
+  await app.bean.user.register({ name }, true);
+  const token = await app.bean.passport.signinMock(name as any);
+  return { token: token.accessToken, user: app.bean.passport.currentUser! };
+}
+
+describe('address.test.ts', () => {
+  it('denies anonymous address actions', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      for (const [method, path, options] of [
+        ['post', actionPath, { body: createAddress('anonymous') }],
+        ['get', actionPath, {}],
+        ['get', `${actionPath}/:id`, { params: { id: 999999 } }],
+        ['patch', `${actionPath}/:id`, { params: { id: 999999 }, body: {} }],
+        ['delete', `${actionPath}/:id`, { params: { id: 999999 } }],
+      ] as const) {
+        const [_, err] = await catchError(() =>
+          app.bean.executor.performAction(method, path, { ...options, innerAccess: false }),
+        );
+        assert.equal(err?.code, 401);
+      }
+    });
+  });
+
+  it('derives ownership from the authenticated customer and scopes every action', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      const customerA = await registerAndSignin(`address-a-${suffix}`);
+      const customerB = await registerAndSignin(`address-b-${suffix}`);
+      const addressData = createAddress(suffix);
+      const addressId = await performAs(customerA.token, 'post', actionPath, {
+        body: { ...addressData, userId: customerB.user.id, iid: 999999 } as any,
+      });
+
+      const persisted = await app.scope('commerce-member').model.address.getById(addressId);
+      assert.equal(String(persisted?.userId), String(customerA.user.id));
+      assert.equal(persisted?.iid, app.ctx.instance.id);
+
+      const ownList = await performAs(customerA.token, 'get', actionPath);
+      assert.equal(
+        ownList.list.some(item => String(item.id) === String(addressId)),
+        true,
+      );
+      assert.equal(
+        ownList.list.every(item => !Object.hasOwn(item, 'userId')),
+        true,
+      );
+      assert.equal(
+        ownList.list.every(item => !Object.hasOwn(item, 'iid')),
+        true,
+      );
+
+      const update: DtoAddressUpdate = { ...addressData, city: 'Oakland', addressLine2: undefined };
+      assert.equal(
+        await performAs(customerA.token, 'patch', `${actionPath}/:id`, {
+          params: { id: addressId },
+          body: update,
+        }),
+        null,
+      );
+      const ownAddress: EntityAddress = await performAs(
+        customerA.token,
+        'get',
+        `${actionPath}/:id`,
+        {
+          params: { id: addressId },
+        },
+      );
+      assert.equal(ownAddress.city, update.city);
+      assert.equal(ownAddress.addressLine2, addressData.addressLine2);
+      assert.equal(Object.hasOwn(ownAddress, 'userId'), false);
+      assert.equal(Object.hasOwn(ownAddress, 'iid'), false);
+
+      const foreignList = await performAs(customerB.token, 'get', actionPath);
+      assert.equal(
+        foreignList.list.some(item => String(item.id) === String(addressId)),
+        false,
+      );
+      assert.equal(
+        await performAs(customerB.token, 'get', `${actionPath}/:id`, { params: { id: addressId } }),
+        undefined,
+      );
+      assert.equal(
+        await performAs(customerB.token, 'patch', `${actionPath}/:id`, {
+          params: { id: addressId },
+          body: { ...addressData, city: 'Los Angeles' },
+        }),
+        null,
+      );
+      assert.equal(
+        await performAs(customerB.token, 'delete', `${actionPath}/:id`, {
+          params: { id: addressId },
+        }),
+        null,
+      );
+      assert.equal(
+        (await app.scope('commerce-member').model.address.getById(addressId))?.city,
+        'Oakland',
+      );
+
+      assert.equal(
+        await performAs(customerA.token, 'delete', `${actionPath}/:id`, {
+          params: { id: addressId },
+        }),
+        null,
+      );
+      assert.equal(
+        await performAs(customerA.token, 'get', `${actionPath}/:id`, { params: { id: addressId } }),
+        undefined,
+      );
+    });
+  });
+
+  it('treats another instance address as absent', async () => {
+    let addressId!: number;
+    let customerDefault!: Awaited<ReturnType<typeof registerAndSignin>>;
+    const addressDefault = createAddress('default');
+    await app.bean.executor.mockCtx(async () => {
+      customerDefault = await registerAndSignin(`address-default-${Date.now()}`);
+      addressId = await performAs(customerDefault.token, 'post', actionPath, {
+        body: addressDefault,
+      });
+    });
+
+    await app.bean.executor.mockCtx(
+      async () => {
+        const customer = await registerAndSignin(`address-share-${Date.now()}`);
+        assert.equal(
+          await performAs(customer.token, 'get', `${actionPath}/:id`, {
+            params: { id: addressId },
+          }),
+          undefined,
+        );
+        const list = await performAs(customer.token, 'get', actionPath);
+        assert.equal(
+          list.list.some(item => String(item.id) === String(addressId)),
+          false,
+        );
+        assert.equal(
+          await performAs(customer.token, 'patch', `${actionPath}/:id`, {
+            params: { id: addressId },
+            body: { ...createAddress('foreign'), city: 'Other city' },
+          }),
+          null,
+        );
+        assert.equal(
+          await performAs(customer.token, 'delete', `${actionPath}/:id`, {
+            params: { id: addressId },
+          }),
+          null,
+        );
+        assert.equal(
+          await app.scope('commerce-member').model.address.getById(addressId),
+          undefined,
+        );
+      },
+      { instanceName: 'shareTest' as any },
+    );
+
+    await app.bean.executor.mockCtx(async () => {
+      const address = await performAs(customerDefault.token, 'get', `${actionPath}/:id`, {
+        params: { id: addressId },
+      });
+      assert.equal(address.city, addressDefault.city);
+    });
+  });
+});

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

@@ -0,0 +1,52 @@
+{
+  "name": "vona-module-commerce-seed",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "commerce-seed",
+  "vonaModule": {
+    "dependencies": {
+      "a-vona": "5.0.0"
+    }
+  }
+}

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

@@ -0,0 +1,55 @@
+// eslint-disable
+/** meta: begin */
+export * from '../bean/meta.version.ts';
+
+import 'vona-module-a-meta';
+declare module 'vona-module-a-meta' {
+  
+    export interface IMetaRecord {
+      'commerce-seed:version': never;
+    }
+
+  
+}
+declare module 'vona-module-commerce-seed' {
+  
+        export interface MetaVersion {
+          /** @internal */
+          get scope(): ScopeModuleCommerceSeed;
+        }
+
+          export interface MetaVersion {
+            get $beanFullName(): 'commerce-seed.meta.version';
+            get $onionName(): 'commerce-seed:version';
+            
+          } 
+}
+/** meta: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleCommerceSeed extends BeanScopeBase {}
+
+export interface ScopeModuleCommerceSeed {
+  util: BeanScopeUtil;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'commerce-seed': ScopeModuleCommerceSeed;
+  }
+
+  export interface IBeanScopeContainer {
+    commerceSeed: ScopeModuleCommerceSeed;
+  }
+  
+  
+
+  
+
+  
+}
+/** scope: end */

package/vona/src/suite/a-commerce/modules/commerce-seed/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'commerce-seed';
+export { ScopeModuleCommerceSeed as ScopeModule } from './index.ts';

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

@@ -0,0 +1,80 @@
+import type { IMetaVersionSeed, IMetaVersionSeedOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionSeed {
+  async seed(_options: IMetaVersionSeedOptions) {
+    const scopeCatalog = this.$scope.commerceCatalog;
+    const scopeTrade = this.$scope.commerceTrade;
+
+    const electronics = await scopeCatalog.model.category.insert({
+      name: 'Electronics',
+      published: true,
+      description: 'Consumer electronics for Commerce testing.',
+    });
+    const homeKitchen = await scopeCatalog.model.category.insert({
+      name: 'Home & Kitchen',
+      published: true,
+      description: 'Home and kitchen products for Commerce testing.',
+    });
+
+    const headphones = await scopeCatalog.model.product.insert({
+      categoryId: electronics.id,
+      title: 'Wireless Headphones',
+      published: true,
+      description: 'Comfortable wireless headphones with clear sound.',
+    });
+    const keyboard = await scopeCatalog.model.product.insert({
+      categoryId: electronics.id,
+      title: 'Mechanical Keyboard',
+      published: true,
+      description: 'A compact mechanical keyboard for daily work.',
+    });
+    const coffeeSet = await scopeCatalog.model.product.insert({
+      categoryId: homeKitchen.id,
+      title: 'Pour-Over Coffee Set',
+      published: true,
+      description: 'A complete pour-over coffee brewing set.',
+    });
+
+    const skus = await Promise.all([
+      scopeCatalog.model.sku.insert({
+        productId: headphones.id,
+        code: 'HPH-BLK',
+        priceCents: 7999,
+        lifecycle: 'active',
+      }),
+      scopeCatalog.model.sku.insert({
+        productId: keyboard.id,
+        code: 'MKB-US',
+        priceCents: 12999,
+        lifecycle: 'active',
+      }),
+      scopeCatalog.model.sku.insert({
+        productId: keyboard.id,
+        code: 'MKB-US-RGB',
+        priceCents: 14999,
+        lifecycle: 'active',
+      }),
+      scopeCatalog.model.sku.insert({
+        productId: coffeeSet.id,
+        code: 'COF-SET-01',
+        priceCents: 4599,
+        lifecycle: 'active',
+      }),
+    ]);
+
+    await Promise.all(
+      [24, 15, 8, 30].map((delta, index) =>
+        scopeTrade.service.stockBalance.adjustStock({
+          skuId: skus[index].id,
+          delta,
+          reason: 'Initial commerce seed inventory',
+          correlationId: `commerce-seed-initial-${skus[index].id}`,
+        }),
+      ),
+    );
+  }
+}

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

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/vona/src/suite/a-commerce/modules/commerce-seed/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite/a-commerce/modules/commerce-seed/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

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

@@ -47,7 +47,9 @@
   "vonaModule": {
     "dependencies": {
       "a-vona": "5.0.0",
-      "a-ssr": "5.0.0"
-    }
+      "a-ssr": "5.0.0",
+      "home-user": "5.0.0"
+    },
+    "fileVersion": 1
   }
 }