@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/data-fabric-adapter/chart-adapters/line.js

@@ -0,0 +1,50 @@
+import { queryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { fetchDateBinnedData } from "../utils/fetch-date-binned-data.js";
+import { mapMetricToDataFabricAggregate } from "../utils/metric-aggregate.js";
+const dataFabricLineChartAdapter = (client, entityName)=>(configuration, dataModel)=>{
+        const firstDimensionId = assertDefined(configuration.dimensions[0], "Line chart must have at least one dimension");
+        const firstDimension = assertDefined(dataModel.dimensions.find((d)=>d.id === firstDimensionId), `Dimension ${firstDimensionId} not found in dataModel`);
+        const firstMetricId = assertDefined(configuration.metrics[0], "Line chart must have at least one metric");
+        const firstMetric = assertDefined(dataModel.metrics.find((m)=>m.id === firstMetricId), `Metric ${firstMetricId} not found in dataModel`);
+        assert("datetime" === firstDimension.type, "Dimension type must be datetime");
+        const aggregate = mapMetricToDataFabricAggregate(firstMetric);
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "line",
+                firstDimension.id,
+                JSON.stringify(filters),
+                JSON.stringify(aggregate),
+                JSON.stringify(configuration.joins),
+                JSON.stringify(configuration.from)
+            ],
+            queryFn: async ()=>{
+                const result = await fetchDateBinnedData({
+                    client,
+                    entityName,
+                    dimensionId: firstDimension.id,
+                    aggregates: [
+                        aggregate
+                    ],
+                    filters,
+                    joins: configuration.joins,
+                    from: configuration.from
+                });
+                if (!result) return {
+                    values: [],
+                    bins: []
+                };
+                const values = result.rows.map((r)=>z.number().nullable().parse(r[aggregate.alias] ?? null) ?? 0);
+                return {
+                    values,
+                    bins: result.bins
+                };
+            }
+        });
+    };
+export { dataFabricLineChartAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/multi-line.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import type { DataFabricClient } from "../utils/query";
+export declare const dataFabricMultiLineChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["multiLine"];

package/dist/registry/data-fabric-adapter/chart-adapters/multi-line.js

@@ -0,0 +1,48 @@
+import { queryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { fetchDateBinnedData } from "../utils/fetch-date-binned-data.js";
+import { mapMetricToDataFabricAggregate } from "../utils/metric-aggregate.js";
+const dataFabricMultiLineChartAdapter = (client, entityName)=>(configuration, dataModel)=>{
+        const firstDimensionId = assertDefined(configuration.dimensions[0], "Multi line chart must have at least one dimension");
+        const firstDimension = assertDefined(dataModel.dimensions.find((d)=>d.id === firstDimensionId), `Dimension ${firstDimensionId} not found in dataModel`);
+        assert("datetime" === firstDimension.type, "Dimension type must be datetime");
+        const metrics = configuration.metrics.map((id)=>assertDefined(dataModel.metrics.find((m)=>m.id === id), `Metric ${id} not found in dataModel`));
+        const aggregates = metrics.map((m)=>mapMetricToDataFabricAggregate(m));
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "multiLine",
+                firstDimension.id,
+                JSON.stringify(filters),
+                JSON.stringify(configuration.joins),
+                JSON.stringify(configuration.from),
+                ...aggregates.map((a)=>JSON.stringify(a))
+            ],
+            queryFn: async ()=>{
+                const result = await fetchDateBinnedData({
+                    client,
+                    entityName,
+                    dimensionId: firstDimension.id,
+                    aggregates,
+                    filters,
+                    joins: configuration.joins,
+                    from: configuration.from
+                });
+                if (!result) return {
+                    seriesByMetricId: {},
+                    bins: []
+                };
+                const seriesByMetricId = {};
+                for (const agg of aggregates)seriesByMetricId[agg.alias] = result.rows.map((r)=>z.number().nullable().parse(r[agg.alias] ?? null) ?? 0);
+                return {
+                    seriesByMetricId,
+                    bins: result.bins
+                };
+            }
+        });
+    };
+export { dataFabricMultiLineChartAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/table.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type DataFabricClient } from "../utils/query";
+export declare const dataFabricTableChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["table"];

package/dist/registry/data-fabric-adapter/chart-adapters/table.js

@@ -0,0 +1,34 @@
+import { queryOptions } from "@tanstack/react-query";
+import { mapConfigFilterToFilterValues, mapResponseToChartData } from "../../charts-core/charts-core.js";
+import { dataFabricQuery } from "../utils/query.js";
+import { createDataFabricChartQueryOptions } from "../utils/query-options.js";
+import { mapDataFabricResponseToChartData } from "../utils/response-data-mapper.js";
+const dataFabricTableChartAdapter = (client, entityName)=>(configuration, _dataModel, state)=>{
+        const dimensionIds = configuration.dimensions;
+        const requestBody = createDataFabricChartQueryOptions({
+            selectedFields: dimensionIds,
+            sortBy: state.sortBy,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f))
+        });
+        const fullRequestBody = {
+            ...requestBody,
+            joins: configuration.joins,
+            from: configuration.from
+        };
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "query",
+                JSON.stringify(fullRequestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await dataFabricQuery(client, entityName, fullRequestBody, "Failed to fetch table data");
+                const columnOriented = mapDataFabricResponseToChartData(body, dimensionIds);
+                return mapResponseToChartData({
+                    data: columnOriented,
+                    dimensions: dimensionIds
+                });
+            }
+        });
+    };
+export { dataFabricTableChartAdapter };

package/dist/registry/data-fabric-adapter/contract.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export declare const dataFabricContract: {
+    query: {
+        body: z.ZodObject<{
+            selectedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+            sortOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                fieldName: z.ZodString;
+                isDescending: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            filterGroup: z.ZodOptional<z.ZodObject<{
+                logicalOperator: z.ZodEnum<{
+                    and: "and";
+                    or: "or";
+                }>;
+                queryFilters: z.ZodArray<z.ZodObject<{
+                    fieldName: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        "=": "=";
+                        "!=": "!=";
+                        ">": ">";
+                        "<": "<";
+                        ">=": ">=";
+                        "<=": "<=";
+                        "not in": "not in";
+                        contains: "contains";
+                        "not contains": "not contains";
+                        startswith: "startswith";
+                        endswith: "endswith";
+                    }>;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            aggregates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                function: z.ZodEnum<{
+                    COUNT: "COUNT";
+                    MIN: "MIN";
+                    MAX: "MAX";
+                    SUM: "SUM";
+                    AVG: "AVG";
+                }>;
+                field: z.ZodString;
+                alias: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    INNER: "INNER";
+                    LEFT: "LEFT";
+                }>;
+                entity: z.ZodString;
+                alias: z.ZodOptional<z.ZodString>;
+                on: z.ZodObject<{
+                    left: z.ZodString;
+                    right: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+            from: z.ZodOptional<z.ZodObject<{
+                entity: z.ZodString;
+                alias: z.ZodString;
+            }, z.core.$strip>>;
+            binnings: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                fieldName: z.ZodString;
+                type: z.ZodLiteral<"Numeric">;
+                numericBinSize: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                fieldName: z.ZodString;
+                type: z.ZodLiteral<"Date">;
+                dateBinUnit: z.ZodEnum<{
+                    Day: "Day";
+                    Month: "Month";
+                    Week: "Week";
+                    Year: "Year";
+                    Quarter: "Quarter";
+                    Hour: "Hour";
+                }>;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>;
+        method: "POST";
+        pathParams: z.ZodObject<{
+            entityName: z.ZodString;
+        }, z.core.$strip>;
+        path: "/v2/EntityService/:entityName/query";
+        responses: {
+            200: z.ZodObject<{
+                totalRecordCount: z.ZodNumber;
+                value: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>>>;
+            }, z.core.$strip>;
+            400: z.ZodObject<{
+                error: z.ZodOptional<z.ZodObject<{
+                    message: z.ZodString;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        strictStatusCodes: true;
+    };
+};

package/dist/registry/data-fabric-adapter/contract.js

@@ -0,0 +1,27 @@
+import { initContract } from "@ts-rest/core";
+import { z } from "zod";
+import { DataFabricQueryRequestSchema, DataFabricQueryResponseSchema } from "./schemas/query-schema.js";
+const c = initContract();
+const queryErrorResponse = z.object({
+    error: z.object({
+        message: z.string(),
+        code: z.string().optional()
+    }).optional()
+});
+const dataFabricContract = c.router({
+    query: {
+        method: "POST",
+        path: "/v2/EntityService/:entityName/query",
+        responses: {
+            200: DataFabricQueryResponseSchema,
+            400: queryErrorResponse
+        },
+        pathParams: z.object({
+            entityName: z.string()
+        }),
+        body: DataFabricQueryRequestSchema
+    }
+}, {
+    strictStatusCodes: true
+});
+export { dataFabricContract };

package/dist/registry/data-fabric-adapter/data-fabric-adapter.d.ts

@@ -0,0 +1,2 @@
+export { dataFabricAdapter } from "./adapter";
+export { dataFabricContract } from "./contract";

package/dist/registry/data-fabric-adapter/data-fabric-adapter.js

@@ -0,0 +1,3 @@
+import { dataFabricAdapter } from "./adapter.js";
+import { dataFabricContract } from "./contract.js";
+export { dataFabricAdapter, dataFabricContract };

package/dist/registry/data-fabric-adapter/schemas/query-schema.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+export declare const DataFabricQueryFilterSchema: z.ZodObject<{
+    fieldName: z.ZodString;
+    operator: z.ZodEnum<{
+        in: "in";
+        "=": "=";
+        "!=": "!=";
+        ">": ">";
+        "<": "<";
+        ">=": ">=";
+        "<=": "<=";
+        "not in": "not in";
+        contains: "contains";
+        "not contains": "not contains";
+        startswith: "startswith";
+        endswith: "endswith";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+}, z.core.$strip>;
+declare const DataFabricBinningRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    fieldName: z.ZodString;
+    type: z.ZodLiteral<"Numeric">;
+    numericBinSize: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    fieldName: z.ZodString;
+    type: z.ZodLiteral<"Date">;
+    dateBinUnit: z.ZodEnum<{
+        Day: "Day";
+        Month: "Month";
+        Week: "Week";
+        Year: "Year";
+        Quarter: "Quarter";
+        Hour: "Hour";
+    }>;
+}, z.core.$strip>], "type">;
+export declare const DataFabricQueryRequestSchema: z.ZodObject<{
+    selectedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    top: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    sortOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fieldName: z.ZodString;
+        isDescending: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    filterGroup: z.ZodOptional<z.ZodObject<{
+        logicalOperator: z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>;
+        queryFilters: z.ZodArray<z.ZodObject<{
+            fieldName: z.ZodString;
+            operator: z.ZodEnum<{
+                in: "in";
+                "=": "=";
+                "!=": "!=";
+                ">": ">";
+                "<": "<";
+                ">=": ">=";
+                "<=": "<=";
+                "not in": "not in";
+                contains: "contains";
+                "not contains": "not contains";
+                startswith: "startswith";
+                endswith: "endswith";
+            }>;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    aggregates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        function: z.ZodEnum<{
+            COUNT: "COUNT";
+            MIN: "MIN";
+            MAX: "MAX";
+            SUM: "SUM";
+            AVG: "AVG";
+        }>;
+        field: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    from: z.ZodOptional<z.ZodObject<{
+        entity: z.ZodString;
+        alias: z.ZodString;
+    }, z.core.$strip>>;
+    binnings: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        fieldName: z.ZodString;
+        type: z.ZodLiteral<"Numeric">;
+        numericBinSize: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        fieldName: z.ZodString;
+        type: z.ZodLiteral<"Date">;
+        dateBinUnit: z.ZodEnum<{
+            Day: "Day";
+            Month: "Month";
+            Week: "Week";
+            Year: "Year";
+            Quarter: "Quarter";
+            Hour: "Hour";
+        }>;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+export declare const DataFabricQueryResponseSchema: z.ZodObject<{
+    totalRecordCount: z.ZodNumber;
+    value: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>>>;
+}, z.core.$strip>;
+export type DataFabricQueryRequest = z.infer<typeof DataFabricQueryRequestSchema>;
+export type DataFabricQueryResponse = z.infer<typeof DataFabricQueryResponseSchema>;
+export type DataFabricBinningRequest = z.infer<typeof DataFabricBinningRequestSchema>;
+export {};

package/dist/registry/data-fabric-adapter/schemas/query-schema.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { FromConfigSchema, JoinConfigSchema, PrimitiveValueSchema } from "../../charts-core/charts-core.js";
+const DataFabricSortOptionSchema = z.object({
+    fieldName: z.string(),
+    isDescending: z.boolean()
+});
+const DataFabricQueryFilterSchema = z.object({
+    fieldName: z.string(),
+    operator: z["enum"]([
+        "=",
+        "!=",
+        ">",
+        "<",
+        ">=",
+        "<=",
+        "in",
+        "not in",
+        "contains",
+        "not contains",
+        "startswith",
+        "endswith"
+    ]),
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z["null"](),
+        z.array(z.union([
+            z.string(),
+            z.number(),
+            z.boolean()
+        ]))
+    ])
+});
+const DataFabricFilterGroupSchema = z.object({
+    logicalOperator: z["enum"]([
+        "and",
+        "or"
+    ]),
+    queryFilters: z.array(DataFabricQueryFilterSchema)
+});
+const DataFabricAggregateRequestSchema = z.object({
+    function: z["enum"]([
+        "COUNT",
+        "SUM",
+        "AVG",
+        "MIN",
+        "MAX"
+    ]),
+    field: z.string(),
+    alias: z.string().optional()
+});
+const DataFabricBinningRequestSchema = z.discriminatedUnion("type", [
+    z.object({
+        fieldName: z.string(),
+        type: z.literal("Numeric"),
+        numericBinSize: z.number().positive()
+    }),
+    z.object({
+        fieldName: z.string(),
+        type: z.literal("Date"),
+        dateBinUnit: z["enum"]([
+            "Year",
+            "Quarter",
+            "Month",
+            "Week",
+            "Day",
+            "Hour"
+        ])
+    })
+]);
+const DataFabricQueryRequestSchema = z.object({
+    selectedFields: z.array(z.string()).optional(),
+    top: z.number().optional(),
+    skip: z.number().optional(),
+    sortOptions: z.array(DataFabricSortOptionSchema).optional(),
+    filterGroup: DataFabricFilterGroupSchema.optional(),
+    aggregates: z.array(DataFabricAggregateRequestSchema).optional(),
+    groupBy: z.array(z.string()).optional(),
+    joins: z.array(JoinConfigSchema).optional(),
+    from: FromConfigSchema.optional(),
+    binnings: z.array(DataFabricBinningRequestSchema).optional()
+});
+const DataFabricQueryResponseSchema = z.object({
+    totalRecordCount: z.number(),
+    value: z.array(z.record(z.string(), PrimitiveValueSchema))
+});
+export { DataFabricQueryFilterSchema, DataFabricQueryRequestSchema, DataFabricQueryResponseSchema };

package/dist/registry/data-fabric-adapter/utils/binning-utils.d.ts

@@ -0,0 +1,11 @@
+import { type Duration, Interval } from "luxon";
+import type { DataFabricBinningRequest } from "../schemas/query-schema";
+export type DateBinUnit = "Year" | "Quarter" | "Month" | "Week" | "Day" | "Hour";
+export declare function durationToDateBinUnit(duration: Duration): DateBinUnit;
+export declare function createNumericBinning(fieldName: string, numericBinSize: number): DataFabricBinningRequest;
+export declare function createDateBinning(fieldName: string, dateBinUnit: DateBinUnit): DataFabricBinningRequest;
+export declare function buildIntervalsFromDateBins(dateBinValues: string[], dateBinUnit: DateBinUnit): Interval[];
+export declare function buildNumericBins(binValues: number[], binSize: number): {
+    start: number;
+    end: number;
+}[];

package/dist/registry/data-fabric-adapter/utils/binning-utils.js

@@ -0,0 +1,68 @@
+import { DateTime, Interval } from "luxon";
+function durationToDateBinUnit(duration) {
+    if (duration.as("years") >= 1) return "Year";
+    if (duration.as("months") >= 3) return "Quarter";
+    if (duration.as("months") >= 1) return "Month";
+    if (duration.as("weeks") >= 1) return "Week";
+    if (duration.as("days") >= 1) return "Day";
+    return "Hour";
+}
+function createNumericBinning(fieldName, numericBinSize) {
+    return {
+        fieldName,
+        type: "Numeric",
+        numericBinSize
+    };
+}
+function createDateBinning(fieldName, dateBinUnit) {
+    return {
+        fieldName,
+        type: "Date",
+        dateBinUnit
+    };
+}
+function dateBinUnitToDuration(unit) {
+    switch(unit){
+        case "Year":
+            return {
+                years: 1
+            };
+        case "Quarter":
+            return {
+                months: 3
+            };
+        case "Month":
+            return {
+                months: 1
+            };
+        case "Week":
+            return {
+                weeks: 1
+            };
+        case "Day":
+            return {
+                days: 1
+            };
+        case "Hour":
+            return {
+                hours: 1
+            };
+    }
+}
+function buildIntervalsFromDateBins(dateBinValues, dateBinUnit) {
+    const durationObj = dateBinUnitToDuration(dateBinUnit);
+    return dateBinValues.map((dateStr)=>{
+        const start = DateTime.fromISO(dateStr, {
+            zone: "utc"
+        });
+        const end = start.plus(durationObj);
+        return Interval.fromDateTimes(start, end);
+    });
+}
+function buildNumericBins(binValues, binSize) {
+    return binValues.map((v)=>({
+            start: v,
+            end: v + binSize
+        }));
+}
+export { buildIntervalsFromDateBins, buildNumericBins, createDateBinning, createNumericBinning, durationToDateBinUnit };

package/dist/registry/data-fabric-adapter/utils/fetch-date-binned-data.d.ts

@@ -0,0 +1,20 @@
+import { type Interval } from "luxon";
+import { type FilterValues, type FromConfig, type JoinConfig } from "../../charts-core/charts-core";
+import type { DataFabricAggregate } from "./metric-aggregate";
+import { type DataFabricClient } from "./query";
+type DataModelAggregate = DataFabricAggregate;
+interface FetchDateBinnedDataOptions {
+    client: DataFabricClient;
+    entityName: string;
+    dimensionId: string;
+    aggregates: DataModelAggregate[];
+    filters: FilterValues[];
+    joins?: JoinConfig[];
+    from?: FromConfig;
+}
+interface DateBinnedResult {
+    bins: Interval[];
+    rows: Record<string, unknown>[];
+}
+export declare function fetchDateBinnedData({ client, entityName, dimensionId, aggregates, filters, joins, from, }: FetchDateBinnedDataOptions): Promise<DateBinnedResult | null>;
+export {};