@hypequery/datasets 0.23.1 → 0.24.0

package/dist/api.type-test.js

@@ -1,251 +0,0 @@
-import { add, between, buildCanonicalSemanticQuerySchemas, buildProtocolDeploymentContract, createDatasetClient, dataset, desc, dimension, eq, measure, publishDatasets, publishToCloud, rehydrateProtocolDeploymentContract, } from './index.js';
-const Orders = dataset('orders', {
-    source: 'orders',
-    tenantKey: 'tenant_id',
-    timeKey: 'created_at',
-    dimensions: {
-        id: dimension.string(),
-        tenantId: dimension.string({ column: 'tenant_id' }),
-        status: dimension.string(),
-        amount: dimension.number(),
-        createdAt: dimension.timestamp({ column: 'created_at' }),
-    },
-    measures: {
-        revenue: measure.sum('amount'),
-        completedRevenue: measure.sum('amount', {
-            filters: [eq('status', 'completed')],
-        }),
-        doubledRevenue: measure.derived({
-            uses: { revenue: 'revenue' },
-            formula: ({ revenue }) => add(revenue, revenue),
-        }),
-    },
-});
-const _SegmentedOrders = dataset('segmentedOrders', {
-    source: 'orders',
-    dimensions: { status: dimension.string() },
-    measures: { revenue: measure.sum('amount') },
-    segments: { paid: { filters: [eq('status', 'paid')] } },
-});
-const validDatasetSegments = { segments: ['paid'] };
-const validMetricSegments = { segments: ['paid'] };
-void validDatasetSegments;
-void validMetricSegments;
-// @ts-expect-error only declared segment names are accepted.
-const invalidDatasetSegments = { segments: ['paidd'] };
-// @ts-expect-error only declared segment names are accepted on metric queries.
-const invalidMetricSegments = { segments: ['paidd'] };
-// @ts-expect-error a dataset without segments has no selectable segment names.
-const invalidPlainSegments = { segments: ['paid'] };
-void invalidDatasetSegments;
-void invalidMetricSegments;
-void invalidPlainSegments;
-// @ts-expect-error standalone metrics may only target base measures.
-Orders.metric('invalidDerivedMetric', { measure: 'doubledRevenue' });
-dataset('derivedDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        doubled: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-        quadrupled: measure.derived({ uses: { value: 'doubled' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-const _WindowOrders = dataset('windowOrders', {
-    source: 'orders', timeKey: 'createdAt',
-    dimensions: { createdAt: dimension.timestamp(), amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        trailingRevenue: measure.trailing('revenue', { amount: 7, unit: 'day' }),
-        runningRevenue: measure.cumulative('revenue'),
-        growth: measure.derived({ uses: { running: 'runningRevenue' }, formula: ({ running }) => add(running, running) }),
-    },
-});
-// @ts-expect-error standalone metrics may only target base measures, even in the unified registry.
-_WindowOrders.metric('invalidWindowMetric', { measure: 'runningRevenue' });
-dataset('invalidWindowInput', {
-    source: 'orders', timeKey: 'createdAt',
-    dimensions: { createdAt: dimension.timestamp(), amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        growth: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-        // @ts-expect-error a window must wrap a base measure.
-        invalid: measure.cumulative('growth'),
-    },
-});
-const deploymentContract = buildProtocolDeploymentContract([Orders]);
-rehydrateProtocolDeploymentContract(deploymentContract);
-dataset('invalidDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        // @ts-expect-error derived inputs must name a base measure on this dataset.
-        typo: measure.derived({ uses: { value: 'reveneu' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-dataset('crossDatasetDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        // @ts-expect-error qualified references cannot name measures from another dataset.
-        foreign: measure.derived({ uses: { value: 'other.revenue' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-dataset('missingBaseMeasures', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        // @ts-expect-error a dataset without base measures cannot define a derived input.
-        invalid: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-const Customers = dataset('customers', {
-    source: 'customers',
-    dimensions: {
-        id: dimension.string(),
-        status: dimension.string(),
-    },
-    measures: {
-        customerCount: measure.count('id'),
-    },
-});
-const revenueMetric = Orders.metric('revenueMetric', { measure: 'revenue' });
-const completedRevenueMetric = Orders.metric('completedRevenueMetric', { measure: 'completedRevenue' });
-const averageRevenueMetric = Orders.metric('averageRevenueMetric', {
-    uses: { revenue: revenueMetric, completedRevenue: completedRevenueMetric },
-    formula: ({ revenue, completedRevenue }) => add(revenue, completedRevenue),
-});
-const customerCountMetric = Customers.metric('customerCountMetric', { measure: 'customerCount' });
-const _publishedDatasets = publishDatasets()
-    .publish(Orders, { metrics: { revenue: revenueMetric } })
-    .publish(Customers, {
-    alias: 'accounts',
-    metrics: { customers: customerCountMetric },
-})
-    .build();
-const _cloudPublication = publishToCloud({
-    datasets: { Orders, Customers },
-    access: { roles: [], scopes: [] },
-});
-// @ts-expect-error published metrics must belong to the dataset being published.
-publishDatasets().publish(Orders, { metrics: { customerCountMetric } });
-const canonicalSchemas = buildCanonicalSemanticQuerySchemas({
-    orders: { ...Orders, metrics: { revenueMetric } },
-});
-canonicalSchemas.queryDataset.parse({ dataset: 'orders', measures: ['revenue'] });
-const _manifestHash = canonicalSchemas.manifestHash;
-const _statusFilter = eq('status', 'completed');
-const _createdAtRange = between('createdAt', '2025-01-01', '2025-01-31');
-const _revenueSort = desc('revenueMetric');
-Orders.metric('validDerivedMetric', {
-    uses: { revenue: revenueMetric },
-    formula: ({ revenue }) => add(revenue, revenue),
-});
-// @ts-expect-error derived metrics can only use base metrics from the same dataset.
-Orders.metric('invalidCrossDatasetDerivedMetric', {
-    uses: { customerCount: customerCountMetric },
-    formula: () => add('customerCount', 'customerCount'),
-});
-// @ts-expect-error derived metrics can only use base metrics, not derived metric refs.
-Orders.metric('invalidDerivedFromDerivedMetric', {
-    uses: { averageRevenue: averageRevenueMetric },
-    formula: () => add('averageRevenue', 'averageRevenue'),
-});
-const runtimeContext = {
-    runtime: {
-        tenant: 'tenant-1',
-    },
-};
-const abortableContext = {
-    abortSignal: new AbortController().signal,
-};
-void abortableContext;
-const _legacyTenantRuntimeContext = {
-    runtime: {
-        tenant: { id: 'tenant-1' },
-    },
-};
-const _tenantSetRuntimeContext = {
-    runtime: {
-        tenant: { in: ['tenant-1', 'tenant-2'] },
-    },
-};
-const _crossTenantRuntimeContext = {
-    runtime: {
-        tenant: { scope: 'all' },
-    },
-};
-const builderFactory = {
-    table: () => ({
-        select: () => builderFactory.table('orders'),
-        sum: () => builderFactory.table('orders'),
-        count: () => builderFactory.table('orders'),
-        countDistinct: () => builderFactory.table('orders'),
-        avg: () => builderFactory.table('orders'),
-        min: () => builderFactory.table('orders'),
-        max: () => builderFactory.table('orders'),
-        argMax: () => builderFactory.table('orders'),
-        argMin: () => builderFactory.table('orders'),
-        quantile: () => builderFactory.table('orders'),
-        stddev: () => builderFactory.table('orders'),
-        variance: () => builderFactory.table('orders'),
-        where: () => builderFactory.table('orders'),
-        leftJoin: () => builderFactory.table('orders'),
-        groupBy: () => builderFactory.table('orders'),
-        orderBy: () => builderFactory.table('orders'),
-        limit: () => builderFactory.table('orders'),
-        offset: () => builderFactory.table('orders'),
-        toSQLWithParams: () => ({ sql: 'SELECT 1', parameters: [] }),
-        execute: async () => [],
-    }),
-    rawQuery: async () => [],
-};
-const analytics = createDatasetClient({ queryBuilder: builderFactory });
-const _datasetCompilation = analytics.compileDataset(Orders, { measures: ['doubledRevenue'] });
-// @ts-expect-error compilation accepts declared dataset measures only.
-analytics.compileDataset(Orders, { measures: ['missing'] });
-// @ts-expect-error compilation accepts declared dataset dimensions only.
-analytics.compileDataset(Orders, { dimensions: ['missing'] });
-// @ts-expect-error standalone metric handles are not dataset compilation targets.
-analytics.compileDataset(Orders.metric('revenue', { measure: 'revenue' }));
-const explicitAnalytics = analytics;
-const datasetQuery = { dimensions: ['status'], measures: ['revenue'] };
-analytics.validate(revenueMetric, { dimensions: ['status'] }, runtimeContext);
-analytics.toSQL(completedRevenueMetric, { dimensions: ['status'] }, runtimeContext);
-analytics.toSQL(revenueMetric, { orderBy: [desc('revenueMetric')] }, runtimeContext);
-analytics.validate(Orders, datasetQuery, runtimeContext);
-analytics.toSQL(Orders, datasetQuery, runtimeContext);
-void analytics.execute(Orders, datasetQuery, runtimeContext);
-void runtimeContext;
-void explicitAnalytics;
-// Sanity: the simulated shape reproduces the original incompatibility.
-// @ts-expect-error a schema-typed builder does not satisfy the strict protocol
-const strictRejection = simulatedTypedFactory;
-const typedAccepted = simulatedTypedFactory;
-const typedClient = createDatasetClient({ queryBuilder: simulatedTypedFactory });
-const typedRuntime = { runtime: { builderFactory: simulatedTypedFactory } };
-// @ts-expect-error non-builder objects are still rejected
-const rejectedFactory = { notABuilder: true };
-void strictRejection;
-void typedAccepted;
-void typedClient;
-void typedRuntime;
-void rejectedFactory;
-// ---------------------------------------------------------------------------
-// Portable execution exclusions carry a named reason (HQ-45)
-// ---------------------------------------------------------------------------
-import { PortableExecutionUnsupportedError as PortableUnsupported, UNSUPPORTED_CONTRACT_REASONS as REASONS, UnsupportedContractFeatureError as ContractFeatureError, } from './index.js';
-const namedReason = REASONS.ambiguousMeasureSql;
-const literalReason = 'HQ_PORTABLE_DATASET_NOT_ACTIVATED';
-// @ts-expect-error an unnamed reason is not an exclusion
-const unnamedReason = 'HQ_PORTABLE_SOMETHING_ELSE';
-const featureReason = new ContractFeatureError('orders', 'metric', 'detail', namedReason).reason;
-// The three-argument constructor stays valid for existing callers.
-const legacyFeatureError = new ContractFeatureError('orders', 'metric', 'detail');
-const executionReason = new PortableUnsupported('message', { reason: literalReason }).reason;
-void unnamedReason;
-void featureReason;
-void legacyFeatureError;
-void executionReason;

package/dist/utils/time-arithmetic-sql.d.ts

@@ -1,4 +0,0 @@
-import type { TimeGrain } from '../types.js';
-export declare function addTimeSql(time: string, amount: string | number, grain: TimeGrain): string;
-export declare function subtractTimeSql(time: string, amount: number, grain: TimeGrain): string;
-//# sourceMappingURL=time-arithmetic-sql.d.ts.map

package/dist/utils/time-arithmetic-sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"time-arithmetic-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-arithmetic-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAE1F;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAEtF"}

package/dist/utils/time-arithmetic-sql.js

@@ -1,9 +0,0 @@
-const INTERVAL_FUNCTIONS = {
-    minute: 'Minutes', hour: 'Hours', day: 'Days', week: 'Weeks', month: 'Months', quarter: 'Quarters', year: 'Years',
-};
-export function addTimeSql(time, amount, grain) {
-    return `add${INTERVAL_FUNCTIONS[grain]}(${time}, ${amount})`;
-}
-export function subtractTimeSql(time, amount, grain) {
-    return `subtract${INTERVAL_FUNCTIONS[grain]}(${time}, ${amount})`;
-}

package/dist/utils/window-aggregation-sql.d.ts

@@ -1,5 +0,0 @@
-import type { MeasureDefinition } from '../types.js';
-/** NULL for an empty non-count population, including nullable measure inputs. */
-export declare function windowAggregateSql(definition: MeasureDefinition, value: string, arg: string): string;
-export declare function isCountAggregation(definition: MeasureDefinition): boolean;
-//# sourceMappingURL=window-aggregation-sql.d.ts.map

package/dist/utils/window-aggregation-sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-aggregation-sql.d.ts","sourceRoot":"","sources":["../../src/utils/window-aggregation-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAYpG;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAEzE"}

package/dist/utils/window-aggregation-sql.js

@@ -1,17 +0,0 @@
-/** NULL for an empty non-count population, including nullable measure inputs. */
-export function windowAggregateSql(definition, value, arg) {
-    switch (definition.aggregation) {
-        case 'count': return `count(${value})`;
-        case 'countDistinct': return `uniqExact(${value})`;
-        case 'approxCountDistinct': return `uniq(${value})`;
-        case 'percentile': return `quantileOrNull(${definition.level})(${value})`;
-        case 'argMax': return `argMaxOrNull(${value}, ${arg})`;
-        case 'argMin': return `argMinOrNull(${value}, ${arg})`;
-        case 'stddev': return `stddevSampOrNull(${value})`;
-        case 'variance': return `varSampOrNull(${value})`;
-        default: return `${definition.aggregation}OrNull(${value})`;
-    }
-}
-export function isCountAggregation(definition) {
-    return ['count', 'countDistinct', 'approxCountDistinct'].includes(definition.aggregation);
-}