metrickit 0.1.2

package/dist/registry.d.ts

@@ -0,0 +1,269 @@
+import { z } from 'zod';
+import type { AnyMetricDefinition } from './define-metric.ts';
+import { getOutputSchema as getOutputSchemaImpl } from './define-metric.ts';
+import type { MetricCatalogMetadata } from './catalog.ts';
+import type { BaseFilters, MetricResult, TimeGranularity, TimeSeriesOutput } from './schemas/index.ts';
+import { OutputSchemaMap } from './schemas/index.ts';
+export interface RegistryOptions<TBaseFilters extends BaseFilters = BaseFilters, TKindSchemas extends Record<string, z.ZodTypeAny> = typeof OutputSchemaMap> {
+    baseFilterSchema?: z.ZodType<TBaseFilters>;
+    kindSchemas?: TKindSchemas;
+}
+export declare function createRegistry<const TMetrics extends readonly AnyMetricDefinition[], TBaseFilters extends BaseFilters = BaseFilters, TKindSchemas extends Record<string, z.ZodTypeAny> = typeof OutputSchemaMap>(metrics: TMetrics, options?: RegistryOptions<TBaseFilters, TKindSchemas>): {
+    readonly metrics: TMetrics;
+    readonly baseFilterSchema: z.ZodType<TBaseFilters, unknown, z.core.$ZodTypeInternals<TBaseFilters, unknown>>;
+    readonly kindSchemas: TKindSchemas & {
+        readonly kpi: z.ZodObject<{
+            kind: z.ZodLiteral<"kpi">;
+            value: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            unit: z.ZodOptional<z.ZodEnum<{
+                DKK: "DKK";
+                EUR: "EUR";
+                USD: "USD";
+                GBP: "GBP";
+                SEK: "SEK";
+                NOK: "NOK";
+                PERCENTAGE: "PERCENTAGE";
+            }>>;
+            prefix: z.ZodOptional<z.ZodString>;
+            suffix: z.ZodOptional<z.ZodString>;
+            trend: z.ZodOptional<z.ZodEnum<{
+                up: "up";
+                down: "down";
+                flat: "flat";
+            }>>;
+        }, z.core.$strip>;
+        readonly timeseries: z.ZodObject<{
+            kind: z.ZodLiteral<"timeseries">;
+            granularity: z.ZodEnum<{
+                hour: "hour";
+                day: "day";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                year: "year";
+            }>;
+            series: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                points: z.ZodArray<z.ZodObject<{
+                    ts: z.ZodDate;
+                    value: z.ZodNumber;
+                    label: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                chartType: z.ZodOptional<z.ZodEnum<{
+                    line: "line";
+                    bar: "bar";
+                }>>;
+                axis: z.ZodOptional<z.ZodEnum<{
+                    left: "left";
+                    right: "right";
+                }>>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly distribution: z.ZodObject<{
+            kind: z.ZodLiteral<"distribution">;
+            total: z.ZodNumber;
+            segments: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodNumber;
+                percent: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            chartType: z.ZodOptional<z.ZodEnum<{
+                bar: "bar";
+                donut: "donut";
+                pie: "pie";
+                funnel: "funnel";
+            }>>;
+        }, z.core.$strip>;
+        readonly table: z.ZodObject<{
+            kind: z.ZodLiteral<"table">;
+            columns: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                }>>;
+                nullable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly leaderboard: z.ZodObject<{
+            kind: z.ZodLiteral<"leaderboard">;
+            items: z.ZodArray<z.ZodObject<{
+                rank: z.ZodNumber;
+                id: z.ZodString;
+                label: z.ZodString;
+                value: z.ZodNumber;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly pivot: z.ZodObject<{
+            kind: z.ZodLiteral<"pivot">;
+            rowDimension: z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            columnDimension: z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            rows: z.ZodArray<z.ZodString>;
+            columns: z.ZodArray<z.ZodString>;
+            values: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+            cellTooltips: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            totals: z.ZodOptional<z.ZodObject<{
+                rowTotals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                columnTotals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                grandTotal: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly metricKeys: [TMetrics[number]["key"], ...TMetrics[number]["key"][]];
+    readonly MetricKeySchema: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T ? { [k in keyof T]: T[k]; } : never>;
+    readonly MetricRequestSchema: z.ZodObject<{
+        key: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>;
+        requestKey: z.ZodOptional<z.ZodString>;
+        filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    readonly MetricsRequestSchema: z.ZodObject<{
+        metrics: z.ZodArray<z.ZodObject<{
+            key: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never>;
+            requestKey: z.ZodOptional<z.ZodString>;
+            filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        granularity: z.ZodOptional<z.ZodEnum<{
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            year: "year";
+        }>>;
+        from: z.ZodOptional<z.ZodDate>;
+        to: z.ZodOptional<z.ZodDate>;
+        compareToPrevious: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        disableCache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>;
+    readonly metricsByKey: Record<TMetrics[number]["key"], AnyMetricDefinition>;
+    readonly getMetricByKey: {
+        <K extends TMetrics[number]["key"]>(key: K): Extract<TMetrics[number], {
+            key: K;
+        }>;
+        (key: string): AnyMetricDefinition | undefined;
+    };
+    readonly parseMetricRequestInput: <K extends TMetrics[number]["key"], TRequestKey extends string | undefined = string | undefined>(metricRequest: {
+        key: K;
+        requestKey?: TRequestKey;
+        filters?: Partial<Omit<z.infer<Extract<TMetrics[number], {
+            key: K;
+        }>["filterSchema"]>, "from" | "to">>;
+    }, options?: {
+        from?: Date;
+        to?: Date;
+    }) => {
+        metric: Extract<TMetrics[number], {
+            key: K;
+        }>;
+        requestKey: K;
+        filters: z.infer<Extract<TMetrics[number], {
+            key: K;
+        }>["filterSchema"]>;
+    };
+    readonly getOutputSchema: typeof getOutputSchemaImpl;
+};
+export type AnyRegistry = ReturnType<typeof createRegistry<any>>;
+export type InferRegistryMetrics<R extends AnyRegistry> = R['metrics'];
+export type InferBaseFilters<R extends AnyRegistry> = z.infer<R['baseFilterSchema']>;
+export type InferAvailableMetricKey<R extends AnyRegistry> = InferRegistryMetrics<R>[number]['key'];
+export type GetMetricByKey<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = Extract<InferRegistryMetrics<R>[number], {
+    key: K;
+}>;
+export type MetricOutputFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = Awaited<ReturnType<GetMetricByKey<R, K>['resolve']>>;
+export type MetricFiltersFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = z.infer<GetMetricByKey<R, K>['filterSchema']>;
+export type MetricCatalogFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = GetMetricByKey<R, K>['catalog'] extends MetricCatalogMetadata | undefined ? GetMetricByKey<R, K>['catalog'] : MetricCatalogMetadata | undefined;
+type GlobalRequestFilterKeys = 'from' | 'to';
+export type MetricRequestFiltersFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = Omit<MetricFiltersFor<R, K>, GlobalRequestFilterKeys>;
+export type MetricKindFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = GetMetricByKey<R, K>['kind'];
+export type MetricSeriesKeysFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = MetricOutputFor<R, K> extends TimeSeriesOutput<infer SeriesKey> ? SeriesKey : never;
+export type MetricKeyToOutput<R extends AnyRegistry> = {
+    [K in InferAvailableMetricKey<R>]: MetricOutputFor<R, K>;
+};
+export type MetricKeyToFilters<R extends AnyRegistry> = {
+    [K in InferAvailableMetricKey<R>]: MetricFiltersFor<R, K>;
+};
+export type MetricKeyToKind<R extends AnyRegistry> = {
+    [K in InferAvailableMetricKey<R>]: MetricKindFor<R, K>;
+};
+export type MetricRequestFor<R extends AnyRegistry, K extends InferAvailableMetricKey<R> = InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined> = K extends InferAvailableMetricKey<R> ? {
+    key: K;
+    requestKey?: TRequestKey;
+    filters?: Partial<MetricRequestFiltersFor<R, K>>;
+} : never;
+export interface MetricsRequestFor<R extends AnyRegistry> {
+    metrics: readonly MetricRequestFor<R>[];
+    granularity?: TimeGranularity;
+    from?: Date;
+    to?: Date;
+    compareToPrevious?: boolean;
+    disableCache?: boolean;
+}
+export type IsValidMetricKey<R extends AnyRegistry, K extends string> = K extends InferAvailableMetricKey<R> ? true : false;
+export type MetricKeysOfKind<R extends AnyRegistry, Kind extends InferRegistryMetrics<R>[number]['kind']> = {
+    [K in InferAvailableMetricKey<R>]: MetricKindFor<R, K> extends Kind ? K : never;
+}[InferAvailableMetricKey<R>];
+export type TypedMetricResult<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> = MetricResult<MetricOutputFor<R, K>>;
+export type TypedMetricsResult<R extends AnyRegistry, Keys extends readonly InferAvailableMetricKey<R>[]> = {
+    metrics: {
+        [K in Keys[number]]?: TypedMetricResult<R, K>;
+    };
+    errors: Partial<Record<Keys[number], string>>;
+};
+type RequestedMetricResultKey<TMetricRequest> = TMetricRequest extends {
+    requestKey: infer TRequestKey extends string;
+} ? TRequestKey : TMetricRequest extends {
+    key: infer TMetricKey extends string;
+} ? TMetricKey : never;
+export type MetricRequestResultKey<TMetricRequest> = RequestedMetricResultKey<TMetricRequest>;
+export declare function getMetricResultKey<TMetricRequest extends {
+    key: string;
+    requestKey?: string;
+}>(metricRequest: TMetricRequest): MetricRequestResultKey<TMetricRequest>;
+export type RequestedMetricKeys<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]> = RequestedMetricResultKey<TMetricRequests[number]>;
+export type MetricRequestForResultKey<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[], TResultKey extends RequestedMetricKeys<R, TMetricRequests>> = Extract<TMetricRequests[number], {
+    requestKey: TResultKey;
+}> extends never ? Extract<TMetricRequests[number], {
+    key: TResultKey;
+}> : Extract<TMetricRequests[number], {
+    requestKey: TResultKey;
+}>;
+export type MetricResultForResultKey<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[], TResultKey extends RequestedMetricKeys<R, TMetricRequests>> = MetricRequestForResultKey<R, TMetricRequests, TResultKey> extends {
+    key: infer TMetricKey extends InferAvailableMetricKey<R>;
+} ? TypedMetricResult<R, TMetricKey> : never;
+export type MetricsExecutionResult<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]> = {
+    metrics: {
+        [TResultKey in RequestedMetricKeys<R, TMetricRequests>]?: MetricResultForResultKey<R, TMetricRequests, TResultKey>;
+    };
+    errors: Partial<Record<RequestedMetricKeys<R, TMetricRequests>, string>>;
+};
+export type MetricResultChunkFor<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]> = TMetricRequests[number] extends infer TMetricRequest ? TMetricRequest extends {
+    key: infer TMetricKey extends InferAvailableMetricKey<R>;
+} ? {
+    key: TMetricKey;
+    requestKey?: RequestedMetricResultKey<TMetricRequest>;
+    result?: TypedMetricResult<R, TMetricKey>;
+    error?: string;
+    done: boolean;
+} : never : never;
+export declare function getMetric<R extends AnyRegistry, Keys extends readonly InferAvailableMetricKey<R>[], K extends Keys[number]>(result: TypedMetricsResult<R, Keys>, key: K): {
+    current: MetricOutputFor<R, K>;
+    previous: MetricOutputFor<R, K> | undefined;
+} | undefined;
+export {};

package/dist/run-metrics.d.ts

@@ -0,0 +1,14 @@
+import type { CacheAdapter } from './cache.ts';
+import type { AnyRegistry, InferRegistryMetrics, MetricRequestFor, MetricResultChunkFor, MetricsExecutionResult, MetricsRequestFor } from './registry.ts';
+export type MetricsRequest<R extends AnyRegistry = AnyRegistry> = MetricsRequestFor<R>;
+export type MetricsResult<R extends AnyRegistry = AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[] = readonly MetricRequestFor<R>[]> = MetricsExecutionResult<R, TMetricRequests>;
+export type MetricResultChunk<R extends AnyRegistry = AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[] = readonly MetricRequestFor<R>[]> = MetricResultChunkFor<R, TMetricRequests>;
+export interface RunMetricsOptions<TContext = unknown, R extends AnyRegistry = AnyRegistry, TRequest extends MetricsRequest<R> = MetricsRequest<R>> {
+    registry: R;
+    request: TRequest;
+    createContext: () => TContext | Promise<TContext>;
+    cache?: CacheAdapter;
+    hasAccess?: (metric: InferRegistryMetrics<R>[number]) => boolean;
+}
+export declare function runMetrics<TContext, R extends AnyRegistry, TRequest extends MetricsRequest<R>>(options: RunMetricsOptions<TContext, R, TRequest>): Promise<MetricsResult<R, TRequest['metrics']>>;
+export declare function runMetricsStream<TContext, R extends AnyRegistry, TRequest extends MetricsRequest<R>>(options: RunMetricsOptions<TContext, R, TRequest>): AsyncGenerator<MetricResultChunk<R, TRequest['metrics']>, void, unknown>;

package/dist/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export * from './time.ts';
+export * from './output.ts';
+export * from './inputs.ts';
+export * from './metric-type.ts';

package/dist/schemas/inputs.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const BaseFiltersSchema: z.ZodObject<{
+    organizationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodDate>;
+    to: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type BaseFilters = z.infer<typeof BaseFiltersSchema>;
+export declare const TimeSeriesFiltersSchema: z.ZodObject<{
+    organizationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    from: z.ZodDate;
+    to: z.ZodDate;
+}, z.core.$strip>;
+export type TimeSeriesFilters = z.infer<typeof TimeSeriesFiltersSchema>;
+export declare function extendBaseFilters<T extends z.ZodRawShape>(shape: T): z.ZodObject<typeof BaseFiltersSchema.shape & {
+    [K in keyof T]: z.ZodOptional<T[K]>;
+}>;
+export declare function extendTimeSeriesFilters<T extends z.ZodRawShape>(shape: T): z.ZodObject<typeof TimeSeriesFiltersSchema.shape & {
+    [K in keyof T]: z.ZodOptional<T[K]>;
+}>;

package/dist/schemas/metric-type.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const MetricTypeSchema: z.ZodEnum<{
+    TOTAL: "TOTAL";
+    AVG: "AVG";
+    PER_BUCKET: "PER_BUCKET";
+}>;
+export type MetricType = z.infer<typeof MetricTypeSchema>;