cabloy 5.1.126 → 5.1.127

package/.cabloy-version

@@ -1 +1 @@
-5.1.126
+5.1.127

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 5.1.127
+
+### Features
+
+- Separate module error codes from HTTP status codes.
+- Complete the commerce payment refund flow.
+- Update feature functionality.
+
+### Bug Fixes
+
+- Harden the commerce order detail locator.
+
+### Improvements
+
+- Refactor error handling.
+- Record the first phase of error status evolution.
+- Define product presentation authority.
+- Retain category semantic CI evidence.
+- Retain semantic presentation CI evidence.
+- Prepare the category presentation rollout.
+
 ## 5.1.126
 
 ### Features

package/cabloy-docs/backend/error-guide.md

@@ -37,6 +37,23 @@ export const errors = {
 
 A useful convention is that business error codes should stay above `1000`.
 
+### Structured declarations and HTTP status
+
+Legacy numeric declarations remain supported. When a business error needs a stable namespaced application code and an intentional HTTP status, use a descriptor:
+
+```typescript
+export const errors = {
+  ErrorTest: {
+    code: 1001,
+    status: 409,
+  },
+} as const;
+```
+
+The descriptor produces an application error code such as `training-student:1001` and an HTTP response status of `409`. The `code` is the stable business identity; `status` is the initial transport decision. The standard JSON response remains `{ code, message }`, with the HTTP status carried by the response envelope.
+
+Use statuses that describe the API meaning: `404` for an absent resource, `409` for a resource-state or uniqueness conflict, and `422` for unacceptable business content. Existing final error filters may still revise the initial status for request-context policy, such as converting unauthenticated authorization failures from `403` to `401`.
+
 ### 2. Define the localized error messages
 
 Representative locale pattern:

package/e2e/specs/a-commerce/commerce.spec.ts

@@ -535,7 +535,9 @@ test(
       await orderCard.getByRole('button', { name: 'View', exact: true }).click();
       await expect(page).toHaveURL(new RegExp(`/commerce/order/${checkout.orderId}(?:/|$)`));
       await historyDetailResponse;
-      await expect(page.getByRole('heading', { name: `Order #${checkout.orderId}` })).toBeVisible();
+      await expect(
+        page.getByRole('heading', { name: `Order #${checkout.orderId}`, level: 1 }),
+      ).toBeVisible();
       await expect(page.getByText('1 × $45.99 = $45.99')).toBeVisible();
       await expect(page.getByRole('alert')).toHaveCount(0);
       expect(pageErrors).toEqual([]);
@@ -705,11 +707,39 @@ test(
         const executeResponse = waitForApiResponse(
           adminPage,
           'POST',
-          `/api/commerce/trade/order/${checkout.orderId}/refundOutcome`,
+          `/api/commerce/trade/order/${checkout.orderId}/executeRefund`,
         );
         await orderRow.getByRole('button', { name: 'Execute refund', exact: true }).click();
-        expect((await executeResponse).ok()).toBeTruthy();
-        await expect(orderRow).toContainText('refunded');
+        const executeResponseValue = await executeResponse;
+        expect(executeResponseValue.ok()).toBeTruthy();
+        const executeResult = (await executeResponseValue.json()).data;
+        const authorization = executeResponseValue.request().headers()['authorization'];
+        expect(authorization).toMatch(/^Bearer /);
+        const authHeaders = { Authorization: authorization };
+        expectTableIdentity(executeResult.refundAttemptId);
+        expectTableIdentity(executeResult.refundOperationId);
+        expect([
+          executeResult.orderState,
+          executeResult.refundState,
+          executeResult.refundAttemptState,
+        ]).toEqual(['refund_approved', 'approved', 'created']);
+        const completeRefundResponse = await adminPage.request.post(
+          `/api/pay/mock/payment-session/refund-operation/${executeResult.refundOperationId}/complete`,
+          { headers: authHeaders, data: { outcome: 'succeeded' } },
+        );
+        expect(completeRefundResponse.ok()).toBeTruthy();
+        await expect
+          .poll(
+            async () => {
+              await adminPage.reload({ waitUntil: 'load' });
+              const currentOrderRow = await getAdminOrderRow(adminPage, checkout.orderId);
+              return (await currentOrderRow.textContent()) ?? '';
+            },
+            { timeout: 40_000 },
+          )
+          .toContain('refunded');
+        const refundedOrderRow = await getAdminOrderRow(adminPage, checkout.orderId);
+        await expect(refundedOrderRow).toContainText('refunded');
         expect(adminPageErrors).toEqual([]);
       } finally {
         await adminContext.close().catch(() => {});
@@ -885,6 +915,107 @@ test(
   },
 );
 
+test(
+  'ATP-SPC-02: Category renders semantic Admin relation and publication controls',
+  { tag: ['@admin', '@flow', '@category'] },
+  async ({ browser }, testInfo) => {
+    test.setTimeout(60_000);
+    const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+    const parentName = `E2E Category Parent ${suffix}`;
+    const childName = `E2E Category Child ${suffix}`;
+    const adminContext = await browser.newContext();
+    const adminPage = await adminContext.newPage();
+    const adminPageErrors = collectPageErrors(adminPage);
+    const categoryCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory/create';
+    const categoryListPath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory';
+    const categoryActionPath = '/api/commerce/catalog/category';
+    let parentId: number | string | undefined;
+    let childId: number | string | undefined;
+    let headers: { Authorization: string } | undefined;
+    try {
+      await adminPage.setViewportSize({ width: 1440, height: 900 });
+      await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+      const accessToken = (await adminContext.cookies()).find(
+        cookie => cookie.name === 'token',
+      )?.value;
+      expect(accessToken).toBeTruthy();
+      headers = { Authorization: `Bearer ${accessToken}` };
+
+      const parentCreateResponse = await adminPage.request.post(categoryActionPath, {
+        data: { name: parentName, published: false },
+        headers,
+      });
+      expect(parentCreateResponse.ok()).toBeTruthy();
+      parentId = (await parentCreateResponse.json()).data;
+      expectTableIdentity(parentId);
+
+      await adminPage.goto(categoryCreatePath, { waitUntil: 'load' });
+      const parentPublication = adminPage
+        .getByRole('group', { name: 'Published' })
+        .getByRole('combobox');
+      await expect(parentPublication).toBeVisible();
+      await expect(parentPublication.locator('option')).toHaveText([
+        '',
+        'Unpublished',
+        'Published',
+      ]);
+      await parentPublication.selectOption({ label: 'Unpublished' });
+      await expect(parentPublication).toHaveValue('false');
+
+      const parentPicker = adminPage
+        .getByRole('group', { name: 'Parent category' })
+        .getByRole('combobox');
+      await expect(parentPicker).toBeVisible();
+      await parentPicker.selectOption({ label: parentName });
+      const parentValue = await parentPicker.inputValue();
+      expect(parentValue).toBe(String(parentId));
+      const childPublication = adminPage
+        .getByRole('group', { name: 'Published' })
+        .getByRole('combobox');
+      await childPublication.selectOption({ label: 'Published' });
+      await expect(childPublication).toHaveValue('true');
+
+      const childCreateResponse = await adminPage.request.post(categoryActionPath, {
+        data: { name: childName, parentId: parentValue, published: true },
+        headers,
+      });
+      expect(childCreateResponse.ok()).toBeTruthy();
+      childId = (await childCreateResponse.json()).data;
+      expectTableIdentity(childId);
+
+      await adminPage.goto(categoryListPath, { waitUntil: 'load' });
+      const childRow = adminPage.getByRole('row', { name: new RegExp(childName) });
+      await expect(childRow).toBeVisible();
+      await expect(childRow.getByText(parentName, { exact: true })).toBeVisible();
+      await expect(childRow.getByText('Published', { exact: true })).toBeVisible();
+
+      await adminPage.goto(`${categoryListPath}/${childId}`, { waitUntil: 'load' });
+      await expect(
+        adminPage.getByRole('group', { name: 'Parent category' }).getByRole('textbox'),
+      ).toHaveValue(parentName);
+      await expect(
+        adminPage.getByRole('group', { name: 'Published' }).getByRole('textbox'),
+      ).toHaveValue('Published');
+      await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+      expect(adminPageErrors).toEqual([]);
+    } finally {
+      if (childId && headers) {
+        const response = await adminPage.request.delete(`${categoryActionPath}/${childId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      if (parentId && headers) {
+        const response = await adminPage.request.delete(`${categoryActionPath}/${parentId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      await adminContext.close().catch(() => {});
+    }
+  },
+);
+
 test(
   'Commerce Cart: anonymous browser is redirected to login',
   { tag: ['@web', '@cart'] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.126",
+  "version": "5.1.127",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.136",
+  "version": "1.1.137",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.134",
+  "version": "1.1.135",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.83",
+  "version": "5.1.84",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.35",
+  "version": "5.1.36",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [

package/vona/packages-vona/vona-core/src/lib/bean/resource/error/errorClass.ts

@@ -21,7 +21,7 @@ export class ErrorClass extends BeanSimple {
   fail(module, code, ...args) {
     const body = this.parseFail(module, code, ...args);
 
-    this.ctx.response.status = __calcStatus(body.code);
+    this.ctx.response.status = body.status;
     this.ctx.response.type = 'application/json';
     this.ctx.response.body = { code: body.code, message: body.message }; // body maybe Error
   }
@@ -32,7 +32,7 @@ export class ErrorClass extends BeanSimple {
     const err = new Error();
     err.code = body.code;
     err.message = body.message;
-    err.status = __calcStatus(body.code);
+    err.status = body.status;
     throw err;
   }
 
@@ -58,9 +58,16 @@ export class ErrorClass extends BeanSimple {
 
     // convert from enum
     let text;
+    let status;
     if (ebError && code && typeof code === 'string') {
       text = code;
-      code = ebError[code];
+      const declaration = ebError[code];
+      if (__isErrorDescriptor(declaration)) {
+        code = declaration.code;
+        status = declaration.status;
+      } else {
+        code = declaration;
+      }
     }
 
     if (code === undefined || code === null || code === '') {
@@ -75,10 +82,20 @@ export class ErrorClass extends BeanSimple {
     }
 
     code = __combineErrorCode(module, code);
-    return { code, message };
+    status ??= __calcStatus(code);
+    return { code, status, message };
   }
 }
 
+function __isErrorDescriptor(value) {
+  return (
+    value &&
+    typeof value === 'object' &&
+    typeof value.code === 'number' &&
+    typeof value.status === 'number'
+  );
+}
+
 function __combineErrorCode(module, code) {
   if (typeof code !== 'number' || code <= 1000) return code;
   return module ? `${module}:${code}` : code;

package/vona/packages-vona/vona-core/src/lib/bean/resource/error/errorObject.ts

@@ -1,4 +1,5 @@
 export interface IErrorObject {
   code: number | string;
+  status: number;
   message: string;
 }

package/vona/packages-vona/vona-core/src/lib/bean/type.ts

@@ -29,12 +29,14 @@ export type TypeBeanScopeLocaleKeys = keyof IBeanScopeLocale;
 export interface IBeanScopeErrors {}
 export type TypeBeanScopeErrorsKeys = keyof IBeanScopeErrors;
 
+type TypeErrorDeclarationCode<T> = T extends { code: infer Code } ? Code : T;
+
 export type TypeScopesErrorsHelper<
   ModuleName extends keyof IBeanScopeErrors,
   Errors extends IBeanScopeErrors[ModuleName],
 > = {
   // @ts-ignore: ignore
-  [K in keyof Errors as `${ModuleName}:${Errors[K]}`]: K;
+  [K in keyof Errors as `${ModuleName}:${TypeErrorDeclarationCode<Errors[K]>}`]: K;
 };
 export type TypeScopesErrorCodes = TypeRecordValues<{
   [ModuleName in keyof IBeanScopeErrors]: keyof TypeScopesErrorsHelper<

package/vona/packages-vona/vona-core/src/types/interface/module.ts

@@ -4,7 +4,12 @@ import type { IModuleMain, IMonkeyModule, IMonkeySystem } from './monkey.ts';
 
 export type TypeModuleResourceLocales = Record<string, object>;
 export type TypeModuleResourceLocaleModules = Record<string, TypeModuleResourceLocales>;
-export type TypeModuleResourceErrors = Record<string, number>;
+export interface IModuleResourceErrorDescriptor {
+  code: number;
+  status: number;
+}
+export type TypeModuleResourceError = number | IModuleResourceErrorDescriptor;
+export type TypeModuleResourceErrors = Record<string, TypeModuleResourceError>;
 export type TypeModuleResourceErrorModules = Record<string, TypeModuleResourceErrors>;
 export type TypeModuleResourceConfig = (app: VonaApplication) => object | Promise<object>;
 

package/vona/packages-vona/vona-mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-mock",
-  "version": "6.1.35",
+  "version": "6.1.36",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona mock",
   "keywords": [

package/vona/pnpm-lock.yaml

@@ -1834,16 +1834,16 @@ importers:
   src/suite-vendor/a-pay:
     dependencies:
       vona-module-a-pay:
-        specifier: ^5.0.2
+        specifier: ^5.0.3
         version: link:modules/a-pay
       vona-module-pay-mock:
-        specifier: ^5.0.2
+        specifier: ^5.0.3
         version: link:modules/pay-mock
       vona-module-pay-paypal:
-        specifier: ^5.0.2
+        specifier: ^5.0.3
         version: link:modules/pay-paypal
       vona-module-pay-stripe:
-        specifier: ^5.0.2
+        specifier: ^5.0.3
         version: link:modules/pay-stripe
 
   src/suite-vendor/a-pay/modules/a-pay:
@@ -1922,7 +1922,7 @@ importers:
         specifier: ^5.0.8
         version: link:modules/test-file
       vona-module-test-pay:
-        specifier: ^5.0.1
+        specifier: ^5.0.2
         version: link:modules/test-pay
 
   src/suite-vendor/a-test/modules/test-auth:

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

@@ -142,7 +142,12 @@ declare module 'vona' {
 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-catalog' {
-  export interface IModelOptionsProduct {
+  export interface IModelOptionsCategory {
+        relations: {
+          parent: IModelRelationBelongsTo<'commerce-catalog:category', 'commerce-catalog:category', false, 'id'|'name'>;
+        };
+      }
+export interface IModelOptionsProduct {
         relations: {
           category: IModelRelationBelongsTo<'commerce-catalog:product', 'commerce-catalog:category', false, '*'>;
 skus: IModelRelationHasMany<'commerce-catalog:sku', 'productId', false, '*', undefined, undefined, undefined>;
@@ -159,7 +164,17 @@ export interface IModelOptionsSku {
       [SymbolKeyEntityMeta]: EntityCategoryMeta;
       [SymbolKeyModelOptions]: IModelOptionsCategory;
       get<T extends IModelGetOptions<EntityCategory,ModelCategory>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T> | undefined>;
+      /**
+       * Retrieves one matching primary row with a pessimistic FOR UPDATE lock.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getForUpdate<T extends IModelGetOptions<EntityCategory,ModelCategory>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T> | undefined>;
+      /**
+       * Retrieves a primary row by ID with the same pessimistic FOR UPDATE lock semantics.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getByIdForUpdate<T extends IModelGetOptions<EntityCategory,ModelCategory>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T> | undefined>;
       mget<T extends IModelGetOptions<EntityCategory,ModelCategory>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityCategory,ModelCategory,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityCategory, ModelCategory, T>>;
@@ -190,7 +205,17 @@ export interface ModelProduct {
       [SymbolKeyEntityMeta]: EntityProductMeta;
       [SymbolKeyModelOptions]: IModelOptionsProduct;
       get<T extends IModelGetOptions<EntityProduct,ModelProduct>>(where: TypeModelWhere<EntityProduct>, options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T> | undefined>;
+      /**
+       * Retrieves one matching primary row with a pessimistic FOR UPDATE lock.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getForUpdate<T extends IModelGetOptions<EntityProduct,ModelProduct>>(where: TypeModelWhere<EntityProduct>, options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T> | undefined>;
+      /**
+       * Retrieves a primary row by ID with the same pessimistic FOR UPDATE lock semantics.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getByIdForUpdate<T extends IModelGetOptions<EntityProduct,ModelProduct>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T> | undefined>;
       mget<T extends IModelGetOptions<EntityProduct,ModelProduct>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityProduct,ModelProduct,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityProduct, ModelProduct, T>>;
@@ -217,7 +242,17 @@ export interface ModelSku {
       [SymbolKeyEntityMeta]: EntitySkuMeta;
       [SymbolKeyModelOptions]: IModelOptionsSku;
       get<T extends IModelGetOptions<EntitySku,ModelSku>>(where: TypeModelWhere<EntitySku>, options?: T): Promise<TypeModelRelationResult<EntitySku, ModelSku, T> | undefined>;
+      /**
+       * Retrieves one matching primary row with a pessimistic FOR UPDATE lock.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getForUpdate<T extends IModelGetOptions<EntitySku,ModelSku>>(where: TypeModelWhere<EntitySku>, options?: T): Promise<TypeModelRelationResult<EntitySku, ModelSku, T> | undefined>;
+      /**
+       * Retrieves a primary row by ID with the same pessimistic FOR UPDATE lock semantics.
+       * Requires an active transaction. The lock is released when that transaction completes.
+       * Entity and query caches are bypassed.
+       */
       getByIdForUpdate<T extends IModelGetOptions<EntitySku,ModelSku>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntitySku, ModelSku, T> | undefined>;
       mget<T extends IModelGetOptions<EntitySku,ModelSku>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntitySku, ModelSku, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntitySku,ModelSku,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntitySku, ModelSku, T>>;

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

@@ -9,6 +9,7 @@ export default {
   Product: 'Product',
   ProductTitle: 'Product title',
   Published: 'Published',
+  Unpublished: 'Unpublished',
   Sku: 'SKU',
   SkuAttributeName: 'SKU attribute name',
   SkuAttributeValue: 'SKU attribute value',

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

@@ -9,6 +9,7 @@ export default {
   Product: '商品',
   ProductTitle: '商品标题',
   Published: '已发布',
+  Unpublished: '未发布',
   Sku: 'SKU',
   SkuAttributeName: 'SKU 属性名',
   SkuAttributeValue: 'SKU 属性值',

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

@@ -46,7 +46,9 @@ export interface IDtoOptionsCategorySelectResItem extends IDecoratorDtoOptions {
     }),
   ],
 })
-export class DtoCategorySelectResItem extends $Dto.get(() => ModelCategory) {
+export class DtoCategorySelectResItem extends $Dto.get(() => ModelCategory, {
+  include: { parent: true },
+}) {
   @Api.field(
     v.title($locale('Operations')),
     ZovaRender.order(1, 'max'),

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

@@ -22,4 +22,6 @@ export interface IDtoOptionsCategoryView extends IDecoratorDtoOptions {}
     }),
   ],
 })
-export class DtoCategoryView extends $Dto.get(() => ModelCategory) {}
+export class DtoCategoryView extends $Dto.get(() => ModelCategory, {
+  include: { parent: true },
+}) {}

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

@@ -1,7 +1,7 @@
 import type { TableIdentity } from 'table-identity';
 import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
 
-import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { $makeMetadata, $resourceName, Api, v } from 'vona-module-a-openapiutils';
 import { Entity, EntityBase } from 'vona-module-a-orm';
 import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
@@ -9,6 +9,11 @@ import { $locale } from '../.metadata/locales.ts';
 
 export interface IEntityOptionsCategory extends IDecoratorEntityOptions {}
 
+export const categoryPublicationItems = [
+  { value: false, title: $locale('Unpublished') },
+  { value: true, title: $locale('Published') },
+];
+
 @Entity<IEntityOptionsCategory>('commerceCatalogCategory', {
   openapi: { title: $locale('Category') },
   fields: {
@@ -41,11 +46,25 @@ export class EntityCategory extends EntityBase {
     v.title($locale('ParentCategory')),
     v.optional(),
     ZovaRender.order(2),
+    ZovaRender.field('basic-resource:formFieldResourcePicker', {
+      resource: $resourceName('commerce-catalog:category'),
+      relationName: 'parent',
+    }),
+    ZovaRender.cell('basic-resource:resourcePicker', {
+      resource: $resourceName('commerce-catalog:category'),
+      relationName: 'parent',
+    }),
     v.tableIdentity(),
   )
   parentId?: TableIdentity;
 
-  @Api.field(v.title($locale('Published')), v.default(false), ZovaRender.order(3))
+  @Api.field(
+    v.title($locale('Published')),
+    v.default(false),
+    ZovaRender.order(3),
+    ZovaRender.field('basic-select:formFieldSelect', { items: categoryPublicationItems }),
+    ZovaRender.cell('basic-select:select', { items: categoryPublicationItems }),
+  )
   published: boolean;
 
   @Api.field(v.title($locale('Description')), v.optional(), ZovaRender.order(4))

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

@@ -1,6 +1,6 @@
 import type { IDecoratorModelOptions } from 'vona-module-a-orm';
 
-import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
 
 import { EntityCategory } from '../entity/category.tsx';
 
@@ -8,6 +8,16 @@ export interface IModelOptionsCategory extends IDecoratorModelOptions<EntityCate
 
 @Model<IModelOptionsCategory>({
   entity: EntityCategory,
+  relations: {
+    parent: $relation.belongsTo(
+      'commerce-catalog:category',
+      'commerce-catalog:category',
+      'parentId',
+      {
+        columns: ['id', 'name'],
+      },
+    ),
+  },
   cache: {
     modelsClear: 'commerce-catalog:product',
   },

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

@@ -19,11 +19,16 @@ export class ServiceCategory extends BeanBase {
   }
 
   async select(params?: IQueryParams<ModelCategory>): Promise<DtoCategorySelectRes> {
-    return await this.scope.model.category.selectAndCount(params);
+    return await this.scope.model.category.selectAndCount({
+      ...params,
+      include: { parent: true },
+    });
   }
 
   async view(id: TableIdentity): Promise<DtoCategoryView | undefined> {
-    return await this.scope.model.category.getById(id);
+    return await this.scope.model.category.getById(id, {
+      include: { parent: true },
+    });
   }
 
   async update(id: TableIdentity, category: DtoCategoryUpdate) {