@ahoo-wang/wow-client 9.2.0-rc.0

package/dist/dsl/aggregation/builders.es.js

@@ -0,0 +1,188 @@
+import { AggregationDatePart as e, AggregationDateUnit as t, AggregationExpressionOperator as n, AggregationExpressionType as r, AggregationFunction as i, AggregationGroupType as a, AggregationMetricType as o, DateDiffUnit as s } from "./types.es.js";
+import { requireValidExpressionTrees as c } from "./expressionTrees.es.js";
+import { queryField as l } from "../field.es.js";
+import { requireElementScopedFilter as u } from "../filter/scope.es.js";
+import { admitAggregationQuery as d } from "./admit.es.js";
+import { derivedExpressionDsl as f } from "./derived.es.js";
+import { havingDsl as p } from "./having.es.js";
+//#region src/dsl/aggregation/builders.ts
+function m(e) {
+	return l(e);
+}
+function h(e) {
+	if (m(e), e.includes(".")) throw TypeError("aggregation alias must contain one segment.");
+	if (e.startsWith("__wow")) throw TypeError("aggregation alias must not use the reserved __wow prefix.");
+	return e;
+}
+function g(e, t, n) {
+	return {
+		type: r.BINARY,
+		operator: e,
+		left: t,
+		right: n
+	};
+}
+function _(e, t, n, { filter: r } = {}) {
+	return {
+		type: o.NUMERIC,
+		...r === void 0 ? {} : { filter: r },
+		function: e,
+		expression: t,
+		alias: h(n)
+	};
+}
+function v(e, t, n, { orderBy: r, filter: i }) {
+	return {
+		type: e,
+		field: m(t),
+		alias: h(n),
+		...r === void 0 ? {} : { orderBy: m(r) },
+		...i === void 0 ? {} : { filter: i }
+	};
+}
+function y(e, t) {
+	if (typeof e == "string") return { field: m(e) };
+	if (typeof e != "object" || !e) throw TypeError(`${t} group requires exactly one of field and expression.`);
+	return c([e]), { expression: e };
+}
+var b = {
+	element(e, t) {
+		let n = m(e);
+		return t === void 0 ? { path: n } : (u(t, "Aggregation element filter", !1), {
+			path: n,
+			filter: t
+		});
+	},
+	field(e) {
+		return {
+			type: r.FIELD,
+			field: m(e)
+		};
+	},
+	constant(e) {
+		if (!Number.isFinite(e)) throw TypeError("aggregation constant must be finite.");
+		return {
+			type: r.CONSTANT,
+			value: e
+		};
+	},
+	dateDiff(e, t, n) {
+		if (!Object.values(s).includes(n)) throw TypeError("date diff unit is invalid.");
+		return {
+			type: r.DATE_DIFF,
+			from: m(e),
+			to: m(t),
+			unit: n
+		};
+	},
+	add: (e, t) => g(n.ADD, e, t),
+	subtract: (e, t) => g(n.SUBTRACT, e, t),
+	multiply: (e, t) => g(n.MULTIPLY, e, t),
+	divide: (e, t) => g(n.DIVIDE, e, t),
+	terms(e, t, { missingKey: n } = {}) {
+		if (n !== void 0 && (typeof n != "string" || !n.trim())) throw TypeError("terms missingKey must not be blank.");
+		let r = y(e, "TERMS");
+		if (n !== void 0 && r.expression) throw TypeError("terms missingKey requires a field input.");
+		return {
+			type: a.TERMS,
+			...n === void 0 ? {} : { missingKey: n },
+			...r,
+			alias: h(t)
+		};
+	},
+	histogram(e, t, { interval: n }) {
+		if (!Number.isFinite(n) || n <= 0) throw TypeError("histogram interval must be finite and greater than 0.");
+		return {
+			type: a.HISTOGRAM,
+			...y(e, "HISTOGRAM"),
+			interval: n,
+			alias: h(t)
+		};
+	},
+	dateHistogram(e, n, { unit: r, timeZone: i = "UTC", dense: o }) {
+		if (o !== void 0 && typeof o != "boolean") throw TypeError("date histogram dense must be boolean.");
+		if (!Object.values(t).includes(r)) throw TypeError("date histogram unit is invalid.");
+		if (typeof i != "string" || !i.trim()) throw TypeError("date histogram timeZone cannot be blank.");
+		return {
+			type: a.DATE_HISTOGRAM,
+			...o === void 0 ? {} : { dense: o },
+			field: m(e),
+			unit: r,
+			alias: h(n),
+			timeZone: i
+		};
+	},
+	datePart(t, n, { part: r, timeZone: i = "UTC", dense: o }) {
+		if (o !== void 0 && typeof o != "boolean") throw TypeError("date part dense must be boolean.");
+		if (!Object.values(e).includes(r)) throw TypeError("date part is invalid.");
+		if (typeof i != "string" || !i.trim()) throw TypeError("date part timeZone cannot be blank.");
+		return {
+			type: a.DATE_PART,
+			...o === void 0 ? {} : { dense: o },
+			field: m(t),
+			part: r,
+			alias: h(n),
+			timeZone: i
+		};
+	},
+	any(e, t, { filter: n } = {}) {
+		return {
+			type: o.ANY,
+			...n === void 0 ? {} : { filter: n },
+			field: m(e),
+			alias: h(t)
+		};
+	},
+	first(e, t, n = {}) {
+		return v(o.FIRST, e, t, n);
+	},
+	last(e, t, n = {}) {
+		return v(o.LAST, e, t, n);
+	},
+	count(e, { filter: t } = {}) {
+		return {
+			type: o.COUNT,
+			...t === void 0 ? {} : { filter: t },
+			alias: h(e)
+		};
+	},
+	sum: (e, t, n) => _(i.SUM, e, t, n),
+	avg: (e, t, n) => _(i.AVG, e, t, n),
+	min: (e, t, n) => _(i.MIN, e, t, n),
+	max: (e, t, n) => _(i.MAX, e, t, n),
+	stddev: (e, t, n) => _(i.STDDEV, e, t, n),
+	variance: (e, t, n) => _(i.VARIANCE, e, t, n),
+	distinctCount(e, t, { filter: n } = {}) {
+		return {
+			type: o.DISTINCT_COUNT,
+			expression: e,
+			alias: h(t),
+			...n === void 0 ? {} : { filter: n }
+		};
+	},
+	percentile(e, t, { percentile: n, filter: r }) {
+		if (!Number.isFinite(n) || n <= 0 || n >= 100) throw TypeError("percentile must be finite and within (0, 100).");
+		return {
+			type: o.PERCENTILE,
+			expression: e,
+			percentile: n,
+			alias: h(t),
+			...r === void 0 ? {} : { filter: r }
+		};
+	},
+	derived(e, t) {
+		return {
+			type: o.DERIVED,
+			expression: typeof e == "function" ? e(f) : e,
+			alias: h(t)
+		};
+	},
+	having: p,
+	query(e) {
+		return d(e);
+	}
+};
+//#endregion
+export { b as aggregation };
+
+//# sourceMappingURL=builders.es.js.map

package/dist/dsl/aggregation/builders.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.es.js","names":["aggregationField","queryField","field","aggregationAlias","alias","binary","AggregationExpressionType","numeric","predicate","AggregationMetricType","fn","edge","orderBy","groupInput","input","type","requireValidExpressionTrees","aggregation","validPath","path","requireElementScopedFilter","value","DateDiffUnit","unit","from","to","AggregationExpressionOperator","left","right","missingKey","source","AggregationGroupType","interval","dense","AggregationDateUnit","timeZone","AggregationDatePart","part","options","AggregationFunction","expression","percentile","derivedExpressionDsl","havingDsl","admitAggregationQuery","query"],"sources":["../../../src/dsl/aggregation/builders.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { queryField } from '../field.js';\nimport type {\n  ElementFilterExpression,\n  ExpressionFilter,\n} from '../filter/index.js';\nimport { requireElementScopedFilter } from '../filter/scope.js';\nimport { admitAggregationQuery } from './admit.js';\nimport { requireValidExpressionTrees } from './expressionTrees.js';\nimport { derivedExpressionDsl, type DerivedExpressionDsl } from './derived.js';\nimport { havingDsl } from './having.js';\nimport {\n  DateDiffUnit,\n  AggregationDatePart,\n  AggregationDateUnit,\n  AggregationExpressionOperator,\n  AggregationExpressionType,\n  AggregationFunction,\n  AggregationGroupType,\n  AggregationMetricType,\n  type AggregationElement,\n  type AggregationExpression,\n  type AggregationGroupInput,\n  type DateDiffAggregationExpression,\n  type AggregationMetricOptions,\n  type AggregationQuery,\n  type AnyAggregationMetric,\n  type EdgeAggregationMetric,\n  type EdgeAggregationOptions,\n  type BinaryAggregationExpression,\n  type ConstantAggregationExpression,\n  type CountAggregationMetric,\n  type DateHistogramAggregationGroup,\n  type DateHistogramAggregationOptions,\n  type DatePartAggregationGroup,\n  type DatePartAggregationOptions,\n  type DerivedAggregationMetric,\n  type DerivedExpression,\n  type DistinctCountAggregationMetric,\n  type FieldAggregationExpression,\n  type HistogramAggregationGroup,\n  type HistogramAggregationOptions,\n  type NumericAggregationMetric,\n  type PercentileAggregationMetric,\n  type PercentileAggregationOptions,\n  type TermsAggregationGroup,\n  type TermsAggregationOptions,\n} from './types.js';\n\nfunction aggregationField<FIELDS extends string>(field: FIELDS): FIELDS {\n  return queryField(field);\n}\n\nfunction aggregationAlias(alias: string): string {\n  aggregationField(alias);\n  if (alias.includes('.')) {\n    throw new TypeError('aggregation alias must contain one segment.');\n  }\n  if (alias.startsWith('__wow')) {\n    throw new TypeError(\n      'aggregation alias must not use the reserved __wow prefix.',\n    );\n  }\n  return alias;\n}\n\nfunction binary<FIELDS extends string>(\n  operator: AggregationExpressionOperator,\n  left: AggregationExpression<FIELDS>,\n  right: AggregationExpression<FIELDS>,\n): BinaryAggregationExpression<FIELDS> {\n  return { type: AggregationExpressionType.BINARY, operator, left, right };\n}\n\nfunction numeric<FIELDS extends string>(\n  fn: AggregationFunction,\n  expression: AggregationExpression<FIELDS>,\n  alias: string,\n  { filter: predicate }: AggregationMetricOptions<FIELDS> = {},\n): NumericAggregationMetric<FIELDS> {\n  return {\n    type: AggregationMetricType.NUMERIC,\n    ...(predicate === undefined ? {} : { filter: predicate }),\n    function: fn,\n    expression,\n    alias: aggregationAlias(alias),\n  };\n}\n\n/** Builds a `FIRST` or `LAST` metric; {@link aggregation.first}. */\nfunction edge<FIELDS extends string>(\n  type: AggregationMetricType.FIRST | AggregationMetricType.LAST,\n  field: FIELDS,\n  alias: string,\n  { orderBy, filter: predicate }: EdgeAggregationOptions<FIELDS>,\n): EdgeAggregationMetric<FIELDS> {\n  return {\n    type,\n    field: aggregationField(field),\n    alias: aggregationAlias(alias),\n    ...(orderBy === undefined ? {} : { orderBy: aggregationField(orderBy) }),\n    ...(predicate === undefined ? {} : { filter: predicate }),\n  };\n}\n\n/**\n * The input of a TERMS or HISTOGRAM group: a field path, or an expression in\n * its place, never both, as Wow's `requireGroupInput` has it.\n */\nfunction groupInput<FIELDS extends string>(\n  input: FIELDS | AggregationExpression<FIELDS>,\n  type: string,\n): AggregationGroupInput<FIELDS> {\n  if (typeof input === 'string') return { field: aggregationField(input) };\n  if (input === null || typeof input !== 'object') {\n    throw new TypeError(\n      `${type} group requires exactly one of field and expression.`,\n    );\n  }\n  requireValidExpressionTrees([input]);\n  return { expression: input };\n}\n\n/**\n * Builders of an `AggregationQuery`: its elements, groups, metrics and the\n * arithmetic expressions metrics compute over. Each builder checks its own\n * part and throws a `TypeError` naming what is wrong; {@link aggregation.query}\n * checks the parts against each other.\n *\n * Every group and metric takes its target first, its alias second, and any\n * further options as a trailing object.\n */\nexport const aggregation = {\n  /**\n   * Aggregates over the elements of an array field instead of the root\n   * documents. `{ path, filter? }`.\n   *\n   * @param path - The array field, a query field path.\n   * @param predicate - Keeps only the elements that match; may not contain\n   *   root filters (id, owner, tenant, space, deletion) or any search, even\n   *   one that names its fields. An `EXPRESSION` filter is allowed.\n   * @throws TypeError when `path` is not a valid field path or `predicate`\n   *   contains a root filter.\n   * @example\n   * ```typescript\n   * aggregation.element('items', filter.gt('quantity', 0));\n   * ```\n   */\n  element(\n    path: string,\n    predicate?: ElementFilterExpression | ExpressionFilter,\n  ): AggregationElement {\n    const validPath = aggregationField(path);\n    if (predicate === undefined) return { path: validPath };\n    requireElementScopedFilter(predicate, 'Aggregation element filter', false);\n    return { path: validPath, filter: predicate };\n  },\n  /**\n   * The value of a field, as an operand. `{ type: 'FIELD', field }`.\n   *\n   * @throws TypeError when `field` is not a valid field path.\n   * @example\n   * ```typescript\n   * aggregation.sum(aggregation.field('state.amount'), 'amount');\n   * ```\n   */\n  field<FIELDS extends string>(\n    field: FIELDS,\n  ): FieldAggregationExpression<FIELDS> {\n    return {\n      type: AggregationExpressionType.FIELD,\n      field: aggregationField(field),\n    };\n  },\n  /**\n   * A number, as an operand. `{ type: 'CONSTANT', value }`.\n   *\n   * @throws TypeError when `value` is not finite.\n   * @example\n   * ```typescript\n   * aggregation.multiply(aggregation.field('price'), aggregation.constant(100));\n   * ```\n   */\n  constant(value: number): ConstantAggregationExpression {\n    if (!Number.isFinite(value)) {\n      throw new TypeError('aggregation constant must be finite.');\n    }\n    return { type: AggregationExpressionType.CONSTANT, value };\n  },\n  /**\n   * The time from the instant in `from` to the instant in `to`, `to − from`,\n   * in `unit`, as a signed decimal: negative when `to` is earlier, and no\n   * value when either instant is absent. A `DAY` is exactly 24 hours.\n   * `{ type: 'DATE_DIFF', from, to, unit }`. Both fields must be\n   * single-valued time fields, those whose `aggregate.groups` list\n   * `DATE_HISTOGRAM` in the descriptor, and `unit` one of its\n   * `analysis.dateDiffUnits`. Wow 9.2 and later.\n   *\n   * @throws TypeError when `from` or `to` is not a valid field path, or\n   *   `unit` is not a {@link DateDiffUnit}.\n   * @example\n   * ```typescript\n   * // Hours from payment to shipping, averaged per warehouse.\n   * aggregation.avg(\n   *   aggregation.dateDiff('state.paidAt', 'state.shippedAt', DateDiffUnit.HOUR),\n   *   'hoursToShip',\n   * );\n   * ```\n   */\n  dateDiff<FIELDS extends string>(\n    from: FIELDS,\n    to: FIELDS,\n    unit: DateDiffUnit,\n  ): DateDiffAggregationExpression<FIELDS> {\n    if (!Object.values(DateDiffUnit).includes(unit)) {\n      throw new TypeError('date diff unit is invalid.');\n    }\n    return {\n      type: AggregationExpressionType.DATE_DIFF,\n      from: aggregationField(from),\n      to: aggregationField(to),\n      unit,\n    };\n  },\n  /** `left + right`. `{ type: 'BINARY', operator: 'ADD', left, right }`. */\n  add: <FIELDS extends string>(\n    left: AggregationExpression<FIELDS>,\n    right: AggregationExpression<FIELDS>,\n  ) => binary(AggregationExpressionOperator.ADD, left, right),\n  /** `left - right`. `{ type: 'BINARY', operator: 'SUBTRACT', left, right }`. */\n  subtract: <FIELDS extends string>(\n    left: AggregationExpression<FIELDS>,\n    right: AggregationExpression<FIELDS>,\n  ) => binary(AggregationExpressionOperator.SUBTRACT, left, right),\n  /** `left * right`. `{ type: 'BINARY', operator: 'MULTIPLY', left, right }`. */\n  multiply: <FIELDS extends string>(\n    left: AggregationExpression<FIELDS>,\n    right: AggregationExpression<FIELDS>,\n  ) => binary(AggregationExpressionOperator.MULTIPLY, left, right),\n  /** `left / right`. `{ type: 'BINARY', operator: 'DIVIDE', left, right }`. */\n  divide: <FIELDS extends string>(\n    left: AggregationExpression<FIELDS>,\n    right: AggregationExpression<FIELDS>,\n  ) => binary(AggregationExpressionOperator.DIVIDE, left, right),\n  /**\n   * Groups by each distinct value of a field, or of a computed expression.\n   * `{ type: 'TERMS', field, alias, missingKey? }`, or\n   * `{ type: 'TERMS', expression, alias }`.\n   *\n   * @param input - The field to group by, or an expression in its place\n   *   (Wow 9.2 and later, an expensive computation).\n   * @param alias - The name of the group column in the result rows.\n   * @param options.missingKey - The key of the rows without a value; only\n   *   with a field.\n   * @throws TypeError when `input` or `alias` is invalid, `missingKey` is\n   *   blank, or `missingKey` is given with an expression.\n   * @example\n   * ```typescript\n   * aggregation.terms('state.status', 'status', { missingKey: 'NONE' });\n   * aggregation.terms(\n   *   aggregation.dateDiff('state.paidAt', 'state.shippedAt', DateDiffUnit.DAY),\n   *   'daysToShip',\n   * );\n   * ```\n   */\n  terms<FIELDS extends string>(\n    input: FIELDS | AggregationExpression<FIELDS>,\n    alias: string,\n    { missingKey }: TermsAggregationOptions = {},\n  ): TermsAggregationGroup<FIELDS> {\n    if (\n      missingKey !== undefined &&\n      (typeof missingKey !== 'string' || !missingKey.trim())\n    ) {\n      throw new TypeError('terms missingKey must not be blank.');\n    }\n    const source = groupInput(input, 'TERMS');\n    if (missingKey !== undefined && source.expression) {\n      throw new TypeError('terms missingKey requires a field input.');\n    }\n    return {\n      type: AggregationGroupType.TERMS,\n      ...(missingKey === undefined ? {} : { missingKey }),\n      ...source,\n      alias: aggregationAlias(alias),\n    };\n  },\n  /**\n   * Groups a number field, or a computed expression, into buckets of equal\n   * width. `{ type: 'HISTOGRAM', field | expression, interval, alias }`.\n   *\n   * @param input - The number field to bucket, or an expression in its\n   *   place (Wow 9.2 and later, an expensive computation).\n   * @param alias - The name of the bucket column in the result rows.\n   * @param options.interval - The bucket width.\n   * @throws TypeError when `interval` is not finite and greater than 0, or\n   *   `field` or `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.histogram('state.amount', 'amountBand', { interval: 100 });\n   * ```\n   */\n  histogram<FIELDS extends string>(\n    input: FIELDS | AggregationExpression<FIELDS>,\n    alias: string,\n    { interval }: HistogramAggregationOptions,\n  ): HistogramAggregationGroup<FIELDS> {\n    if (!Number.isFinite(interval) || interval <= 0) {\n      throw new TypeError(\n        'histogram interval must be finite and greater than 0.',\n      );\n    }\n    return {\n      type: AggregationGroupType.HISTOGRAM,\n      ...groupInput(input, 'HISTOGRAM'),\n      interval,\n      alias: aggregationAlias(alias),\n    };\n  },\n  /**\n   * Groups a time field into calendar buckets.\n   * `{ type: 'DATE_HISTOGRAM', field, unit, alias, timeZone, dense? }`.\n   *\n   * @param field - The time field (epoch milliseconds) to bucket.\n   * @param alias - The name of the bucket column in the result rows.\n   * @param options.unit - The calendar unit of a bucket.\n   * @param options.timeZone - The zone buckets are cut in. Defaults to `UTC`.\n   * @param options.dense - Whether the empty buckets of the range are filled\n   *   in.\n   * @throws TypeError when `unit` is not an `AggregationDateUnit`,\n   *   `timeZone` is blank, `dense` is not a boolean, or `field` or `alias` is\n   *   invalid.\n   * @example\n   * ```typescript\n   * aggregation.dateHistogram('createTime', 'day', {\n   *   unit: AggregationDateUnit.DAY,\n   *   timeZone: 'Asia/Shanghai',\n   * });\n   * ```\n   */\n  dateHistogram<FIELDS extends string>(\n    field: FIELDS,\n    alias: string,\n    { unit, timeZone = 'UTC', dense }: DateHistogramAggregationOptions,\n  ): DateHistogramAggregationGroup<FIELDS> {\n    if (dense !== undefined && typeof dense !== 'boolean') {\n      throw new TypeError('date histogram dense must be boolean.');\n    }\n    if (!Object.values(AggregationDateUnit).includes(unit)) {\n      throw new TypeError('date histogram unit is invalid.');\n    }\n    if (typeof timeZone !== 'string' || !timeZone.trim()) {\n      throw new TypeError('date histogram timeZone cannot be blank.');\n    }\n    return {\n      type: AggregationGroupType.DATE_HISTOGRAM,\n      ...(dense === undefined ? {} : { dense }),\n      field: aggregationField(field),\n      unit,\n      alias: aggregationAlias(alias),\n      timeZone,\n    };\n  },\n  /**\n   * Groups a time field by one calendar part of each instant, such as the\n   * weekday or the hour, so records from different days share a bucket.\n   * `{ type: 'DATE_PART', field, part, alias, timeZone, dense? }`.\n   *\n   * The group's keys in the result rows are integers: `DAY_OF_WEEK` is the\n   * ISO weekday, 1 (Monday) to 7 (Sunday); `DAY_OF_MONTH` 1 to 31;\n   * `HOUR_OF_DAY` 0 to 23 on the wall clock of `timeZone`; `MONTH_OF_YEAR`\n   * 1 to 12. With `dense`, every key of that domain comes back, those\n   * without records carrying each metric's empty value; `dense` needs the\n   * group to be the query's only one. Wow 9.2 and later.\n   *\n   * @param field - The time field (epoch milliseconds) to read the part of.\n   * @param alias - The name of the part column in the result rows.\n   * @param options.part - The calendar part to group by.\n   * @param options.timeZone - The zone the part is read in. Defaults to\n   *   `UTC`.\n   * @param options.dense - Whether every key of the part's domain is\n   *   returned.\n   * @throws TypeError when `part` is not an `AggregationDatePart`,\n   *   `timeZone` is blank, `dense` is not a boolean, or `field` or `alias` is\n   *   invalid.\n   * @example\n   * ```typescript\n   * aggregation.datePart('createTime', 'weekday', {\n   *   part: AggregationDatePart.DAY_OF_WEEK,\n   *   timeZone: 'Asia/Shanghai',\n   * });\n   * ```\n   */\n  datePart<FIELDS extends string>(\n    field: FIELDS,\n    alias: string,\n    { part, timeZone = 'UTC', dense }: DatePartAggregationOptions,\n  ): DatePartAggregationGroup<FIELDS> {\n    if (dense !== undefined && typeof dense !== 'boolean') {\n      throw new TypeError('date part dense must be boolean.');\n    }\n    if (!Object.values(AggregationDatePart).includes(part)) {\n      throw new TypeError('date part is invalid.');\n    }\n    if (typeof timeZone !== 'string' || !timeZone.trim()) {\n      throw new TypeError('date part timeZone cannot be blank.');\n    }\n    return {\n      type: AggregationGroupType.DATE_PART,\n      ...(dense === undefined ? {} : { dense }),\n      field: aggregationField(field),\n      part,\n      alias: aggregationAlias(alias),\n      timeZone,\n    };\n  },\n  /**\n   * Any one value of a field within each group, of any type.\n   * `{ type: 'ANY', field, alias, filter? }`.\n   *\n   * @throws TypeError when `field` or `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.any('state.customerName', 'customer');\n   * ```\n   */\n  any<FIELDS extends string>(\n    field: FIELDS,\n    alias: string,\n    { filter: predicate }: AggregationMetricOptions<FIELDS> = {},\n  ): AnyAggregationMetric<FIELDS> {\n    return {\n      type: AggregationMetricType.ANY,\n      ...(predicate === undefined ? {} : { filter: predicate }),\n      field: aggregationField(field),\n      alias: aggregationAlias(alias),\n    };\n  },\n  /**\n   * The value of `field` on each group's earliest record by `orderBy`.\n   * `{ type: 'FIRST', field, alias, orderBy?, filter? }`.\n   *\n   * The value comes back in the field's own type, or `null` when no record\n   * of the group has both a value and an `orderBy` position. Without\n   * `orderBy` the server orders by the model's event time, which the\n   * descriptor names as `analysis.firstLastOrderBy`. Neither a derived\n   * metric nor `having` may refer to it. Wow 9.2 and later.\n   *\n   * @throws TypeError when `field`, `orderBy` or `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.first('state.price', 'open', { orderBy: 'createTime' });\n   * ```\n   */\n  first<FIELDS extends string>(\n    field: FIELDS,\n    alias: string,\n    options: EdgeAggregationOptions<FIELDS> = {},\n  ): EdgeAggregationMetric<FIELDS> {\n    return edge(AggregationMetricType.FIRST, field, alias, options);\n  },\n  /**\n   * The value of `field` on each group's latest record by `orderBy`.\n   * `{ type: 'LAST', field, alias, orderBy?, filter? }`. As\n   * {@link aggregation.first}, from the other end.\n   *\n   * @throws TypeError when `field`, `orderBy` or `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.last('state.price', 'close', { orderBy: 'createTime' });\n   * ```\n   */\n  last<FIELDS extends string>(\n    field: FIELDS,\n    alias: string,\n    options: EdgeAggregationOptions<FIELDS> = {},\n  ): EdgeAggregationMetric<FIELDS> {\n    return edge(AggregationMetricType.LAST, field, alias, options);\n  },\n  /**\n   * The number of rows in each group. `{ type: 'COUNT', alias, filter? }`.\n   *\n   * @param alias - The name of the metric column in the result rows.\n   * @param options.filter - Counts only the rows that match.\n   * @throws TypeError when `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.count('paid', { filter: filter.eq('state.status', 'PAID') });\n   * ```\n   */\n  count<FIELDS extends string = string>(\n    alias: string,\n    { filter: predicate }: AggregationMetricOptions<FIELDS> = {},\n  ): CountAggregationMetric<FIELDS> {\n    return {\n      type: AggregationMetricType.COUNT,\n      ...(predicate === undefined ? {} : { filter: predicate }),\n      alias: aggregationAlias(alias),\n    };\n  },\n  /**\n   * The sum of an expression. `{ type: 'NUMERIC', function: 'SUM',\n   * expression, alias, filter? }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.sum(aggregation.field('state.amount'), 'revenue');\n   * ```\n   */\n  sum: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.SUM, expression, alias, options),\n  /** The average of an expression; see {@link aggregation.sum}. */\n  avg: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.AVG, expression, alias, options),\n  /** The least value of an expression; see {@link aggregation.sum}. */\n  min: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.MIN, expression, alias, options),\n  /** The greatest value of an expression; see {@link aggregation.sum}. */\n  max: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.MAX, expression, alias, options),\n  /** The standard deviation of an expression; see {@link aggregation.sum}. */\n  stddev: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.STDDEV, expression, alias, options),\n  /** The variance of an expression; see {@link aggregation.sum}. */\n  variance: <FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    options?: AggregationMetricOptions<FIELDS>,\n  ) => numeric(AggregationFunction.VARIANCE, expression, alias, options),\n  /**\n   * The number of distinct values of an expression.\n   * `{ type: 'DISTINCT_COUNT', expression, alias, filter? }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.distinctCount(aggregation.field('ownerId'), 'customers');\n   * ```\n   */\n  distinctCount<FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    { filter: predicate }: AggregationMetricOptions<FIELDS> = {},\n  ): DistinctCountAggregationMetric<FIELDS> {\n    return {\n      type: AggregationMetricType.DISTINCT_COUNT,\n      expression,\n      alias: aggregationAlias(alias),\n      ...(predicate === undefined ? {} : { filter: predicate }),\n    };\n  },\n  /**\n   * A percentile of an expression.\n   * `{ type: 'PERCENTILE', expression, percentile, alias, filter? }`.\n   *\n   * @param options.percentile - Which percentile, within (0, 100).\n   * @throws TypeError when `percentile` is not finite and within (0, 100), or\n   *   `alias` is invalid.\n   * @example\n   * ```typescript\n   * aggregation.percentile(aggregation.field('latency'), 'p95', { percentile: 95 });\n   * ```\n   */\n  percentile<FIELDS extends string>(\n    expression: AggregationExpression<FIELDS>,\n    alias: string,\n    { percentile, filter: predicate }: PercentileAggregationOptions<FIELDS>,\n  ): PercentileAggregationMetric<FIELDS> {\n    if (!Number.isFinite(percentile) || percentile <= 0 || percentile >= 100) {\n      throw new TypeError('percentile must be finite and within (0, 100).');\n    }\n    return {\n      type: AggregationMetricType.PERCENTILE,\n      expression,\n      percentile,\n      alias: aggregationAlias(alias),\n      ...(predicate === undefined ? {} : { filter: predicate }),\n    };\n  },\n  /**\n   * A metric computed from other metrics of the same row, by their aliases.\n   * `{ type: 'DERIVED', expression, alias }`. `aggregation.query()` checks\n   * that it refers only to metrics declared before it.\n   *\n   * @param expression - The arithmetic: a callback that builds it from the\n   *   {@link DerivedExpressionDsl} it is handed (`ref`, `constant`, `add`,\n   *   `subtract`, `multiply`, `divide`), or an already-built tree.\n   * @throws TypeError when `alias` is invalid, or a `constant` is not finite.\n   * @example\n   * ```typescript\n   * aggregation.derived(\n   *   d => d.divide(d.ref('revenue'), d.ref('orders')),\n   *   'averageOrder',\n   * );\n   * ```\n   */\n  derived(\n    expression:\n      DerivedExpression | ((d: DerivedExpressionDsl) => DerivedExpression),\n    alias: string,\n  ): DerivedAggregationMetric {\n    return {\n      type: AggregationMetricType.DERIVED,\n      expression:\n        typeof expression === 'function'\n          ? expression(derivedExpressionDsl)\n          : expression,\n      alias: aggregationAlias(alias),\n    };\n  },\n  /**\n   * The builders of the query's `having`: conditions on the metric columns of\n   * the grouped rows (`eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `between`, `isIn`,\n   * `isNull`, `isNotNull`) and their `and`/`or`. See `HavingDsl`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.query({\n   *   groupBy: [aggregation.terms('state.status', 'status')],\n   *   metrics: [aggregation.count('orders')],\n   *   having: aggregation.having.gt('orders', 10),\n   * });\n   * ```\n   */\n  having: havingDsl,\n\n  /**\n   * Admits a whole aggregation query against the rules Wow enforces on arrival.\n   *\n   * The factories above each check their own part; only the assembled query\n   * can answer the questions that span parts — whether two aliases collide,\n   * whether a sort names one of them, whether `having` has rows to filter.\n   * Wow checks all of it in `AggregationQuery`'s constructor and answers a\n   * query that fails with a 400, so the same rules run here against the object\n   * about to be sent.\n   */\n  query<\n    ROOT_FIELDS extends string = string,\n    AGGREGATION_FIELDS extends string = ROOT_FIELDS,\n  >(\n    query: AggregationQuery<ROOT_FIELDS, AGGREGATION_FIELDS>,\n  ): AggregationQuery<ROOT_FIELDS, AGGREGATION_FIELDS> {\n    return admitAggregationQuery(query);\n  },\n};\n"],"mappings":"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"}

package/dist/dsl/aggregation/derived.cjs

@@ -0,0 +1,2 @@
+const e=require("./types.cjs");function t(t,n,r){return{type:e.DerivedExpressionType.BINARY,operator:t,left:n,right:r}}var n={ref:t=>({type:e.DerivedExpressionType.METRIC_REF,metric:t}),constant(t){if(!Number.isFinite(t))throw TypeError(`derived constant must be finite.`);return{type:e.DerivedExpressionType.CONSTANT,value:t}},add:(n,r)=>t(e.AggregationExpressionOperator.ADD,n,r),subtract:(n,r)=>t(e.AggregationExpressionOperator.SUBTRACT,n,r),multiply:(n,r)=>t(e.AggregationExpressionOperator.MULTIPLY,n,r),divide:(n,r)=>t(e.AggregationExpressionOperator.DIVIDE,n,r)};exports.derivedExpressionDsl=n;
+//# sourceMappingURL=derived.cjs.map

package/dist/dsl/aggregation/derived.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.cjs","names":["DerivedExpressionType","AggregationExpressionOperator","require_types","binary","derivedExpressionDsl","value","left","right"],"sources":["../../../src/dsl/aggregation/derived.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AggregationExpressionOperator,\n  DerivedExpressionType,\n  type DerivedExpression,\n} from './types.js';\n\n/**\n * The builders of a derived metric's arithmetic, handed to the callback of\n * `aggregation.derived(d => …, alias)`: references to other metrics of the\n * same row, numbers, and the four operators. Mirrors Kotlin's\n * `DerivedExpressionDsl` (`wow-query`, `AggregationQueryDsl.kt`).\n *\n * `constant` checks its number here; `aggregation.query()` checks what\n * spans the query: that each `ref` names a non-ANY metric declared before the\n * derived one, and the depth and size of the tree.\n *\n * These are not `aggregation.add` and friends: those build the expressions a\n * metric aggregates over, which name fields, not metrics.\n */\nexport interface DerivedExpressionDsl {\n  /** The value of another metric of the row. `{ type: 'METRIC_REF', metric }`. */\n  ref(metric: string): DerivedExpression;\n  /**\n   * A number. `{ type: 'CONSTANT', value }`.\n   *\n   * @throws TypeError when `value` is not finite.\n   */\n  constant(value: number): DerivedExpression;\n  /** `left + right`. `{ type: 'BINARY', operator: 'ADD', left, right }`. */\n  add(left: DerivedExpression, right: DerivedExpression): DerivedExpression;\n  /** `left - right`. `{ type: 'BINARY', operator: 'SUBTRACT', left, right }`. */\n  subtract(\n    left: DerivedExpression,\n    right: DerivedExpression,\n  ): DerivedExpression;\n  /** `left * right`. `{ type: 'BINARY', operator: 'MULTIPLY', left, right }`. */\n  multiply(\n    left: DerivedExpression,\n    right: DerivedExpression,\n  ): DerivedExpression;\n  /** `left / right`. `{ type: 'BINARY', operator: 'DIVIDE', left, right }`. */\n  divide(left: DerivedExpression, right: DerivedExpression): DerivedExpression;\n}\n\nfunction binary(\n  operator: AggregationExpressionOperator,\n  left: DerivedExpression,\n  right: DerivedExpression,\n): DerivedExpression {\n  return { type: DerivedExpressionType.BINARY, operator, left, right };\n}\n\nexport const derivedExpressionDsl: DerivedExpressionDsl = {\n  ref: metric => ({ type: DerivedExpressionType.METRIC_REF, metric }),\n  constant(value) {\n    if (!Number.isFinite(value)) {\n      throw new TypeError('derived constant must be finite.');\n    }\n    return { type: DerivedExpressionType.CONSTANT, value };\n  },\n  add: (left, right) => binary(AggregationExpressionOperator.ADD, left, right),\n  subtract: (left, right) =>\n    binary(AggregationExpressionOperator.SUBTRACT, left, right),\n  multiply: (left, right) =>\n    binary(AggregationExpressionOperator.MULTIPLY, left, right),\n  divide: (left, right) =>\n    binary(AggregationExpressionOperator.DIVIDE, left, right),\n};\n"],"mappings":"+BAyDA,SAASG,EACP,EACA,EACA,EACmB,CACnB,MAAO,CAAE,KAAMH,EAAAA,sBAAsB,OAAQ,WAAU,OAAM,OAAM,CACrE,CAEA,IAAaI,EAA6C,CACxD,IAAK,IAAW,CAAE,KAAMJ,EAAAA,sBAAsB,WAAY,QAAO,GACjE,SAAS,EAAO,CACd,GAAI,CAAC,OAAO,SAASK,CAAK,EACxB,MAAU,UAAU,kCAAkC,EAExD,MAAO,CAAE,KAAML,EAAAA,sBAAsB,SAAU,OAAM,CACvD,EACA,KAAM,EAAM,IAAUG,EAAOF,EAAAA,8BAA8B,IAAKK,EAAMC,CAAK,EAC3E,UAAW,EAAM,IACfJ,EAAOF,EAAAA,8BAA8B,SAAUK,EAAMC,CAAK,EAC5D,UAAW,EAAM,IACfJ,EAAOF,EAAAA,8BAA8B,SAAUK,EAAMC,CAAK,EAC5D,QAAS,EAAM,IACbJ,EAAOF,EAAAA,8BAA8B,OAAQK,EAAMC,CAAK,CAC5D"}

package/dist/dsl/aggregation/derived.d.cts

@@ -0,0 +1,33 @@
+import { DerivedExpression } from './types.cjs';
+/**
+ * The builders of a derived metric's arithmetic, handed to the callback of
+ * `aggregation.derived(d => …, alias)`: references to other metrics of the
+ * same row, numbers, and the four operators. Mirrors Kotlin's
+ * `DerivedExpressionDsl` (`wow-query`, `AggregationQueryDsl.kt`).
+ *
+ * `constant` checks its number here; `aggregation.query()` checks what
+ * spans the query: that each `ref` names a non-ANY metric declared before the
+ * derived one, and the depth and size of the tree.
+ *
+ * These are not `aggregation.add` and friends: those build the expressions a
+ * metric aggregates over, which name fields, not metrics.
+ */
+export interface DerivedExpressionDsl {
+    /** The value of another metric of the row. `{ type: 'METRIC_REF', metric }`. */
+    ref(metric: string): DerivedExpression;
+    /**
+     * A number. `{ type: 'CONSTANT', value }`.
+     *
+     * @throws TypeError when `value` is not finite.
+     */
+    constant(value: number): DerivedExpression;
+    /** `left + right`. `{ type: 'BINARY', operator: 'ADD', left, right }`. */
+    add(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left - right`. `{ type: 'BINARY', operator: 'SUBTRACT', left, right }`. */
+    subtract(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left * right`. `{ type: 'BINARY', operator: 'MULTIPLY', left, right }`. */
+    multiply(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left / right`. `{ type: 'BINARY', operator: 'DIVIDE', left, right }`. */
+    divide(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+}
+export declare const derivedExpressionDsl: DerivedExpressionDsl;

package/dist/dsl/aggregation/derived.d.ts

@@ -0,0 +1,33 @@
+import { DerivedExpression } from './types.js';
+/**
+ * The builders of a derived metric's arithmetic, handed to the callback of
+ * `aggregation.derived(d => …, alias)`: references to other metrics of the
+ * same row, numbers, and the four operators. Mirrors Kotlin's
+ * `DerivedExpressionDsl` (`wow-query`, `AggregationQueryDsl.kt`).
+ *
+ * `constant` checks its number here; `aggregation.query()` checks what
+ * spans the query: that each `ref` names a non-ANY metric declared before the
+ * derived one, and the depth and size of the tree.
+ *
+ * These are not `aggregation.add` and friends: those build the expressions a
+ * metric aggregates over, which name fields, not metrics.
+ */
+export interface DerivedExpressionDsl {
+    /** The value of another metric of the row. `{ type: 'METRIC_REF', metric }`. */
+    ref(metric: string): DerivedExpression;
+    /**
+     * A number. `{ type: 'CONSTANT', value }`.
+     *
+     * @throws TypeError when `value` is not finite.
+     */
+    constant(value: number): DerivedExpression;
+    /** `left + right`. `{ type: 'BINARY', operator: 'ADD', left, right }`. */
+    add(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left - right`. `{ type: 'BINARY', operator: 'SUBTRACT', left, right }`. */
+    subtract(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left * right`. `{ type: 'BINARY', operator: 'MULTIPLY', left, right }`. */
+    multiply(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+    /** `left / right`. `{ type: 'BINARY', operator: 'DIVIDE', left, right }`. */
+    divide(left: DerivedExpression, right: DerivedExpression): DerivedExpression;
+}
+export declare const derivedExpressionDsl: DerivedExpressionDsl;

package/dist/dsl/aggregation/derived.es.js

@@ -0,0 +1,31 @@
+import { AggregationExpressionOperator as e, DerivedExpressionType as t } from "./types.es.js";
+//#region src/dsl/aggregation/derived.ts
+function n(e, n, r) {
+	return {
+		type: t.BINARY,
+		operator: e,
+		left: n,
+		right: r
+	};
+}
+var r = {
+	ref: (e) => ({
+		type: t.METRIC_REF,
+		metric: e
+	}),
+	constant(e) {
+		if (!Number.isFinite(e)) throw TypeError("derived constant must be finite.");
+		return {
+			type: t.CONSTANT,
+			value: e
+		};
+	},
+	add: (t, r) => n(e.ADD, t, r),
+	subtract: (t, r) => n(e.SUBTRACT, t, r),
+	multiply: (t, r) => n(e.MULTIPLY, t, r),
+	divide: (t, r) => n(e.DIVIDE, t, r)
+};
+//#endregion
+export { r as derivedExpressionDsl };
+
+//# sourceMappingURL=derived.es.js.map

package/dist/dsl/aggregation/derived.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.es.js","names":["binary","DerivedExpressionType","derivedExpressionDsl","value","AggregationExpressionOperator","left","right"],"sources":["../../../src/dsl/aggregation/derived.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AggregationExpressionOperator,\n  DerivedExpressionType,\n  type DerivedExpression,\n} from './types.js';\n\n/**\n * The builders of a derived metric's arithmetic, handed to the callback of\n * `aggregation.derived(d => …, alias)`: references to other metrics of the\n * same row, numbers, and the four operators. Mirrors Kotlin's\n * `DerivedExpressionDsl` (`wow-query`, `AggregationQueryDsl.kt`).\n *\n * `constant` checks its number here; `aggregation.query()` checks what\n * spans the query: that each `ref` names a non-ANY metric declared before the\n * derived one, and the depth and size of the tree.\n *\n * These are not `aggregation.add` and friends: those build the expressions a\n * metric aggregates over, which name fields, not metrics.\n */\nexport interface DerivedExpressionDsl {\n  /** The value of another metric of the row. `{ type: 'METRIC_REF', metric }`. */\n  ref(metric: string): DerivedExpression;\n  /**\n   * A number. `{ type: 'CONSTANT', value }`.\n   *\n   * @throws TypeError when `value` is not finite.\n   */\n  constant(value: number): DerivedExpression;\n  /** `left + right`. `{ type: 'BINARY', operator: 'ADD', left, right }`. */\n  add(left: DerivedExpression, right: DerivedExpression): DerivedExpression;\n  /** `left - right`. `{ type: 'BINARY', operator: 'SUBTRACT', left, right }`. */\n  subtract(\n    left: DerivedExpression,\n    right: DerivedExpression,\n  ): DerivedExpression;\n  /** `left * right`. `{ type: 'BINARY', operator: 'MULTIPLY', left, right }`. */\n  multiply(\n    left: DerivedExpression,\n    right: DerivedExpression,\n  ): DerivedExpression;\n  /** `left / right`. `{ type: 'BINARY', operator: 'DIVIDE', left, right }`. */\n  divide(left: DerivedExpression, right: DerivedExpression): DerivedExpression;\n}\n\nfunction binary(\n  operator: AggregationExpressionOperator,\n  left: DerivedExpression,\n  right: DerivedExpression,\n): DerivedExpression {\n  return { type: DerivedExpressionType.BINARY, operator, left, right };\n}\n\nexport const derivedExpressionDsl: DerivedExpressionDsl = {\n  ref: metric => ({ type: DerivedExpressionType.METRIC_REF, metric }),\n  constant(value) {\n    if (!Number.isFinite(value)) {\n      throw new TypeError('derived constant must be finite.');\n    }\n    return { type: DerivedExpressionType.CONSTANT, value };\n  },\n  add: (left, right) => binary(AggregationExpressionOperator.ADD, left, right),\n  subtract: (left, right) =>\n    binary(AggregationExpressionOperator.SUBTRACT, left, right),\n  multiply: (left, right) =>\n    binary(AggregationExpressionOperator.MULTIPLY, left, right),\n  divide: (left, right) =>\n    binary(AggregationExpressionOperator.DIVIDE, left, right),\n};\n"],"mappings":";;AAyDA,SAASA,EACP,GACA,GACA,GACmB;CACnB,OAAO;EAAE,MAAMC,EAAsB;EAAQ;EAAU;EAAM;CAAM;AACrE;AAEA,IAAaC,IAA6C;CACxD,MAAK,OAAW;EAAE,MAAMD,EAAsB;EAAY;CAAO;CACjE,SAAS,GAAO;EACd,IAAI,CAAC,OAAO,SAASE,CAAK,GACxB,MAAU,UAAU,kCAAkC;EAExD,OAAO;GAAE,MAAMF,EAAsB;GAAU;EAAM;CACvD;CACA,MAAM,GAAM,MAAUD,EAAOI,EAA8B,KAAKC,GAAMC,CAAK;CAC3E,WAAW,GAAM,MACfN,EAAOI,EAA8B,UAAUC,GAAMC,CAAK;CAC5D,WAAW,GAAM,MACfN,EAAOI,EAA8B,UAAUC,GAAMC,CAAK;CAC5D,SAAS,GAAM,MACbN,EAAOI,EAA8B,QAAQC,GAAMC,CAAK;AAC5D"}

package/dist/dsl/aggregation/expressionTrees.cjs

@@ -0,0 +1,2 @@
+const e=require("./types.cjs");function t(t){let n=t.map(e=>({expression:e,depth:1})),r=0;for(;n.length>0;){let{expression:t,depth:i}=n.pop();if(i>e.AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH)throw TypeError(`aggregation expression depth must be at most ${e.AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH}.`);if(r++,r>e.AGGREGATION_LIMITS.MAX_EXPRESSION_NODES)throw TypeError(`aggregation expressions must contain at most ${e.AGGREGATION_LIMITS.MAX_EXPRESSION_NODES} nodes.`);switch(t.type){case e.AggregationExpressionType.FIELD:break;case e.AggregationExpressionType.CONSTANT:if(!Number.isFinite(t.value))throw TypeError(`aggregation constant must be finite.`);break;case e.AggregationExpressionType.DATE_DIFF:if(!Object.values(e.DateDiffUnit).includes(t.unit))throw TypeError(`date diff unit is invalid.`);break;case e.AggregationExpressionType.BINARY:n.push({expression:t.left,depth:i+1}),n.push({expression:t.right,depth:i+1});break;default:throw TypeError(`Unsupported aggregation expression: ${String(t.type)}.`)}}}function n(t){switch(t.type){case e.AggregationExpressionType.FIELD:return[t.field];case e.AggregationExpressionType.DATE_DIFF:return[t.from,t.to];case e.AggregationExpressionType.BINARY:return[...n(t.left),...n(t.right)];default:return[]}}exports.expressionFields=n,exports.requireValidExpressionTrees=t;
+//# sourceMappingURL=expressionTrees.cjs.map

package/dist/dsl/aggregation/expressionTrees.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionTrees.cjs","names":["AGGREGATION_LIMITS","AggregationExpressionType","DateDiffUnit","require_types","requireValidExpressionTrees","pending","expressions","nodes","depth","expression","expressionFields"],"sources":["../../../src/dsl/aggregation/expressionTrees.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AGGREGATION_LIMITS,\n  AggregationExpressionType,\n  DateDiffUnit,\n  type AggregationExpression,\n} from './types.js';\n\n// Internal: the one walk over aggregation expression trees that metrics,\n// expression groups and `EXPRESSION` filters share. index.ts does not\n// re-export this file.\n\n/**\n * Bounds the depth of each tree and the nodes of all of them together, as\n * Wow's `requireValidExpressionTrees` does: depth is per expression and the\n * node count is one budget over the list, so a query cannot slip past by\n * spreading a large tree across many metrics.\n */\nexport function requireValidExpressionTrees(\n  expressions: readonly AggregationExpression[],\n): void {\n  const pending = expressions.map(expression => ({ expression, depth: 1 }));\n  let nodes = 0;\n  while (pending.length > 0) {\n    const { expression, depth } = pending.pop()!;\n    if (depth > AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH) {\n      throw new TypeError(\n        `aggregation expression depth must be at most ${AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH}.`,\n      );\n    }\n    nodes++;\n    if (nodes > AGGREGATION_LIMITS.MAX_EXPRESSION_NODES) {\n      throw new TypeError(\n        `aggregation expressions must contain at most ${AGGREGATION_LIMITS.MAX_EXPRESSION_NODES} nodes.`,\n      );\n    }\n    switch (expression.type) {\n      case AggregationExpressionType.FIELD:\n        break;\n      // `aggregation.constant` refuses these, but a query rebuilt from a\n      // stored config never passed through it, and JSON has no NaN: the value\n      // would serialise to null and be refused on arrival instead.\n      case AggregationExpressionType.CONSTANT:\n        if (!Number.isFinite(expression.value)) {\n          throw new TypeError('aggregation constant must be finite.');\n        }\n        break;\n      case AggregationExpressionType.DATE_DIFF:\n        if (!Object.values(DateDiffUnit).includes(expression.unit)) {\n          throw new TypeError('date diff unit is invalid.');\n        }\n        break;\n      case AggregationExpressionType.BINARY:\n        pending.push({ expression: expression.left, depth: depth + 1 });\n        pending.push({ expression: expression.right, depth: depth + 1 });\n        break;\n      default:\n        throw new TypeError(\n          `Unsupported aggregation expression: ${String((expression as { type: unknown }).type)}.`,\n        );\n    }\n  }\n}\n\n/** The fields an expression reads, in tree order. */\nexport function expressionFields(expression: AggregationExpression): string[] {\n  switch (expression.type) {\n    case AggregationExpressionType.FIELD:\n      return [expression.field];\n    case AggregationExpressionType.DATE_DIFF:\n      return [expression.from, expression.to];\n    case AggregationExpressionType.BINARY:\n      return [\n        ...expressionFields(expression.left),\n        ...expressionFields(expression.right),\n      ];\n    default:\n      return [];\n  }\n}\n"],"mappings":"+BA8BA,SAAgBI,EACd,EACM,CACN,IAAMC,EAAUC,EAAY,IAAI,IAAe,CAAE,aAAY,MAAO,CAAE,EAAE,EACpEC,EAAQ,EACZ,KAAOF,EAAQ,OAAS,GAAG,CACzB,GAAM,CAAE,aAAY,SAAUA,EAAQ,IAAI,EAC1C,GAAIG,EAAQR,EAAAA,mBAAmB,qBAC7B,MAAU,UACR,gDAAgDA,EAAAA,mBAAmB,qBAAqB,EAC1F,EAGF,GADA,IACIO,EAAQP,EAAAA,mBAAmB,qBAC7B,MAAU,UACR,gDAAgDA,EAAAA,mBAAmB,qBAAqB,QAC1F,EAEF,OAAQS,EAAW,KAAnB,CACE,KAAKR,EAAAA,0BAA0B,MAC7B,MAIF,KAAKA,EAAAA,0BAA0B,SAC7B,GAAI,CAAC,OAAO,SAASQ,EAAW,KAAK,EACnC,MAAU,UAAU,sCAAsC,EAE5D,MACF,KAAKR,EAAAA,0BAA0B,UAC7B,GAAI,CAAC,OAAO,OAAOC,EAAAA,YAAY,CAAC,CAAC,SAASO,EAAW,IAAI,EACvD,MAAU,UAAU,4BAA4B,EAElD,MACF,KAAKR,EAAAA,0BAA0B,OAC7BI,EAAQ,KAAK,CAAE,WAAYI,EAAW,KAAM,MAAOD,EAAQ,CAAE,CAAC,EAC9DH,EAAQ,KAAK,CAAE,WAAYI,EAAW,MAAO,MAAOD,EAAQ,CAAE,CAAC,EAC/D,MACF,QACE,MAAU,UACR,uCAAuC,OAAQC,EAAiC,IAAI,EAAE,EACxF,CACJ,CACF,CACF,CAGA,SAAgBC,EAAiB,EAA6C,CAC5E,OAAQD,EAAW,KAAnB,CACE,KAAKR,EAAAA,0BAA0B,MAC7B,MAAO,CAACQ,EAAW,KAAK,EAC1B,KAAKR,EAAAA,0BAA0B,UAC7B,MAAO,CAACQ,EAAW,KAAMA,EAAW,EAAE,EACxC,KAAKR,EAAAA,0BAA0B,OAC7B,MAAO,CACL,GAAGS,EAAiBD,EAAW,IAAI,EACnC,GAAGC,EAAiBD,EAAW,KAAK,CACtC,EACF,QACE,MAAO,CAAC,CACZ,CACF"}

package/dist/dsl/aggregation/expressionTrees.d.cts

@@ -0,0 +1,10 @@
+import { AggregationExpression } from './types.cjs';
+/**
+ * Bounds the depth of each tree and the nodes of all of them together, as
+ * Wow's `requireValidExpressionTrees` does: depth is per expression and the
+ * node count is one budget over the list, so a query cannot slip past by
+ * spreading a large tree across many metrics.
+ */
+export declare function requireValidExpressionTrees(expressions: readonly AggregationExpression[]): void;
+/** The fields an expression reads, in tree order. */
+export declare function expressionFields(expression: AggregationExpression): string[];

package/dist/dsl/aggregation/expressionTrees.d.ts

@@ -0,0 +1,10 @@
+import { AggregationExpression } from './types.js';
+/**
+ * Bounds the depth of each tree and the nodes of all of them together, as
+ * Wow's `requireValidExpressionTrees` does: depth is per expression and the
+ * node count is one budget over the list, so a query cannot slip past by
+ * spreading a large tree across many metrics.
+ */
+export declare function requireValidExpressionTrees(expressions: readonly AggregationExpression[]): void;
+/** The fields an expression reads, in tree order. */
+export declare function expressionFields(expression: AggregationExpression): string[];

package/dist/dsl/aggregation/expressionTrees.es.js

@@ -0,0 +1,44 @@
+import { AGGREGATION_LIMITS as e, AggregationExpressionType as t, DateDiffUnit as n } from "./types.es.js";
+//#region src/dsl/aggregation/expressionTrees.ts
+function r(r) {
+	let i = r.map((e) => ({
+		expression: e,
+		depth: 1
+	})), a = 0;
+	for (; i.length > 0;) {
+		let { expression: r, depth: o } = i.pop();
+		if (o > e.MAX_EXPRESSION_DEPTH) throw TypeError(`aggregation expression depth must be at most ${e.MAX_EXPRESSION_DEPTH}.`);
+		if (a++, a > e.MAX_EXPRESSION_NODES) throw TypeError(`aggregation expressions must contain at most ${e.MAX_EXPRESSION_NODES} nodes.`);
+		switch (r.type) {
+			case t.FIELD: break;
+			case t.CONSTANT:
+				if (!Number.isFinite(r.value)) throw TypeError("aggregation constant must be finite.");
+				break;
+			case t.DATE_DIFF:
+				if (!Object.values(n).includes(r.unit)) throw TypeError("date diff unit is invalid.");
+				break;
+			case t.BINARY:
+				i.push({
+					expression: r.left,
+					depth: o + 1
+				}), i.push({
+					expression: r.right,
+					depth: o + 1
+				});
+				break;
+			default: throw TypeError(`Unsupported aggregation expression: ${String(r.type)}.`);
+		}
+	}
+}
+function i(e) {
+	switch (e.type) {
+		case t.FIELD: return [e.field];
+		case t.DATE_DIFF: return [e.from, e.to];
+		case t.BINARY: return [...i(e.left), ...i(e.right)];
+		default: return [];
+	}
+}
+//#endregion
+export { i as expressionFields, r as requireValidExpressionTrees };
+
+//# sourceMappingURL=expressionTrees.es.js.map

package/dist/dsl/aggregation/expressionTrees.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionTrees.es.js","names":["requireValidExpressionTrees","pending","expressions","nodes","depth","AGGREGATION_LIMITS","expression","AggregationExpressionType","DateDiffUnit","expressionFields"],"sources":["../../../src/dsl/aggregation/expressionTrees.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AGGREGATION_LIMITS,\n  AggregationExpressionType,\n  DateDiffUnit,\n  type AggregationExpression,\n} from './types.js';\n\n// Internal: the one walk over aggregation expression trees that metrics,\n// expression groups and `EXPRESSION` filters share. index.ts does not\n// re-export this file.\n\n/**\n * Bounds the depth of each tree and the nodes of all of them together, as\n * Wow's `requireValidExpressionTrees` does: depth is per expression and the\n * node count is one budget over the list, so a query cannot slip past by\n * spreading a large tree across many metrics.\n */\nexport function requireValidExpressionTrees(\n  expressions: readonly AggregationExpression[],\n): void {\n  const pending = expressions.map(expression => ({ expression, depth: 1 }));\n  let nodes = 0;\n  while (pending.length > 0) {\n    const { expression, depth } = pending.pop()!;\n    if (depth > AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH) {\n      throw new TypeError(\n        `aggregation expression depth must be at most ${AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH}.`,\n      );\n    }\n    nodes++;\n    if (nodes > AGGREGATION_LIMITS.MAX_EXPRESSION_NODES) {\n      throw new TypeError(\n        `aggregation expressions must contain at most ${AGGREGATION_LIMITS.MAX_EXPRESSION_NODES} nodes.`,\n      );\n    }\n    switch (expression.type) {\n      case AggregationExpressionType.FIELD:\n        break;\n      // `aggregation.constant` refuses these, but a query rebuilt from a\n      // stored config never passed through it, and JSON has no NaN: the value\n      // would serialise to null and be refused on arrival instead.\n      case AggregationExpressionType.CONSTANT:\n        if (!Number.isFinite(expression.value)) {\n          throw new TypeError('aggregation constant must be finite.');\n        }\n        break;\n      case AggregationExpressionType.DATE_DIFF:\n        if (!Object.values(DateDiffUnit).includes(expression.unit)) {\n          throw new TypeError('date diff unit is invalid.');\n        }\n        break;\n      case AggregationExpressionType.BINARY:\n        pending.push({ expression: expression.left, depth: depth + 1 });\n        pending.push({ expression: expression.right, depth: depth + 1 });\n        break;\n      default:\n        throw new TypeError(\n          `Unsupported aggregation expression: ${String((expression as { type: unknown }).type)}.`,\n        );\n    }\n  }\n}\n\n/** The fields an expression reads, in tree order. */\nexport function expressionFields(expression: AggregationExpression): string[] {\n  switch (expression.type) {\n    case AggregationExpressionType.FIELD:\n      return [expression.field];\n    case AggregationExpressionType.DATE_DIFF:\n      return [expression.from, expression.to];\n    case AggregationExpressionType.BINARY:\n      return [\n        ...expressionFields(expression.left),\n        ...expressionFields(expression.right),\n      ];\n    default:\n      return [];\n  }\n}\n"],"mappings":";;AA8BA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAUC,EAAY,KAAI,OAAe;EAAE;EAAY,OAAO;CAAE,EAAE,GACpEC,IAAQ;CACZ,OAAOF,EAAQ,SAAS,IAAG;EACzB,IAAM,EAAE,eAAY,aAAUA,EAAQ,IAAI;EAC1C,IAAIG,IAAQC,EAAmB,sBAC7B,MAAU,UACR,gDAAgDA,EAAmB,qBAAqB,EAC1F;EAGF,IADA,KACIF,IAAQE,EAAmB,sBAC7B,MAAU,UACR,gDAAgDA,EAAmB,qBAAqB,QAC1F;EAEF,QAAQC,EAAW,MAAnB;GACE,KAAKC,EAA0B,OAC7B;GAIF,KAAKA,EAA0B;IAC7B,IAAI,CAAC,OAAO,SAASD,EAAW,KAAK,GACnC,MAAU,UAAU,sCAAsC;IAE5D;GACF,KAAKC,EAA0B;IAC7B,IAAI,CAAC,OAAO,OAAOC,CAAY,CAAC,CAAC,SAASF,EAAW,IAAI,GACvD,MAAU,UAAU,4BAA4B;IAElD;GACF,KAAKC,EAA0B;IAE7B,AADAN,EAAQ,KAAK;KAAE,YAAYK,EAAW;KAAM,OAAOF,IAAQ;IAAE,CAAC,GAC9DH,EAAQ,KAAK;KAAE,YAAYK,EAAW;KAAO,OAAOF,IAAQ;IAAE,CAAC;IAC/D;GACF,SACE,MAAU,UACR,uCAAuC,OAAQE,EAAiC,IAAI,EAAE,EACxF;EACJ;CACF;AACF;AAGA,SAAgBG,EAAiB,GAA6C;CAC5E,QAAQH,EAAW,MAAnB;EACE,KAAKC,EAA0B,OAC7B,OAAO,CAACD,EAAW,KAAK;EAC1B,KAAKC,EAA0B,WAC7B,OAAO,CAACD,EAAW,MAAMA,EAAW,EAAE;EACxC,KAAKC,EAA0B,QAC7B,OAAO,CACL,GAAGE,EAAiBH,EAAW,IAAI,GACnC,GAAGG,EAAiBH,EAAW,KAAK,CACtC;EACF,SACE,OAAO,CAAC;CACZ;AACF"}

package/dist/dsl/aggregation/having.cjs

@@ -0,0 +1,2 @@
+const e=require("./types.cjs");function t(t,n,r){if(!Number.isFinite(r))throw TypeError(`having condition [${n}] value must be finite.`);return{type:e.HavingExpressionType.CONDITION,metric:n,operator:t,value:r}}function n(e,t){let[n,...r]=t;if(n===void 0)throw TypeError(`having ${e} operands must not be empty.`);return{type:e,operands:[n,...r]}}var r={eq:(n,r)=>t(e.ComparisonOperator.EQ,n,r),ne:(n,r)=>t(e.ComparisonOperator.NE,n,r),gt:(n,r)=>t(e.ComparisonOperator.GT,n,r),gte:(n,r)=>t(e.ComparisonOperator.GTE,n,r),lt:(n,r)=>t(e.ComparisonOperator.LT,n,r),lte:(n,r)=>t(e.ComparisonOperator.LTE,n,r),between(t,n,r){if(!Number.isFinite(n)||!Number.isFinite(r))throw TypeError(`having between [${t}] bounds must be finite.`);if(n>r)throw TypeError(`having between [${t}] lower bound must not exceed upper bound.`);return{type:e.HavingExpressionType.BETWEEN,metric:t,lower:n,upper:r}},isIn(t,n){let[r,...i]=n;if(r===void 0)throw TypeError(`having in [${t}] values must not be empty.`);if(!n.every(Number.isFinite))throw TypeError(`having in [${t}] values must be finite.`);return{type:e.HavingExpressionType.IN,metric:t,values:[r,...i]}},isNull:t=>({type:e.HavingExpressionType.IS_NULL,metric:t}),isNotNull:t=>({type:e.HavingExpressionType.IS_NULL,metric:t,negated:!0}),and:t=>n(e.HavingExpressionType.AND,t),or:t=>n(e.HavingExpressionType.OR,t)};exports.havingDsl=r;
+//# sourceMappingURL=having.cjs.map

package/dist/dsl/aggregation/having.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"having.cjs","names":["HavingExpressionType","ComparisonOperator","require_types","condition","value","metric","logical","first","rest","operands","type","havingDsl","lower","upper","values"],"sources":["../../../src/dsl/aggregation/having.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ComparisonOperator,\n  HavingExpressionType,\n  type HavingExpression,\n} from './types.js';\n\n/**\n * The builders of a `having` expression, `aggregation.having.*`: conditions on\n * the metric columns of the grouped rows, and their `and`/`or`. Mirrors\n * Kotlin's `HavingDsl` (`wow-query`, `AggregationQueryDsl.kt`).\n *\n * Each builder checks its own numbers and throws a `TypeError` with the\n * message Wow answers; `aggregation.query()` checks what spans the query:\n * that `metric` names a declared, non-ANY metric, and that the query groups.\n */\nexport interface HavingDsl {\n  /**\n   * `metric = value`. `{ type: 'CONDITION', metric, operator: 'EQ', value }`.\n   *\n   * @param metric - The alias of a metric of the same query.\n   * @throws TypeError when `value` is not finite.\n   * @example\n   * ```typescript\n   * aggregation.having.eq('orders', 1);\n   * ```\n   */\n  eq(metric: string, value: number): HavingExpression;\n  /** `metric ≠ value`. `{ type: 'CONDITION', operator: 'NE', … }`. */\n  ne(metric: string, value: number): HavingExpression;\n  /**\n   * `metric > value`. `{ type: 'CONDITION', operator: 'GT', … }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.having.gt('revenue', 100);\n   * ```\n   */\n  gt(metric: string, value: number): HavingExpression;\n  /** `metric ≥ value`. `{ type: 'CONDITION', operator: 'GTE', … }`. */\n  gte(metric: string, value: number): HavingExpression;\n  /** `metric < value`. `{ type: 'CONDITION', operator: 'LT', … }`. */\n  lt(metric: string, value: number): HavingExpression;\n  /** `metric ≤ value`. `{ type: 'CONDITION', operator: 'LTE', … }`. */\n  lte(metric: string, value: number): HavingExpression;\n  /**\n   * `lower ≤ metric ≤ upper`. `{ type: 'BETWEEN', metric, lower, upper }`.\n   *\n   * @throws TypeError when a bound is not finite, or `lower` exceeds `upper`.\n   * @example\n   * ```typescript\n   * aggregation.having.between('revenue', 10, 1000);\n   * ```\n   */\n  between(metric: string, lower: number, upper: number): HavingExpression;\n  /**\n   * `metric` is one of `values`. `{ type: 'IN', metric, values }` with a\n   * copy of `values`.\n   *\n   * @throws TypeError when `values` is empty or holds a non-finite number.\n   * @example\n   * ```typescript\n   * aggregation.having.isIn('orders', [2, 3]);\n   * ```\n   */\n  isIn(metric: string, values: readonly number[]): HavingExpression;\n  /**\n   * `metric` has no value in the row. `{ type: 'IS_NULL', metric }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.having.isNull('averageOrder');\n   * ```\n   */\n  isNull(metric: string): HavingExpression;\n  /** `metric` has a value. `{ type: 'IS_NULL', metric, negated: true }`. */\n  isNotNull(metric: string): HavingExpression;\n  /**\n   * All of `operands` hold. `{ type: 'AND', operands }` with a copy of\n   * `operands`.\n   *\n   * @throws TypeError when `operands` is empty.\n   * @example\n   * ```typescript\n   * aggregation.having.and([\n   *   aggregation.having.gt('orders', 1),\n   *   aggregation.having.isNotNull('revenue'),\n   * ]);\n   * ```\n   */\n  and(operands: readonly HavingExpression[]): HavingExpression;\n  /**\n   * At least one of `operands` holds. `{ type: 'OR', operands }` with a copy\n   * of `operands`.\n   *\n   * @throws TypeError when `operands` is empty.\n   */\n  or(operands: readonly HavingExpression[]): HavingExpression;\n}\n\nfunction condition(\n  operator: ComparisonOperator,\n  metric: string,\n  value: number,\n): HavingExpression {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`having condition [${metric}] value must be finite.`);\n  }\n  return { type: HavingExpressionType.CONDITION, metric, operator, value };\n}\n\nfunction logical(\n  type: HavingExpressionType.AND | HavingExpressionType.OR,\n  operands: readonly HavingExpression[],\n): HavingExpression {\n  const [first, ...rest] = operands;\n  if (first === undefined) {\n    throw new TypeError(`having ${type} operands must not be empty.`);\n  }\n  return { type, operands: [first, ...rest] };\n}\n\nexport const havingDsl: HavingDsl = {\n  eq: (metric, value) => condition(ComparisonOperator.EQ, metric, value),\n  ne: (metric, value) => condition(ComparisonOperator.NE, metric, value),\n  gt: (metric, value) => condition(ComparisonOperator.GT, metric, value),\n  gte: (metric, value) => condition(ComparisonOperator.GTE, metric, value),\n  lt: (metric, value) => condition(ComparisonOperator.LT, metric, value),\n  lte: (metric, value) => condition(ComparisonOperator.LTE, metric, value),\n  between(metric, lower, upper) {\n    if (!Number.isFinite(lower) || !Number.isFinite(upper)) {\n      throw new TypeError(`having between [${metric}] bounds must be finite.`);\n    }\n    if (lower > upper) {\n      throw new TypeError(\n        `having between [${metric}] lower bound must not exceed upper bound.`,\n      );\n    }\n    return { type: HavingExpressionType.BETWEEN, metric, lower, upper };\n  },\n  isIn(metric, values) {\n    const [first, ...rest] = values;\n    if (first === undefined) {\n      throw new TypeError(`having in [${metric}] values must not be empty.`);\n    }\n    if (!values.every(Number.isFinite)) {\n      throw new TypeError(`having in [${metric}] values must be finite.`);\n    }\n    return { type: HavingExpressionType.IN, metric, values: [first, ...rest] };\n  },\n  isNull: metric => ({ type: HavingExpressionType.IS_NULL, metric }),\n  isNotNull: metric => ({\n    type: HavingExpressionType.IS_NULL,\n    metric,\n    negated: true,\n  }),\n  and: operands => logical(HavingExpressionType.AND, operands),\n  or: operands => logical(HavingExpressionType.OR, operands),\n};\n"],"mappings":"+BAgHA,SAASG,EACP,EACA,EACA,EACkB,CAClB,GAAI,CAAC,OAAO,SAASC,CAAK,EACxB,MAAU,UAAU,qBAAqBC,EAAO,wBAAwB,EAE1E,MAAO,CAAE,KAAML,EAAAA,qBAAqB,UAAW,SAAQ,WAAU,OAAM,CACzE,CAEA,SAASM,EACP,EACA,EACkB,CAClB,GAAM,CAACC,EAAO,GAAGC,GAAQC,EACzB,GAAIF,IAAU,IAAA,GACZ,MAAU,UAAU,UAAUG,EAAK,6BAA6B,EAElE,MAAO,CAAE,OAAM,SAAU,CAACH,EAAO,GAAGC,CAAI,CAAE,CAC5C,CAEA,IAAaG,EAAuB,CAClC,IAAK,EAAQ,IAAUR,EAAUF,EAAAA,mBAAmB,GAAII,EAAQD,CAAK,EACrE,IAAK,EAAQ,IAAUD,EAAUF,EAAAA,mBAAmB,GAAII,EAAQD,CAAK,EACrE,IAAK,EAAQ,IAAUD,EAAUF,EAAAA,mBAAmB,GAAII,EAAQD,CAAK,EACrE,KAAM,EAAQ,IAAUD,EAAUF,EAAAA,mBAAmB,IAAKI,EAAQD,CAAK,EACvE,IAAK,EAAQ,IAAUD,EAAUF,EAAAA,mBAAmB,GAAII,EAAQD,CAAK,EACrE,KAAM,EAAQ,IAAUD,EAAUF,EAAAA,mBAAmB,IAAKI,EAAQD,CAAK,EACvE,QAAQ,EAAQ,EAAO,EAAO,CAC5B,GAAI,CAAC,OAAO,SAASQ,CAAK,GAAK,CAAC,OAAO,SAASC,CAAK,EACnD,MAAU,UAAU,mBAAmBR,EAAO,yBAAyB,EAEzE,GAAIO,EAAQC,EACV,MAAU,UACR,mBAAmBR,EAAO,2CAC5B,EAEF,MAAO,CAAE,KAAML,EAAAA,qBAAqB,QAAS,SAAQ,QAAO,OAAM,CACpE,EACA,KAAK,EAAQ,EAAQ,CACnB,GAAM,CAACO,EAAO,GAAGC,GAAQM,EACzB,GAAIP,IAAU,IAAA,GACZ,MAAU,UAAU,cAAcF,EAAO,4BAA4B,EAEvE,GAAI,CAACS,EAAO,MAAM,OAAO,QAAQ,EAC/B,MAAU,UAAU,cAAcT,EAAO,yBAAyB,EAEpE,MAAO,CAAE,KAAML,EAAAA,qBAAqB,GAAI,SAAQ,OAAQ,CAACO,EAAO,GAAGC,CAAI,CAAE,CAC3E,EACA,OAAQ,IAAW,CAAE,KAAMR,EAAAA,qBAAqB,QAAS,QAAO,GAChE,UAAW,IAAW,CACpB,KAAMA,EAAAA,qBAAqB,QAC3B,SACA,QAAS,EACX,GACA,IAAK,GAAYM,EAAQN,EAAAA,qBAAqB,IAAKS,CAAQ,EAC3D,GAAI,GAAYH,EAAQN,EAAAA,qBAAqB,GAAIS,CAAQ,CAC3D"}

package/dist/dsl/aggregation/having.d.cts

@@ -0,0 +1,94 @@
+import { HavingExpression } from './types.cjs';
+/**
+ * The builders of a `having` expression, `aggregation.having.*`: conditions on
+ * the metric columns of the grouped rows, and their `and`/`or`. Mirrors
+ * Kotlin's `HavingDsl` (`wow-query`, `AggregationQueryDsl.kt`).
+ *
+ * Each builder checks its own numbers and throws a `TypeError` with the
+ * message Wow answers; `aggregation.query()` checks what spans the query:
+ * that `metric` names a declared, non-ANY metric, and that the query groups.
+ */
+export interface HavingDsl {
+    /**
+     * `metric = value`. `{ type: 'CONDITION', metric, operator: 'EQ', value }`.
+     *
+     * @param metric - The alias of a metric of the same query.
+     * @throws TypeError when `value` is not finite.
+     * @example
+     * ```typescript
+     * aggregation.having.eq('orders', 1);
+     * ```
+     */
+    eq(metric: string, value: number): HavingExpression;
+    /** `metric ≠ value`. `{ type: 'CONDITION', operator: 'NE', … }`. */
+    ne(metric: string, value: number): HavingExpression;
+    /**
+     * `metric > value`. `{ type: 'CONDITION', operator: 'GT', … }`.
+     *
+     * @example
+     * ```typescript
+     * aggregation.having.gt('revenue', 100);
+     * ```
+     */
+    gt(metric: string, value: number): HavingExpression;
+    /** `metric ≥ value`. `{ type: 'CONDITION', operator: 'GTE', … }`. */
+    gte(metric: string, value: number): HavingExpression;
+    /** `metric < value`. `{ type: 'CONDITION', operator: 'LT', … }`. */
+    lt(metric: string, value: number): HavingExpression;
+    /** `metric ≤ value`. `{ type: 'CONDITION', operator: 'LTE', … }`. */
+    lte(metric: string, value: number): HavingExpression;
+    /**
+     * `lower ≤ metric ≤ upper`. `{ type: 'BETWEEN', metric, lower, upper }`.
+     *
+     * @throws TypeError when a bound is not finite, or `lower` exceeds `upper`.
+     * @example
+     * ```typescript
+     * aggregation.having.between('revenue', 10, 1000);
+     * ```
+     */
+    between(metric: string, lower: number, upper: number): HavingExpression;
+    /**
+     * `metric` is one of `values`. `{ type: 'IN', metric, values }` with a
+     * copy of `values`.
+     *
+     * @throws TypeError when `values` is empty or holds a non-finite number.
+     * @example
+     * ```typescript
+     * aggregation.having.isIn('orders', [2, 3]);
+     * ```
+     */
+    isIn(metric: string, values: readonly number[]): HavingExpression;
+    /**
+     * `metric` has no value in the row. `{ type: 'IS_NULL', metric }`.
+     *
+     * @example
+     * ```typescript
+     * aggregation.having.isNull('averageOrder');
+     * ```
+     */
+    isNull(metric: string): HavingExpression;
+    /** `metric` has a value. `{ type: 'IS_NULL', metric, negated: true }`. */
+    isNotNull(metric: string): HavingExpression;
+    /**
+     * All of `operands` hold. `{ type: 'AND', operands }` with a copy of
+     * `operands`.
+     *
+     * @throws TypeError when `operands` is empty.
+     * @example
+     * ```typescript
+     * aggregation.having.and([
+     *   aggregation.having.gt('orders', 1),
+     *   aggregation.having.isNotNull('revenue'),
+     * ]);
+     * ```
+     */
+    and(operands: readonly HavingExpression[]): HavingExpression;
+    /**
+     * At least one of `operands` holds. `{ type: 'OR', operands }` with a copy
+     * of `operands`.
+     *
+     * @throws TypeError when `operands` is empty.
+     */
+    or(operands: readonly HavingExpression[]): HavingExpression;
+}
+export declare const havingDsl: HavingDsl;