cabloy 5.1.249 → 5.1.251

package/vona/src/suite-vendor/a-vona/modules/a-orm/src/types/analysis.ts

@@ -0,0 +1,137 @@
+import type { Constructable } from 'vona';
+
+import type { BeanModelMeta } from '../lib/bean.model/bean.model_meta.ts';
+import type { TypeModelWhere } from './modelWhere.ts';
+import type { IModelClassRecord } from './onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from './relations.ts';
+
+export type TypeAnalysisMode = 'group' | 'aggregate';
+export type TypeAnalysisFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export type TypeAnalysisModelLike =
+  | Constructable<BeanModelMeta>
+  | (() => Constructable<BeanModelMeta>)
+  | keyof IModelClassRecord;
+export type TypeAnalysisEntity<ModelLike extends TypeAnalysisModelLike> =
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity];
+export type TypeAnalysisField<Entity> = Extract<keyof Entity, string>;
+export type TypeAnalysisNumericField<Entity> = Exclude<
+  {
+    [K in keyof Entity]-?: NonNullable<Entity[K]> extends number ? K : never;
+  }[keyof Entity],
+  'id' | 'iid'
+> &
+  string;
+
+export type TypeAnalysisAggrs = Partial<Record<TypeAnalysisFunction, readonly string[]>>;
+export type TypeAnalysisAllowedAggrs<Entity> = {
+  readonly count?: readonly ('*' | TypeAnalysisField<Entity>)[];
+} & {
+  readonly [
+    K in Exclude<TypeAnalysisFunction, 'count'>
+  ]?: readonly TypeAnalysisNumericField<Entity>[];
+};
+export type TypeAnalysisSelectionAggrs<Aggrs extends TypeAnalysisAggrs> = {
+  readonly [K in keyof Aggrs]?: NonNullable<Aggrs[K]> extends readonly string[]
+    ? readonly NonNullable<Aggrs[K]>[number][]
+    : never;
+};
+export interface IAnalysisLimits {
+  readonly maxGroups: number;
+  readonly maxMetrics: number;
+  readonly maxGroupRows: number;
+}
+export interface IAnalysisSelection {
+  readonly groups?: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+}
+
+/** Structural server-owned policy surface; model references must not be serialized. */
+export interface IAnalysisPolicy {
+  readonly modelLike: TypeAnalysisModelLike;
+  readonly modelClass: Constructable<BeanModelMeta>;
+  readonly groups: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+  readonly defaults: {
+    readonly group?: IAnalysisSelection & { readonly groups: readonly string[] };
+    readonly aggregate?: { readonly aggrs: TypeAnalysisAggrs };
+  };
+  readonly limits: IAnalysisLimits;
+}
+export type TypeAnalysisPolicy<
+  ModelLike extends TypeAnalysisModelLike,
+  Groups extends readonly string[],
+  Aggrs extends TypeAnalysisAggrs,
+> = Omit<IAnalysisPolicy, 'modelLike' | 'groups' | 'aggrs'> & {
+  readonly modelLike: ModelLike;
+  readonly groups: Groups;
+  readonly aggrs: Aggrs;
+};
+export interface IAnalysisConfig<
+  Groups extends readonly string[],
+  Aggrs extends TypeAnalysisAggrs,
+> {
+  readonly groups: Groups;
+  readonly aggrs: Aggrs;
+  readonly defaults: {
+    readonly group?: {
+      readonly groups: readonly NoInfer<Groups[number]>[];
+      readonly aggrs: TypeAnalysisSelectionAggrs<NoInfer<Aggrs>>;
+    };
+    readonly aggregate?: { readonly aggrs: TypeAnalysisSelectionAggrs<NoInfer<Aggrs>> };
+  };
+  readonly limits?: Partial<IAnalysisLimits>;
+}
+
+interface IAnalysisParams<Policy extends IAnalysisPolicy> {
+  where?: TypeModelWhere<TypeAnalysisEntity<Policy['modelLike']>>;
+  aggrs?: TypeAnalysisSelectionAggrs<Policy['aggrs']>;
+  // Existing list controls remain accepted but never drive analysis execution.
+  columns?: unknown;
+  orders?: unknown;
+  limit?: number;
+  offset?: number;
+  pageNo?: number;
+  pageSize?: number;
+  joins?: never;
+  having?: never;
+  distinct?: never;
+  include?: never;
+  with?: never;
+}
+export type TypeAnalysisGroupParams<Policy extends IAnalysisPolicy> = IAnalysisParams<Policy> & {
+  groups?: readonly Policy['groups'][number][];
+};
+export type TypeAnalysisAggregateParams<Policy extends IAnalysisPolicy> =
+  IAnalysisParams<Policy> & {
+    groups?: never;
+  };
+
+type TypeAnalysisAlias<Column extends string> = Column extends '*' ? 'all' : Column;
+export type TypeAnalysisAggregateResult<Policy extends IAnalysisPolicy> = {
+  -readonly [
+    Fn in keyof Policy['aggrs'] &
+      TypeAnalysisFunction as Policy['aggrs'][Fn] extends readonly string[]
+      ? `${Fn}_${TypeAnalysisAlias<Policy['aggrs'][Fn][number]>}`
+      : never
+  ]?: Fn extends 'count' ? string : string | null;
+};
+export type TypeAnalysisGroupResult<Policy extends IAnalysisPolicy> = Partial<
+  Pick<
+    TypeAnalysisEntity<Policy['modelLike']>,
+    Extract<Policy['groups'][number], keyof TypeAnalysisEntity<Policy['modelLike']>>
+  >
+> &
+  TypeAnalysisAggregateResult<Policy>;
+
+export interface IAnalysisCapabilities {
+  readonly mode: TypeAnalysisMode;
+  readonly groups: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+  readonly defaults: IAnalysisSelection;
+  readonly limits: IAnalysisLimits;
+}
+
+export interface IResolvedAnalysis {
+  groups?: string[];
+  aggrs: Partial<Record<TypeAnalysisFunction, string[]>>;
+}

package/vona/src/suite-vendor/a-vona/modules/a-orm/src/types/index.ts

@@ -1,3 +1,4 @@
+export * from './analysis.ts';
 export * from './columns.ts';
 export * from './config.ts';
 export * from './database.ts';

package/vona/src/suite-vendor/a-vona/modules/a-orm/src/types/relationsAggr.ts

@@ -27,7 +27,7 @@ export type TypeUtilAggrPrepareColumns<TColumns> = TColumns extends string[]
     : undefined;
 export type TypeRecordAggrsValues<TRecord extends Record<string, any>> = TRecord[keyof TRecord];
 export type TypeRecordAggrsValuesToObject<AggrValues extends string> = {
-  [K in AggrValues]: string | undefined;
+  [K in AggrValues]: K extends `count_${string}` ? string | undefined : string | null | undefined;
 };
 
 export type TypeUtilGetAggrsFromRelationAndIncludeWrapper<

package/vona/src/suite-vendor/a-vona/modules/a-orm/test/aggregateResult.test.ts

@@ -0,0 +1,81 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { normalizeAggregateRows, normalizeAggregateValue } from '../src/lib/aggregateResult.ts';
+
+describe('ORM aggregate result adaptation', () => {
+  it('preserves driver strings and converts supported numeric scalars', () => {
+    for (const fn of ['count', 'sum', 'avg', 'min', 'max'] as const) {
+      for (const value of [0, 17, 17n, Number.MAX_SAFE_INTEGER, '900719925474099312345']) {
+        assert.equal(normalizeAggregateValue(value, fn), String(value));
+      }
+      assert.equal(normalizeAggregateValue(undefined, fn), undefined);
+      for (const value of [true, {}, new Date(), Number.NaN, Infinity, -Infinity]) {
+        assert.throws(() => normalizeAggregateValue(value, fn), TypeError);
+      }
+    }
+    for (const fn of ['sum', 'avg', 'min', 'max'] as const) {
+      for (const value of ['001.2300', '-12345678901234567890.12345', '1e-100', -1.25, -1n]) {
+        assert.equal(normalizeAggregateValue(value, fn), String(value));
+      }
+      assert.equal(normalizeAggregateValue(null, fn), null);
+    }
+  });
+
+  it('rejects invalid and already lossy count values', () => {
+    for (const value of [
+      null,
+      -1,
+      -1n,
+      1.5,
+      Number.MAX_SAFE_INTEGER + 1,
+      '',
+      '01',
+      '-1',
+      '+1',
+      ' 1',
+      '1 ',
+      '1.0',
+      '1e3',
+    ]) {
+      assert.throws(() => normalizeAggregateValue(value, 'count'), TypeError);
+    }
+  });
+
+  it('adapts only requested aliases without mutating cached rows', () => {
+    const unchanged = Object.freeze({ level: 2, count_all: '2', sum_age: null });
+    const legacy = Object.freeze({
+      level: 1,
+      count_all: 2,
+      avg_age: 1.25,
+      sum_age: null,
+      count_name: 7,
+    });
+    const rows = [unchanged, legacy];
+    const result = normalizeAggregateRows(rows, { count: '*', sum: 'age', avg: 'age' });
+    assert.notEqual(result, rows);
+    assert.equal(result[0], unchanged);
+    assert.notEqual(result[1], legacy);
+    assert.deepEqual(result[1], {
+      level: 1,
+      count_all: '2',
+      avg_age: '1.25',
+      sum_age: null,
+      count_name: 7,
+    });
+    assert.equal(legacy.count_all, 2);
+    assert.equal(normalizeAggregateRows(result, { count: '*', sum: 'age', avg: 'age' }), result);
+    assert.equal(normalizeAggregateRows(rows), rows);
+    assert.equal(normalizeAggregateRows(rows, {}), rows);
+  });
+
+  it('preserves absent and undefined aliases and supports column lists', () => {
+    const rows = [{ count_all: 0n, count_imageId: undefined, name: 'unchanged' }];
+    assert.deepEqual(normalizeAggregateRows(rows, { count: ['*', 'imageId', 'name'] }), [
+      { count_all: '0', count_imageId: undefined, name: 'unchanged' },
+    ]);
+    assert.equal(Object.hasOwn(rows[0], 'count_name'), false);
+    const empty: object[] = [];
+    assert.equal(normalizeAggregateRows(empty, { count: '*' }), empty);
+  });
+});

package/vona/src/suite-vendor/a-vona/modules/a-orm/test/analysis.test.ts

@@ -0,0 +1,208 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import type { IAnalysisPolicy } from '../src/types/analysis.ts';
+
+import {
+  AnalysisError,
+  analysisCapabilities,
+  analysisControlSchemas,
+  resolveAnalysis,
+} from '../src/lib/analysis/controls.ts';
+import { $executeAnalysisAggregate, $executeAnalysisGroup } from '../src/lib/analysis/execute.ts';
+
+class Model {
+  calls: unknown[] = [];
+  rows: object[] = [];
+  group(params: unknown) {
+    this.calls.push(params);
+    return Promise.resolve(this.rows);
+  }
+
+  aggregate(params: unknown) {
+    this.calls.push(params);
+    return Promise.resolve(this.rows[0]);
+  }
+}
+const policy = {
+  modelLike: Model,
+  modelClass: Model,
+  groups: ['level', 'category'],
+  aggrs: {
+    count: ['*', 'imageId'],
+    sum: ['amount'],
+    avg: ['amount'],
+    min: ['amount'],
+    max: ['amount'],
+  },
+  defaults: {
+    group: { groups: ['level'], aggrs: { count: ['*'] } },
+    aggregate: { aggrs: { count: ['*', 'imageId'] } },
+  },
+  limits: { maxGroups: 2, maxMetrics: 5, maxGroupRows: 2 },
+} as unknown as IAnalysisPolicy;
+const invalid = (run: () => unknown) =>
+  assert.throws(
+    run,
+    error => error instanceof AnalysisError && error.status === 422 && error.code === 422,
+  );
+
+describe('analysis controls', () => {
+  it('defaults each omitted control independently and canonicalizes policy order', () => {
+    assert.deepEqual(resolveAnalysis(policy, 'group'), {
+      groups: ['level'],
+      aggrs: { count: ['*'] },
+    });
+    assert.deepEqual(resolveAnalysis(policy, 'group', { groups: ['category'] }), {
+      groups: ['category'],
+      aggrs: { count: ['*'] },
+    });
+    assert.deepEqual(resolveAnalysis(policy, 'group', { aggrs: { sum: ['amount'] } }), {
+      groups: ['level'],
+      aggrs: { sum: ['amount'] },
+    });
+    assert.deepEqual(
+      resolveAnalysis(policy, 'group', {
+        groups: ['category', 'level'],
+        aggrs: { count: ['imageId', '*'] },
+      }),
+      { groups: ['level', 'category'], aggrs: { count: ['*', 'imageId'] } },
+    );
+    assert.deepEqual(resolveAnalysis(policy, 'aggregate'), { aggrs: { count: ['*', 'imageId'] } });
+  });
+
+  it('rejects empty, duplicated, unknown, qualified and malformed controls', () => {
+    for (const input of [
+      { groups: [] },
+      { groups: ['level', 'level'] },
+      { groups: ['unknown'] },
+      { groups: ['table.level'] },
+      { groups: 'level' },
+      { groups: '["level"]' },
+      { groups: [1] },
+      { groups: null },
+      { aggrs: '{"count":["*"]}' },
+      { aggrs: { count: '["*"]' } },
+      { aggrs: { count: '*' } },
+      { aggrs: { count: [1] } },
+      { aggrs: {} },
+      { aggrs: null },
+      { aggrs: [] },
+      { aggrs: { count: [] } },
+      { aggrs: { count: ['*', '*'] } },
+      { aggrs: { count: ['table.imageId'] } },
+      { aggrs: { count: ['unknown'] } },
+      { aggrs: { sum: ['imageId'] } },
+      { aggrs: { median: ['amount'] } },
+      { aggrs: { 'sql.count': ['*'] } },
+      { aggrs: { count: ['*'], avg: [] } },
+      { joins: [] },
+      { having: {} },
+      { distinct: false },
+      { include: {} },
+      { with: {} },
+      'not-an-object',
+      null,
+      [],
+    ])
+      invalid(() => resolveAnalysis(policy, 'group', input));
+    for (const groups of [[], ['level'], undefined, null])
+      invalid(() => resolveAnalysis(policy, 'aggregate', { groups }));
+    invalid(() => resolveAnalysis(policy, 'other' as never));
+  });
+
+  it('applies combined metric limits and refuses disabled actions', () => {
+    invalid(() =>
+      resolveAnalysis({ ...policy, limits: { ...policy.limits, maxGroups: 1 } }, 'group', {
+        groups: ['level', 'category'],
+      }),
+    );
+    invalid(() => resolveAnalysis(policy, 'aggregate', { aggrs: policy.aggrs }));
+    invalid(() =>
+      resolveAnalysis({ ...policy, defaults: { aggregate: policy.defaults.aggregate } }, 'group'),
+    );
+    assert.deepEqual(
+      resolveAnalysis(
+        { ...policy, groups: [], defaults: { aggregate: policy.defaults.aggregate } },
+        'aggregate',
+      ),
+      { aggrs: { count: ['*', 'imageId'] } },
+    );
+  });
+
+  it('exposes strict native schemas and only serializable public capabilities', () => {
+    const schemas = analysisControlSchemas(policy, 'group');
+    assert.equal(
+      schemas.selection.safeParse({ aggrs: { count: ['*'], unknown: ['amount'] } }).success,
+      false,
+    );
+    assert.equal(schemas.selection.safeParse({ extra: true }).success, false);
+    assert.equal(
+      analysisControlSchemas(policy, 'aggregate').selection.safeParse({ groups: ['level'] })
+        .success,
+      false,
+    );
+    assert.deepEqual(schemas.selection.parse({}), { groups: ['level'], aggrs: { count: ['*'] } });
+    const capabilities = analysisCapabilities(policy, 'group');
+    assert.deepEqual(JSON.parse(JSON.stringify(capabilities)), {
+      mode: 'group',
+      groups: ['level', 'category'],
+      aggrs: policy.aggrs,
+      defaults: policy.defaults.group,
+      limits: policy.limits,
+    });
+    assert.deepEqual(analysisCapabilities(policy, 'aggregate').groups, []);
+    (capabilities.groups as string[]).push('external');
+    assert.deepEqual(policy.groups, ['level', 'category']);
+  });
+});
+
+describe('analysis execution boundary', () => {
+  it('forwards only scoped where, resolved controls, canonical ordering and cap+1', async () => {
+    const model = new Model();
+    const where = { level: 1 };
+    model.rows = [
+      { level: 1, count_all: '2' },
+      { level: 2, count_all: '1' },
+    ];
+    const rows = await $executeAnalysisGroup(model as never, policy, {
+      where,
+      limit: 999,
+      offset: 99,
+      columns: ['secret'],
+      orders: [['secret', 'desc']],
+    });
+    assert.equal(rows, model.rows);
+    assert.deepEqual(model.calls, [
+      { where, groups: ['level'], aggrs: { count: ['*'] }, orders: [['level', 'asc']], limit: 3 },
+    ]);
+    model.calls = [];
+    model.rows = [{ count_all: '0', sum_amount: null }];
+    const item = await $executeAnalysisAggregate(model as never, policy, {
+      where,
+      aggrs: { count: ['*'], sum: ['amount'] },
+      limit: 1,
+    });
+    assert.equal(item, model.rows[0]);
+    assert.deepEqual(model.calls, [{ where, aggrs: { count: ['*'], sum: ['amount'] } }]);
+  });
+
+  it('rejects overflow, wrong models and invalid direct calls before execution', async () => {
+    const model = new Model();
+    model.rows = [{}, {}, {}];
+    await assert.rejects($executeAnalysisGroup(model as never, policy), AnalysisError);
+    model.calls = [];
+    await assert.rejects(
+      $executeAnalysisGroup(model as never, policy, { groups: [] }),
+      AnalysisError,
+    );
+    await assert.rejects(
+      $executeAnalysisAggregate(model as never, policy, { joins: [] } as never),
+      AnalysisError,
+    );
+    await assert.rejects($executeAnalysisAggregate({} as never, policy), AnalysisError);
+    assert.deepEqual(model.calls, []);
+    model.rows = [];
+    assert.deepEqual(await $executeAnalysisGroup(model as never, policy), []);
+  });
+});

package/vona/src/suite-vendor/a-vona/modules/a-orm/test/analysis.types.test.ts

@@ -0,0 +1,112 @@
+import type { BeanModelMeta } from '../src/lib/bean.model/bean.model_meta.ts';
+import type {
+  TypeAnalysisAggregateParams,
+  TypeAnalysisAggregateResult,
+  TypeAnalysisGroupParams,
+  TypeAnalysisGroupResult,
+} from '../src/types/analysis.ts';
+
+import { $defineAnalysis } from '../src/lib/analysis/policy.ts';
+
+function expectType<_T extends true>() {}
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+
+type Entity = {
+  id: string;
+  iid: number;
+  level: number;
+  amount?: number | null;
+  name: string;
+  description?: string | null;
+  imageId?: string;
+};
+declare const Model: new () => BeanModelMeta<Entity>;
+
+// Compile-time assertions only; the factory is never executed by this file.
+function checkAnalysisTypes() {
+  const policy = $defineAnalysis(() => Model, {
+    groups: ['level', 'description'],
+    aggrs: { count: ['*', 'imageId'], sum: ['amount'] },
+    defaults: {
+      group: { groups: ['level'], aggrs: { count: ['*'] } },
+      aggregate: { aggrs: { count: ['imageId'] } },
+    },
+  });
+  expectType<Equal<typeof policy.groups, readonly ['level', 'description']>>();
+  expectType<Equal<typeof policy.aggrs.count, readonly ['*', 'imageId']>>();
+  expectType<
+    Equal<
+      TypeAnalysisAggregateResult<typeof policy>,
+      { count_all?: string; count_imageId?: string; sum_amount?: string | null }
+    >
+  >();
+  expectType<
+    Equal<TypeAnalysisGroupResult<typeof policy>['description'], string | null | undefined>
+  >();
+  expectType<Equal<TypeAnalysisGroupResult<typeof policy>['level'], number | undefined>>();
+  const group: TypeAnalysisGroupParams<typeof policy> = {
+    groups: ['description'],
+    aggrs: { sum: ['amount'] },
+    where: { name: 'x' },
+  };
+  const aggregate: TypeAnalysisAggregateParams<typeof policy> = { aggrs: { count: ['imageId'] } };
+  void group;
+  void aggregate;
+  // @ts-expect-error unapproved group
+  const badGroup: TypeAnalysisGroupParams<typeof policy> = { groups: ['name'] };
+  // @ts-expect-error field was allowed for count, not sum
+  const badColumn: TypeAnalysisAggregateParams<typeof policy> = { aggrs: { sum: ['imageId'] } };
+  // @ts-expect-error aggregate has no group controls
+  const badAggregate: TypeAnalysisAggregateParams<typeof policy> = { groups: ['level'] };
+  // @ts-expect-error unknown function
+  const badFunction: TypeAnalysisAggregateParams<typeof policy> = { aggrs: { median: ['amount'] } };
+  void [badGroup, badColumn, badAggregate, badFunction];
+  $defineAnalysis(Model, {
+    groups: ['level'],
+    // @ts-expect-error non-count metrics must be numeric
+    aggrs: { sum: ['name'] },
+    defaults: { aggregate: { aggrs: {} } },
+  });
+  $defineAnalysis(Model, {
+    groups: ['level'],
+    // @ts-expect-error identity columns cannot be summed
+    aggrs: { sum: ['iid'] },
+    defaults: { aggregate: { aggrs: {} } },
+  });
+  $defineAnalysis(Model, {
+    // @ts-expect-error qualified columns are not physical field names
+    groups: ['table.level'],
+    aggrs: { count: ['*'] },
+    defaults: { aggregate: { aggrs: { count: ['*'] } } },
+  });
+  $defineAnalysis(Model, {
+    groups: [],
+    // @ts-expect-error unknown function
+    aggrs: { count: ['*'], median: ['level'] },
+    defaults: { aggregate: { aggrs: { count: ['*'] } } },
+  });
+  $defineAnalysis(Model, {
+    groups: ['level'],
+    aggrs: { count: ['*'] },
+    defaults: {
+      // @ts-expect-error defaults cannot widen the group allowlist
+      group: { groups: ['name'], aggrs: { count: ['*'] } },
+    },
+  });
+  $defineAnalysis(Model, {
+    groups: ['level'],
+    aggrs: { count: ['*'] },
+    // @ts-expect-error defaults cannot widen the metric allowlist
+    defaults: { aggregate: { aggrs: { count: ['imageId'] } } },
+  });
+  const readonlyConfig = {
+    groups: ['level'],
+    aggrs: { count: ['*'] },
+    defaults: { group: { groups: ['level'], aggrs: { count: ['*'] } } },
+  } as const;
+  const readonlyPolicy = $defineAnalysis(Model, readonlyConfig);
+  expectType<Equal<typeof readonlyPolicy.aggrs.count, readonly ['*']>>();
+  void [policy, readonlyPolicy];
+}
+void checkAnalysisTypes;

package/vona/src/suite-vendor/a-vona/modules/a-permission/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-permission",
-  "version": "5.1.36",
+  "version": "5.1.37",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-queue/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-queue",
-  "version": "5.1.17",
+  "version": "5.1.18",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-ratelimit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-ratelimit",
-  "version": "5.1.5",
+  "version": "5.1.6",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-vona/modules/a-user/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-user",
-  "version": "5.1.27",
+  "version": "5.1.28",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-web",
-  "version": "5.1.24",
+  "version": "5.1.25",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [