cabloy 5.1.149 → 5.1.151

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/lib/schema.ts

@@ -21,7 +21,7 @@ export function loadSchemaProperties(
   schema: SchemaObject | undefined,
   onGetSchema: (schemaName: string) => SchemaObject | undefined,
   schemaScene?: TypeSchemaScene,
-): SchemaObject[] | undefined {
+): ISchemaObjectExtensionField[] | undefined {
   if (!schema) return;
   const properties = schema.properties!;
   const result: ISchemaObjectExtensionField[] = [];
@@ -32,12 +32,26 @@ export function loadSchemaProperties(
       property = onGetSchema(property.$ref)!;
     }
     if (!property) continue;
-    const fieldSource = property.rest?.fieldSource;
+    const schemaKey = key;
+    const propertyRest = deepExtend(
+      {},
+      property.rest,
+      schemaScene && ['form-view', 'form-create', 'filter'].includes(schemaScene)
+        ? property.rest?.form
+        : undefined,
+      schemaScene ? property.rest?.[schemaScene] : undefined,
+    );
+    const fieldSource = propertyRest?.fieldSource;
     if (fieldSource) {
       const parts = fieldSource.split('.');
-      const propertyParent: any =
-        parts[0] === key ? property : result.find(item => item.key === parts[0]);
-      property = propertyParent?.properties[parts[1]];
+      let propertyParent =
+        parts[0] === schemaKey
+          ? property
+          : (properties[parts[0]] as ISchemaObjectExtensionField | undefined);
+      if (propertyParent?.$ref) {
+        propertyParent = onGetSchema(propertyParent.$ref)!;
+      }
+      property = propertyParent?.properties?.[parts[1]] as ISchemaObjectExtensionField;
       key = fieldSource;
     }
     if (!property) continue;
@@ -49,6 +63,14 @@ export function loadSchemaProperties(
         : undefined,
       schemaScene ? { rest: property.rest?.[schemaScene] ?? {} } : undefined,
     );
+    if (schemaKey !== key) {
+      property.schemaKey = schemaKey;
+    }
+    const propertyExisting = result.find(item => item.key === key);
+    if (propertyExisting) {
+      propertyExisting.schemaKeys = [...(propertyExisting.schemaKeys ?? []), schemaKey];
+      continue;
+    }
     result.push(property);
   }
   // sort

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/model/sdk.ts

@@ -20,7 +20,7 @@ import {
   schemaToZodSchema,
 } from '../lib/schema.js';
 import { TypeOpenapiPermissions } from '../types/permissions.js';
-import { TypeSchemaScene } from '../types/rest.js';
+import { ISchemaObjectExtensionField, TypeSchemaScene } from '../types/rest.js';
 import { IOpenapiSchemas, TypeOpenapiSchemasSdk } from '../types/schema.js';
 import { TypeRequestMethod } from '../types/sdk.js';
 
@@ -236,7 +236,7 @@ export class ModelSdk extends BeanModelBase {
   public loadSchemaProperties(
     schema: SchemaObject | undefined,
     schemaScene?: TypeSchemaScene,
-  ): SchemaObject[] | undefined {
+  ): ISchemaObjectExtensionField[] | undefined {
     return loadSchemaProperties(schema, schemaName => this.getSchema(schemaName).data, schemaScene);
   }
 

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/types/rest.ts

@@ -47,6 +47,10 @@ export interface ISchemaObjectExtensionFieldFilter {
 
 export interface ISchemaObjectExtensionField extends SchemaObject {
   key?: string;
+  /** Original property name before fieldSource normalization. */
+  schemaKey?: string;
+  /** Additional schema aliases that resolve to this canonical key. */
+  schemaKeys?: string[];
   rest?: ISchemaObjectExtensionFieldRest;
   filter?: ISchemaObjectExtensionFieldFilter;
 }

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/types/schema.ts

@@ -1,6 +1,5 @@
-import type { DefaultError, UseQueryReturnType } from '@tanstack/vue-query';
 import type { OpenAPIObject, SchemaObject } from 'openapi3-ts/oas31';
-import type { UnwrapNestedRefs } from 'vue';
+import type { ModelUseQueryReturnType } from 'zova-module-a-model';
 
 import type { IOpenapiSdkItem } from './sdk.js';
 
@@ -11,9 +10,7 @@ export interface IOpenapiSchema {
 
 export interface IOpenapiSchemaMeta {}
 
-export type TypeOpenapiSchemasSdk = UnwrapNestedRefs<
-  UseQueryReturnType<IOpenapiSdkItem, DefaultError>
->;
+export type TypeOpenapiSchemasSdk = ModelUseQueryReturnType<IOpenapiSdkItem, Error>;
 
 export interface IOpenapiSchemas {
   sdk: TypeOpenapiSchemasSdk;

package/zova/src/suite-vendor/a-zova/modules/a-openapi/test/lib/schema.test.ts

@@ -0,0 +1,179 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import type { ISchemaObjectExtensionField } from '../../src/types/rest.js';
+
+import { loadSchemaProperties } from '../../src/lib/schema.js';
+
+const onGetSchema = () => undefined;
+
+function field(field: ISchemaObjectExtensionField) {
+  return field;
+}
+
+test('schema properties preserve the canonical fieldSource key and original schema key', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({
+              type: 'string',
+              rest: { render: 'start-markdown:formFieldMarkdown' as any },
+            }),
+          },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: 'content',
+      type: 'string',
+      rest: { render: 'start-markdown:formFieldMarkdown' },
+    },
+  ]);
+});
+
+test('schema properties preserve virtual aliases without changing the form key', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { visible: false },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties?.[1], {
+    key: 'content.descriptionMarkdown',
+    schemaKey: '_descriptionMarkdown',
+    type: 'string',
+  });
+});
+
+test('schema properties normalize a scene-specific fieldSource', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { visible: false },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { form: { fieldSource: 'content.descriptionMarkdown' } },
+        }),
+      },
+    },
+    onGetSchema,
+    'form',
+  );
+
+  assert.deepEqual(properties?.[1], {
+    key: 'content.descriptionMarkdown',
+    schemaKey: '_descriptionMarkdown',
+    type: 'string',
+  });
+});
+
+test('schema properties coalesce aliases when the source property has fieldSource', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+        studentContentForm: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: 'content',
+      schemaKeys: ['_descriptionMarkdown', 'studentContentForm'],
+      type: 'string',
+    },
+  ]);
+});
+
+test('schema properties coalesce aliases declared before their fieldSource parent', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      schemaKeys: ['content'],
+      type: 'string',
+    },
+  ]);
+});
+
+test('ordinary schema properties do not gain a schema alias', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        name: field({ type: 'string' }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [{ key: 'name', type: 'string' }]);
+});

package/zova/src/suite-vendor/a-zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-suite-a-zova",
-  "version": "5.1.153",
+  "version": "5.1.154",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "zova",
   "license": "MIT",
@@ -16,13 +16,13 @@
     "zova-module-a-boundary": "^5.1.22",
     "zova-module-a-command": "^5.1.34",
     "zova-module-a-fetch": "^5.1.25",
-    "zova-module-a-form": "^5.1.49",
+    "zova-module-a-form": "^5.1.50",
     "zova-module-a-icon": "^5.1.27",
     "zova-module-a-interceptor": "^5.1.31",
     "zova-module-a-logger": "^5.1.28",
     "zova-module-a-meta": "^5.1.22",
-    "zova-module-a-model": "^5.1.35",
-    "zova-module-a-openapi": "^5.1.50",
+    "zova-module-a-model": "^5.1.36",
+    "zova-module-a-openapi": "^5.1.51",
     "zova-module-a-router": "^5.1.34",
     "zova-module-a-routerstack": "^5.1.27",
     "zova-module-a-routertabs": "^5.1.34",