cabloy 5.1.248 → 5.1.250

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": [

package/vona/src/suite-vendor/a-vona/modules/a-web/src/.metadata/index.ts

@@ -1,4 +1,44 @@
 // eslint-disable
+/** filterTransform: begin */
+export * from '../bean/filterTransform.base.ts';
+export * from '../bean/filterTransform.dateRange.ts';
+import type { IFilterTransformOptionsBase } from '../bean/filterTransform.base.ts';
+import type { IFilterTransformOptionsDateRange } from '../bean/filterTransform.dateRange.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+
+    export interface IFilterTransformRecord {
+      'a-web:base': IFilterTransformOptionsBase;
+'a-web:dateRange': IFilterTransformOptionsDateRange;
+    }
+
+
+}
+declare module 'vona-module-a-web' {
+
+        export interface FilterTransformBase {
+          /** @internal */
+          get scope(): ScopeModuleAWeb;
+        }
+
+          export interface FilterTransformBase {
+            get $beanFullName(): 'a-web.filterTransform.base';
+            get $onionName(): 'a-web:base';
+            get $onionOptions(): IFilterTransformOptionsBase;
+          }
+
+        export interface FilterTransformDateRange {
+          /** @internal */
+          get scope(): ScopeModuleAWeb;
+        }
+
+          export interface FilterTransformDateRange {
+            get $beanFullName(): 'a-web.filterTransform.dateRange';
+            get $onionName(): 'a-web:dateRange';
+            get $onionOptions(): IFilterTransformOptionsDateRange;
+          }
+}
+/** filterTransform: end */
 /** pipe: begin */
 export * from '../bean/pipe.filter.ts';
 export * from '../bean/pipe.valid.ts';
@@ -167,46 +207,6 @@ declare module 'vona-module-a-web' {
           }
 }
 /** startup: end */
-/** filterTransform: begin */
-export * from '../bean/filterTransform.base.ts';
-export * from '../bean/filterTransform.dateRange.ts';
-import type { IFilterTransformOptionsBase } from '../bean/filterTransform.base.ts';
-import type { IFilterTransformOptionsDateRange } from '../bean/filterTransform.dateRange.ts';
-import 'vona-module-a-web';
-declare module 'vona-module-a-web' {
-
-    export interface IFilterTransformRecord {
-      'a-web:base': IFilterTransformOptionsBase;
-'a-web:dateRange': IFilterTransformOptionsDateRange;
-    }
-
-
-}
-declare module 'vona-module-a-web' {
-
-        export interface FilterTransformBase {
-          /** @internal */
-          get scope(): ScopeModuleAWeb;
-        }
-
-          export interface FilterTransformBase {
-            get $beanFullName(): 'a-web.filterTransform.base';
-            get $onionName(): 'a-web:base';
-            get $onionOptions(): IFilterTransformOptionsBase;
-          }
-
-        export interface FilterTransformDateRange {
-          /** @internal */
-          get scope(): ScopeModuleAWeb;
-        }
-
-          export interface FilterTransformDateRange {
-            get $beanFullName(): 'a-web.filterTransform.dateRange';
-            get $onionName(): 'a-web:dateRange';
-            get $onionOptions(): IFilterTransformOptionsDateRange;
-          }
-}
-/** filterTransform: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

package/vona/src/suite-vendor/a-vona/modules/a-web/src/bean/pipe.filter.ts

@@ -8,13 +8,15 @@ import type {
   ITableQuery,
   RouteHandlerArgumentMeta,
 } from 'vona-module-a-openapi';
+import type { IAnalysisPolicy, TypeAnalysisMode } from 'vona-module-a-orm';
 import type { ValidatorOptions } from 'vona-module-a-validation';
 
 import { isNil, isNilOrEmptyString } from '@cabloy/utils';
 import { ZodMetadata } from '@cabloy/zod-openapi';
 import { isNullableSchema } from '@cabloy/zod-query';
-import { BeanBase, beanFullNameFromOnionName, cast } from 'vona';
+import { BeanBase, beanFullNameFromOnionName, cast, runWithZodQueryCoercion } from 'vona';
 import { createArgumentPipe, Pipe } from 'vona-module-a-aspect';
+import { analysisFailure, resolveAnalysis } from 'vona-module-a-orm';
 
 import type {
   IFilterTransformRecord,
@@ -28,9 +30,13 @@ export type TypePipeFilterResult = TypeQueryParamsPatch;
 type TypeQueryJoin = NonNullable<TypeQueryParamsPatch['joins']>[number];
 
 export interface IPipeOptionsFilter
-  extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {}
+  extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+  analysis?: IAnalysisPolicy;
+  analysisMode?: TypeAnalysisMode;
+}
 
 const __FieldsSystem = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
+const __AnalysisControls = ['groups', 'aggrs', 'having', 'joins', 'distinct', 'include', 'with'];
 
 @Pipe<IPipeOptionsFilter>({
   // ValidatorOptions
@@ -53,6 +59,7 @@ export class PipeFilter
         `should specify the schema of pipeFilter: ${metadata.controller.name}.${metadata.method}#${metadata.index}`,
       );
     }
+    value = this._prepareAnalysisControls(value, options);
     // validateSchema
     value = (await this.bean.validator.validateSchema(
       options.schema,
@@ -66,6 +73,35 @@ export class PipeFilter
     return params;
   }
 
+  private _prepareAnalysisControls(value: TypePipeFilterData, options: IPipeOptionsFilter) {
+    if (!!options.analysis !== !!options.analysisMode) {
+      throw new Error('Analysis filter requires both a policy and an action mode');
+    }
+    if (!value || typeof value !== 'object') return value;
+    const prepared = { ...value };
+    for (const key of __AnalysisControls) {
+      if (!Object.hasOwn(value, key)) continue;
+      if (!options.analysisMode) analysisFailure(`Select does not support ${key}`);
+      if (key !== 'aggrs' && !(key === 'groups' && options.analysisMode === 'group')) {
+        analysisFailure(`Analysis ${options.analysisMode} does not support ${key}`);
+      }
+      if (typeof value[key] === 'string') {
+        try {
+          prepared[key] = JSON.parse(value[key]);
+        } catch {
+          analysisFailure(`Analysis ${key} must be valid JSON`);
+        }
+      }
+    }
+    if (options.analysis && options.analysisMode) {
+      // Validate native shapes before permissive generic query coercion runs.
+      runWithZodQueryCoercion(false, () =>
+        resolveAnalysis(options.analysis!, options.analysisMode!, prepared),
+      );
+    }
+    return prepared;
+  }
+
   private async _transform(value: TypePipeFilterData, options: IPipeOptionsFilter) {
     // 1. system: columns/where/orders/pageNo/pageSize
     const params = this._transformSystem(value);
@@ -76,6 +112,10 @@ export class PipeFilter
     await this._transformFields(params, value, options, rootOpenapi);
     // 3. system: orders
     this._transformOrders(params, options, rootOpenapi);
+    if (options.analysis && options.analysisMode) {
+      if (params.joins?.length) analysisFailure('Analysis does not support joined filters');
+      Object.assign(params, resolveAnalysis(options.analysis, options.analysisMode, value));
+    }
     // ok
     return params;
   }
@@ -188,7 +228,8 @@ export class PipeFilter
     options: IPipeOptionsFilter,
     rootOpenapi: ISchemaObjectExtensionField | undefined,
   ) {
-    if (__FieldsSystem.includes(key)) return;
+    if (__FieldsSystem.includes(key) || (options.analysisMode && __AnalysisControls.includes(key)))
+      return;
     const info = this._resolveField(key, options, rootOpenapi);
     if (!info) return;
     const { fieldSchema, fieldSchemaInner, openapi, originalName, fullName, joinInfo } = info;