@cohesivesystems/presentation-core 0.1.0-alpha.1

package/dist/data-source-projection.js

@@ -0,0 +1,880 @@
+import { findPresentationDataSource, } from './module.js';
+import { isTanStackQueryBinding, presentationDataSourceBindings, presentationDataSourceAuthorization, } from './presentation-data-source-binding-model.js';
+import { createDataSourceEndpointQueryRequest, createDataSourcePaginationRequest, findDataSourceQueryEndpointBinding, } from './data-source-query-lowering.js';
+import { aggregateOperators, cachePolicyKinds, dataSourceAggregateMaterializationKinds, dataSourceAggregatePredicateKinds, dataSourceKindLabels, dataSourceKinds, presentationBindingKinds, } from '@cohesivesystems/presentation-contracts';
+import { readPresentationQueryFormAppliedValue, } from './presentation-query-form-state.js';
+import { readObjectPath, writeObjectPath, } from './object-path.js';
+/** Preserves target interpretation objects as a named projection concept. */
+export function createPresentationDataSourceTargetInterpretation(interpretation) {
+    return interpretation;
+}
+/**
+ * Resolves authorization from the target interpretation based on the backend
+ * binding kind declared for the data source.
+ */
+export function resolvePresentationDataSourceTargetAuthorization(targetInterpretation, context) {
+    const options = readPresentationDataSourceTargetBindingOptions(context.binding);
+    if (options.authorizationPolicyId) {
+        return (targetInterpretation?.authorizationPoliciesById?.[options.authorizationPolicyId]?.(context) ??
+            presentationDataSourceAuthorization.required({
+                blockedLabel: `No frontend authorization policy is registered for '${options.authorizationPolicyId}'.`,
+                isAuthorized: false,
+            }));
+    }
+    if (isApiEndpointBinding(context.binding)) {
+        return (targetInterpretation?.apiEndpoint?.authorization?.(context) ??
+            targetInterpretation?.defaultAuthorization?.(context) ??
+            presentationDataSourceAuthorization.none());
+    }
+    if (isLocalStateBinding(context.binding)) {
+        return (targetInterpretation?.localState?.authorization?.(context) ??
+            targetInterpretation?.defaultAuthorization?.(context) ??
+            presentationDataSourceAuthorization.none());
+    }
+    return (targetInterpretation?.defaultAuthorization?.(context) ??
+        presentationDataSourceAuthorization.none());
+}
+/** Creates a local-value binding with authorization supplied by the target. */
+export function createTargetInterpretedLocalValueDataSourceBinding(context, targetInterpretation, binding) {
+    const { authorization, ...bindingWithoutAuthorization } = binding;
+    return presentationDataSourceBindings.localValue({
+        ...bindingWithoutAuthorization,
+        authorization: authorization ??
+            resolvePresentationDataSourceTargetAuthorization(targetInterpretation, context),
+    });
+}
+/** Creates a TanStack Query binding with authorization supplied by the target. */
+export function createTargetInterpretedTanStackQueryDataSourceBinding(context, targetInterpretation, binding, defaultAuthorization) {
+    const { authorization, ...bindingWithoutAuthorization } = binding;
+    return presentationDataSourceBindings.tanstackQuery({
+        ...bindingWithoutAuthorization,
+        authorization: authorization ??
+            defaultAuthorization?.(context) ??
+            resolvePresentationDataSourceTargetAuthorization(targetInterpretation, context),
+    });
+}
+/** Creates endpoint-query binding input from backend-declared query lowering. */
+export function createDataSourceEndpointQueryBindingInput({ context, defaultRequest, emptyMessage, enabled, endpointId, fallbackData, paginationRequest, pendingLabel, queryKeyParts = [], refetchInterval, retry, staleTime, targetInterpretation, transforms, value, }) {
+    const loweredTransforms = mergeDataSourceQueryLoweringTransforms(targetInterpretation.queryLowering?.transformsById, transforms);
+    const query = createDataSourceEndpointQueryRequest({
+        dataSource: context.dataSource,
+        defaultRequest,
+        endpointId,
+        paginationRequest,
+        transforms: loweredTransforms,
+        value,
+    });
+    const runtimeOptions = readDataSourceBindingRuntimeOptions(context.dataSource);
+    return {
+        dataSourceId: context.dataSource.Id,
+        emptyMessage: emptyMessage ?? runtimeOptions.emptyMessage,
+        enabled,
+        fallbackData: fallbackData === undefined ? runtimeOptions.fallbackData : fallbackData,
+        pendingLabel: pendingLabel ?? runtimeOptions.pendingLabel,
+        queryFn: () => executePresentationDataSourceTargetEndpoint(targetInterpretation, endpointId, { query }, { binding: context.binding }),
+        queryKey: [
+            'presentation-data-source-endpoint-query',
+            context.dataSource.Id,
+            endpointId,
+            query,
+            ...queryKeyParts,
+        ],
+        refetchInterval: refetchInterval ?? runtimeOptions.refetchInterval,
+        retry: retry ?? runtimeOptions.retry,
+        staleTime: staleTime ?? runtimeOptions.staleTime,
+    };
+}
+/** Creates a fully wrapped endpoint-query binding from backend query lowering. */
+export function createDataSourceEndpointQueryBinding(options) {
+    return createTargetInterpretedTanStackQueryDataSourceBinding(options.context, options.targetInterpretation, createDataSourceEndpointQueryBindingInput(options));
+}
+/** Creates a default binding registry for backend-declared collection-query data sources. */
+export function createCollectionQueryDataSourceBindingProjectionRegistry({ paginationRequestsByDataSourceId = {}, queryKeyParts = [], resolveLocalValue, resolveTransforms, resolveValue, targetInterpretation, }) {
+    return {
+        apiEndpoint: (context) => {
+            if (!isCollectionQueryDataSource(context.dataSource) ||
+                !context.dataSource.Query) {
+                return null;
+            }
+            const localValue = resolveLocalValue?.(context);
+            if (localValue) {
+                return createTargetInterpretedLocalValueDataSourceBinding(context, targetInterpretation, localValue);
+            }
+            const endpointId = readPresentationDataSourceEndpointId(context.binding);
+            if (!endpointId) {
+                return null;
+            }
+            return createDataSourceEndpointQueryBinding({
+                context,
+                endpointId,
+                paginationRequest: paginationRequestsByDataSourceId[context.dataSource.Id],
+                queryKeyParts: resolveQueryKeyParts(queryKeyParts, context),
+                targetInterpretation,
+                transforms: resolveTransforms?.(context),
+                value: resolveValue?.(context) ??
+                    readPresentationQueryFormAppliedValue(context.context, context.dataSource.Id),
+            });
+        },
+    };
+}
+/** Creates a default binding registry for backend-declared aggregate-query data sources. */
+export function createAggregateQueryDataSourceBindingProjectionRegistry({ queryKeyParts = [], resolveTransforms, resolveValue, targetInterpretation, }) {
+    return {
+        fallback: (context) => {
+            if (!isAggregateQueryDataSource(context.dataSource) ||
+                !context.dataSource.Aggregation) {
+                return null;
+            }
+            return createDataSourceAggregateQueryBinding({
+                context,
+                queryKeyParts: resolveQueryKeyParts(queryKeyParts, context),
+                targetInterpretation,
+                transforms: resolveTransforms?.(context),
+                value: resolveValue?.(context),
+            });
+        },
+    };
+}
+/** Creates a default fetch binding registry for endpoint-backed data sources. */
+export function createApiEndpointFetchDataSourceBindingProjectionRegistry({ queryKeyParts = [], targetInterpretation, }) {
+    return {
+        apiEndpoint: (context) => {
+            if (context.dataSource.Query || isPromptPreviewDataSource(context.dataSource)) {
+                return null;
+            }
+            const endpointId = readPresentationDataSourceEndpointId(context.binding);
+            if (!endpointId) {
+                return null;
+            }
+            return createDataSourceEndpointFetchBinding({
+                context,
+                endpointId,
+                queryKeyParts: resolveQueryKeyParts(queryKeyParts, context),
+                targetInterpretation,
+            });
+        },
+    };
+}
+/** Creates a default binding registry for frontend-owned local-state data sources. */
+export function createLocalStateDataSourceBindingProjectionRegistry({ resolveLocalValue, targetInterpretation, }) {
+    return {
+        fallback: (context) => {
+            if (!isLocalStateDataSource(context.dataSource)) {
+                return null;
+            }
+            const localValue = resolveLocalValue(context);
+            return localValue
+                ? createTargetInterpretedLocalValueDataSourceBinding(context, targetInterpretation, localValue)
+                : null;
+        },
+    };
+}
+/**
+ * Creates a binding registry that exposes action-result state writes as local
+ * values for their target data sources.
+ */
+export function createActionResultStateDataSourceBindingProjectionRegistry({ targetInterpretation, values = {}, }) {
+    return {
+        fallback: (context) => {
+            if (!hasOwn(values, context.dataSource.Id)) {
+                return null;
+            }
+            return createTargetInterpretedLocalValueDataSourceBinding(context, targetInterpretation, {
+                data: values[context.dataSource.Id],
+                dataSourceId: context.dataSource.Id,
+            });
+        },
+    };
+}
+/** Adapts data-source query interpretation metadata to collection/aggregate projector hooks. */
+export function createDataSourceQueryInterpretationResolvers({ byDataSourceId = {}, defaultQueryKeyParts = [], transforms, }) {
+    return {
+        queryKeyParts: (context) => resolveQueryKeyParts(byDataSourceId[context.dataSource.Id]?.queryKeyParts ?? defaultQueryKeyParts, context),
+        resolveLocalValue: (context) => byDataSourceId[context.dataSource.Id]?.localValue?.(context),
+        resolveTransforms: (context) => resolveDataSourceQueryInterpretationTransforms(byDataSourceId[context.dataSource.Id], transforms, context),
+        resolveValue: (context) => resolveDataSourceQueryInterpretationValue(byDataSourceId[context.dataSource.Id], context),
+    };
+}
+/** Creates endpoint-fetch binding input from an API endpoint data source. */
+export function createDataSourceEndpointFetchBindingInput({ context, emptyMessage, enabled, endpointId, fallbackData, pendingLabel, queryKeyParts = [], refetchInterval, retry, routeParameters, staleTime, targetInterpretation, }) {
+    const runtimeOptions = readDataSourceBindingRuntimeOptions(context.dataSource);
+    const resolvedEndpointId = endpointId ?? readPresentationDataSourceEndpointId(context.binding);
+    const resolvedRouteParameters = routeParameters ??
+        projectDataSourceRouteParameters(context.dataSource.Parameters, context.context.routeParameters);
+    const hasRequiredRouteParameters = hasRequiredDataSourceRouteParameters(context.dataSource.Parameters, resolvedRouteParameters);
+    return {
+        dataSourceId: context.dataSource.Id,
+        emptyMessage: emptyMessage ?? runtimeOptions.emptyMessage,
+        enabled: Boolean(resolvedEndpointId) && (enabled ?? true) && hasRequiredRouteParameters,
+        fallbackData: fallbackData === undefined ? runtimeOptions.fallbackData : fallbackData,
+        pendingLabel: pendingLabel ?? runtimeOptions.pendingLabel,
+        queryFn: () => resolvedEndpointId
+            ? executePresentationDataSourceTargetEndpoint(targetInterpretation, resolvedEndpointId, { routeParameters: resolvedRouteParameters }, { binding: context.binding })
+            : Promise.reject(new Error(`Data source '${context.dataSource.Id}' is not bound to an API endpoint.`)),
+        queryKey: [
+            'presentation-data-source-endpoint-fetch',
+            context.dataSource.Id,
+            resolvedEndpointId,
+            resolvedRouteParameters,
+            ...queryKeyParts,
+        ],
+        refetchInterval: refetchInterval ?? runtimeOptions.refetchInterval,
+        retry: retry ?? runtimeOptions.retry,
+        staleTime: staleTime ?? runtimeOptions.staleTime,
+    };
+}
+/** Creates a fully wrapped endpoint-fetch binding from an API endpoint data source. */
+export function createDataSourceEndpointFetchBinding(options) {
+    return createTargetInterpretedTanStackQueryDataSourceBinding(options.context, options.targetInterpretation, createDataSourceEndpointFetchBindingInput(options));
+}
+/** Creates a binding that materializes a source data source and evaluates aggregate measures. */
+export function createDataSourceAggregateQueryBinding({ context, queryKeyParts = [], targetInterpretation, transforms, value, }) {
+    const aggregation = context.dataSource.Aggregation;
+    if (!aggregation) {
+        return null;
+    }
+    const sourceDataSource = findPresentationDataSource(context.module, aggregation.SourceDataSourceId);
+    const sourceEndpointId = readPresentationDataSourceEndpointId(sourceDataSource?.Binding);
+    if (!sourceDataSource || !sourceEndpointId) {
+        return createTargetInterpretedTanStackQueryDataSourceBinding(context, targetInterpretation, {
+            authorization: presentationDataSourceAuthorization.required({
+                blockedLabel: `Aggregate data source '${context.dataSource.Id}' cannot resolve source '${aggregation.SourceDataSourceId}'.`,
+                isAuthorized: false,
+            }),
+            dataSourceId: context.dataSource.Id,
+            queryFn: () => Promise.resolve(evaluateDataSourceAggregateQuery(aggregation, [])),
+            queryKey: [
+                'presentation-data-source-aggregate-query',
+                context.dataSource.Id,
+                aggregation.SourceDataSourceId,
+                'missing-source',
+                ...queryKeyParts,
+            ],
+        });
+    }
+    const appliedValue = value ?? readPresentationQueryFormAppliedValue(context.context, context.dataSource.Id);
+    const runtimeOptions = readDataSourceBindingRuntimeOptions(context.dataSource);
+    const fallbackData = runtimeOptions.fallbackData === undefined
+        ? evaluateDataSourceAggregateQuery(aggregation, [])
+        : runtimeOptions.fallbackData;
+    const sourceAuthorization = resolvePresentationDataSourceTargetAuthorization(targetInterpretation, {
+        ...context,
+        binding: sourceDataSource.Binding ?? null,
+        dataSource: sourceDataSource,
+    });
+    const loweredTransforms = mergeDataSourceQueryLoweringTransforms(targetInterpretation.queryLowering?.transformsById, transforms);
+    return createTargetInterpretedTanStackQueryDataSourceBinding(context, targetInterpretation, {
+        authorization: sourceAuthorization,
+        dataSourceId: context.dataSource.Id,
+        fallbackData,
+        pendingLabel: runtimeOptions.pendingLabel,
+        queryFn: async () => {
+            const items = await materializeDataSourceAggregateItems({
+                aggregation,
+                sourceDataSource,
+                sourceEndpointId,
+                targetInterpretation,
+                transforms: loweredTransforms,
+                value: appliedValue,
+            });
+            return evaluateDataSourceAggregateQuery(aggregation, items);
+        },
+        queryKey: [
+            'presentation-data-source-aggregate-query',
+            context.dataSource.Id,
+            sourceDataSource.Id,
+            appliedValue ?? {},
+            aggregation,
+            ...queryKeyParts,
+        ],
+        refetchInterval: runtimeOptions.refetchInterval,
+        retry: runtimeOptions.retry,
+        staleTime: runtimeOptions.staleTime,
+    });
+}
+/** Executes an API endpoint through the active target interpretation. */
+export function executePresentationDataSourceTargetEndpoint(targetInterpretation, endpointId, request = {}, options = {}) {
+    const executeEndpoint = resolvePresentationDataSourceTargetEndpointExecutor(targetInterpretation, options.binding);
+    if (!executeEndpoint) {
+        const executionTargetId = readPresentationDataSourceTargetBindingOptions(options.binding).executionTargetId;
+        return Promise.reject(new Error(executionTargetId
+            ? `No API endpoint executor is registered for presentation data-source execution target '${executionTargetId}'.`
+            : `No API endpoint executor is registered for presentation data-source endpoint '${endpointId}'.`));
+    }
+    return executeEndpoint(endpointId, request);
+}
+/**
+ * Composes independently owned data-source binding registries into one
+ * projection registry. Later registries override earlier factories for the same
+ * data-source or endpoint id so app-level composition can replace defaults at
+ * narrower ownership boundaries.
+ */
+export function mergePresentationDataSourceBindingProjectionRegistries(...registries) {
+    let defaultAuthorization;
+    for (const registry of registries) {
+        defaultAuthorization = registry.defaultAuthorization ?? defaultAuthorization;
+    }
+    return {
+        apiEndpoint: resolveApiEndpointFactory(registries),
+        byDataSourceId: Object.assign({}, ...registries.map((registry) => registry.byDataSourceId ?? {})),
+        byEndpointId: Object.assign({}, ...registries.map((registry) => registry.byEndpointId ?? {})),
+        defaultAuthorization,
+        fallback: resolveFallbackFactory(registries),
+    };
+}
+/**
+ * Projects semantic data-source definitions onto concrete frontend binding
+ * plans. React hooks are deliberately not used here; hook-backed realization is
+ * handled later by PresentationDataSourceBinder.
+ */
+export function projectPresentationDataSourceBindings({ context = {}, dataSourceDefinitions = [], dataSourceIds, module, registry, }) {
+    const uniqueDataSourceIds = Array.from(new Set(dataSourceIds));
+    const fallbackDataSourcesById = new Map(dataSourceDefinitions.map((dataSource) => [dataSource.Id, dataSource]));
+    return uniqueDataSourceIds.flatMap((dataSourceId) => {
+        const dataSource = findPresentationDataSource(module, dataSourceId) ??
+            fallbackDataSourcesById.get(dataSourceId) ??
+            null;
+        if (!dataSource) {
+            return [];
+        }
+        const binding = dataSource.Binding ?? null;
+        const factoryContext = {
+            binding,
+            context,
+            dataSource,
+            module,
+        };
+        const factory = resolveDataSourceBindingFactory(registry, dataSource);
+        const projectedBinding = factory?.(factoryContext) ??
+            createUnboundDataSourceBinding(dataSource, registry.defaultAuthorization?.(factoryContext));
+        return [applyDataSourceDefaults(projectedBinding, dataSource)];
+    });
+}
+/**
+ * Adapts TanStack Query binding-input factories into a full projection
+ * registry by applying target-level authorization to every produced binding.
+ */
+export function createTanStackQueryDataSourceBindingProjectionRegistry({ apiEndpoint, byDataSourceId, byEndpointId, defaultAuthorization, targetInterpretation, }) {
+    return {
+        apiEndpoint: apiEndpoint
+            ? (context) => {
+                const binding = apiEndpoint(context);
+                return binding
+                    ? createTargetInterpretedTanStackQueryDataSourceBinding(context, targetInterpretation, binding, defaultAuthorization)
+                    : binding;
+            }
+            : undefined,
+        byDataSourceId,
+        byEndpointId: mapFactories(byEndpointId, (factory) => (context) => {
+            const binding = factory(context);
+            return binding
+                ? createTargetInterpretedTanStackQueryDataSourceBinding(context, targetInterpretation, binding, defaultAuthorization)
+                : binding;
+        }),
+        defaultAuthorization,
+    };
+}
+/**
+ * Creates a generic TanStack Query projection registry for API endpoint data
+ * sources. The registry resolves endpoint ids from backend bindings, projects
+ * route parameters, applies runtime annotations, and executes through the
+ * active target interpretation.
+ */
+export function createApiEndpointTanStackQueryDataSourceBindingProjectionRegistry({ createQueryKey, defaultAuthorization, executeEndpoint, isEnabled, pendingLabel, retry, targetInterpretation, }) {
+    return createTanStackQueryDataSourceBindingProjectionRegistry({
+        apiEndpoint: (context) => {
+            const endpointId = readPresentationDataSourceEndpointId(context.binding);
+            if (!endpointId) {
+                return null;
+            }
+            const endpointExecutor = executeEndpoint ??
+                resolvePresentationDataSourceTargetEndpointExecutor(targetInterpretation, context.binding);
+            if (!endpointExecutor) {
+                return null;
+            }
+            const routeParameters = projectDataSourceRouteParameters(context.dataSource.Parameters, context.context.routeParameters);
+            const apiContext = {
+                ...context,
+                endpointId,
+                routeParameters,
+            };
+            const runtimeOptions = readDataSourceBindingRuntimeOptions(context.dataSource);
+            const targetIsEnabled = targetInterpretation?.apiEndpoint?.isEnabled?.(apiContext);
+            const projectedIsEnabled = isEnabled?.(apiContext);
+            return {
+                dataSourceId: context.dataSource.Id,
+                enabled: (targetIsEnabled ?? true) &&
+                    (projectedIsEnabled ?? true) &&
+                    hasRequiredDataSourceRouteParameters(context.dataSource.Parameters, routeParameters),
+                emptyMessage: runtimeOptions.emptyMessage,
+                fallbackData: runtimeOptions.fallbackData,
+                pendingLabel: resolveApiEndpointDataSourcePendingLabel(pendingLabel ??
+                    runtimeOptions.pendingLabel ??
+                    targetInterpretation?.apiEndpoint?.pendingLabel, apiContext),
+                queryFn: () => endpointExecutor(endpointId, { routeParameters }),
+                queryKey: createQueryKey?.(apiContext) ??
+                    targetInterpretation?.apiEndpoint?.createQueryKey?.(apiContext) ??
+                    createDefaultApiEndpointDataSourceQueryKey(apiContext),
+                refetchInterval: runtimeOptions.refetchInterval,
+                retry: retry ?? runtimeOptions.retry ?? targetInterpretation?.apiEndpoint?.retry ?? false,
+                staleTime: runtimeOptions.staleTime,
+            };
+        },
+        defaultAuthorization,
+        targetInterpretation,
+    });
+}
+function resolveApiEndpointFactory(registries) {
+    const factories = registries.flatMap((registry) => registry.apiEndpoint ? [registry.apiEndpoint] : []);
+    if (factories.length === 0) {
+        return undefined;
+    }
+    return (context) => {
+        for (let i = factories.length - 1; i >= 0; i -= 1) {
+            const binding = factories[i]?.(context);
+            if (binding) {
+                return binding;
+            }
+        }
+        return null;
+    };
+}
+function resolveFallbackFactory(registries) {
+    const factories = registries.flatMap((registry) => registry.fallback ? [registry.fallback] : []);
+    if (factories.length === 0) {
+        return undefined;
+    }
+    return (context) => {
+        for (let i = factories.length - 1; i >= 0; i -= 1) {
+            const binding = factories[i]?.(context);
+            if (binding) {
+                return binding;
+            }
+        }
+        return null;
+    };
+}
+function resolveDataSourceBindingFactory(registry, dataSource) {
+    const endpointId = isApiEndpointBinding(dataSource.Binding)
+        ? dataSource.Binding?.EndpointId
+        : null;
+    const exactFactory = registry.byDataSourceId?.[dataSource.Id] ??
+        (endpointId ? registry.byEndpointId?.[endpointId] : undefined);
+    if (exactFactory) {
+        return exactFactory;
+    }
+    const genericFactories = [
+        endpointId ? registry.apiEndpoint : undefined,
+        registry.fallback,
+    ].filter((factory) => Boolean(factory));
+    if (genericFactories.length === 0) {
+        return undefined;
+    }
+    return (context) => {
+        for (const factory of genericFactories) {
+            const binding = factory(context);
+            if (binding) {
+                return binding;
+            }
+        }
+        return null;
+    };
+}
+function isAggregateQueryDataSource(dataSource) {
+    return matchesDataSourceKind(dataSource.Kind, dataSourceKinds.aggregateQuery, 'aggregateQuery');
+}
+function isCollectionQueryDataSource(dataSource) {
+    return matchesDataSourceKind(dataSource.Kind, dataSourceKinds.collectionQuery, 'collectionQuery');
+}
+function isLocalStateDataSource(dataSource) {
+    return matchesDataSourceKind(dataSource.Kind, dataSourceKinds.localState, 'localState');
+}
+function isPromptPreviewDataSource(dataSource) {
+    return matchesDataSourceKind(dataSource.Kind, dataSourceKinds.promptPreview, 'promptPreview');
+}
+function matchesDataSourceKind(value, numericValue, camelLabel) {
+    const pascalLabel = dataSourceKindLabels[numericValue];
+    return (value === numericValue ||
+        String(value) === String(numericValue) ||
+        String(value) === pascalLabel ||
+        String(value).toLocaleLowerCase() === camelLabel.toLocaleLowerCase());
+}
+function resolveQueryKeyParts(queryKeyParts, context) {
+    return typeof queryKeyParts === 'function'
+        ? queryKeyParts(context)
+        : queryKeyParts;
+}
+function resolveDataSourceQueryInterpretationTransforms(interpretation, registryTransforms, context) {
+    const resolvedRegistryTransforms = resolveDataSourceQueryTransforms(registryTransforms, context);
+    const resolvedInterpretationTransforms = resolveDataSourceQueryTransforms(interpretation?.transforms, context);
+    if (!resolvedRegistryTransforms) {
+        return resolvedInterpretationTransforms;
+    }
+    if (!resolvedInterpretationTransforms) {
+        return resolvedRegistryTransforms;
+    }
+    return {
+        ...resolvedRegistryTransforms,
+        ...resolvedInterpretationTransforms,
+    };
+}
+function resolveDataSourceQueryTransforms(transforms, context) {
+    return typeof transforms === 'function'
+        ? transforms(context)
+        : transforms;
+}
+function mergeDataSourceQueryLoweringTransforms(targetTransforms, localTransforms) {
+    if (!targetTransforms) {
+        return localTransforms;
+    }
+    if (!localTransforms) {
+        return targetTransforms;
+    }
+    return {
+        ...targetTransforms,
+        ...localTransforms,
+    };
+}
+function resolveDataSourceQueryInterpretationValue(interpretation, context) {
+    if (!interpretation?.normalizeValue && !interpretation?.readValue) {
+        return undefined;
+    }
+    const value = interpretation.readValue
+        ? interpretation.readValue(context)
+        : readPresentationQueryFormAppliedValue(context.context, context.dataSource.Id);
+    return interpretation.normalizeValue
+        ? interpretation.normalizeValue(value, context)
+        : value;
+}
+/**
+ * Reads target binding options from a backend presentation binding.
+ *
+ * Option names are matched case-insensitively and may use either camelCase or
+ * PascalCase.
+ */
+export function readPresentationDataSourceTargetBindingOptions(binding) {
+    return {
+        authorizationPolicyId: readPresentationBindingStringOption(binding?.Options, 'authorizationPolicyId'),
+        executionTargetId: readPresentationBindingStringOption(binding?.Options, 'executionTargetId'),
+    };
+}
+/**
+ * Reads runtime query defaults from the standard
+ * `cohesive.presentation.data-source.runtime` data-source annotation.
+ */
+export function readDataSourceBindingRuntimeOptions(dataSource) {
+    const annotation = dataSource?.Annotations.find((candidate) => candidate.Name === 'cohesive.presentation.data-source.runtime' ||
+        candidate.Name.toLocaleLowerCase() === 'cohesive.presentation.data-source.runtime');
+    if (!annotation || !annotation.Value || typeof annotation.Value !== 'object') {
+        return {};
+    }
+    const options = annotation.Value;
+    const refetchInterval = readNumberOption(options, 'refetchIntervalMs') ??
+        readSecondsOptionAsMilliseconds(options, 'refetchIntervalSeconds');
+    const staleTime = readNumberOption(options, 'staleTimeMs') ??
+        readSecondsOptionAsMilliseconds(options, 'staleTimeSeconds');
+    return {
+        emptyMessage: readStringOption(options, 'emptyMessage'),
+        fallbackData: readObjectOption(options, 'fallbackData'),
+        pendingLabel: readStringOption(options, 'pendingLabel'),
+        refetchInterval,
+        retry: readRetryOption(options, 'retry'),
+        staleTime,
+    };
+}
+/**
+ * Resolves the endpoint executor selected by a binding's `executionTargetId`,
+ * falling back to the default API endpoint executor on the target
+ * interpretation.
+ */
+export function resolvePresentationDataSourceTargetEndpointExecutor(targetInterpretation, binding) {
+    const executionTargetId = readPresentationDataSourceTargetBindingOptions(binding).executionTargetId;
+    if (executionTargetId) {
+        return targetInterpretation?.apiEndpoint?.executeEndpointByTargetId?.[executionTargetId];
+    }
+    return targetInterpretation?.apiEndpoint?.executeEndpoint;
+}
+async function materializeDataSourceAggregateItems({ aggregation, sourceDataSource, sourceEndpointId, targetInterpretation, transforms, value, }) {
+    const materializeAllPages = matchesDataSourceAggregateMaterializationKind(aggregation.Materialization.Kind, dataSourceAggregateMaterializationKinds.allPages, 'allPages');
+    const pageSize = aggregation.Materialization.PageSize ??
+        sourceDataSource.Query?.Pagination?.DefaultPageSize ??
+        100;
+    const endpointBinding = findDataSourceQueryEndpointBinding(sourceDataSource, sourceEndpointId);
+    const items = [];
+    const seenCursors = new Set();
+    let cursor = null;
+    do {
+        const paginationRequest = materializeAllPages
+            ? createDataSourcePaginationRequest(sourceDataSource, {
+                cursor,
+                limit: pageSize,
+            })
+            : null;
+        const query = createDataSourceEndpointQueryRequest({
+            dataSource: sourceDataSource,
+            endpointId: sourceEndpointId,
+            paginationRequest,
+            transforms,
+            value,
+        });
+        const response = await executePresentationDataSourceTargetEndpoint(targetInterpretation, sourceEndpointId, { query }, { binding: sourceDataSource.Binding ?? null });
+        const pageItems = readAggregateResponseItems(response, endpointBinding?.ItemsPath);
+        items.push(...pageItems);
+        const nextCursor = readStringObjectPath(response, sourceDataSource.Query?.Pagination?.Response.CursorField);
+        cursor = materializeAllPages && nextCursor && !seenCursors.has(nextCursor)
+            ? nextCursor
+            : null;
+        if (cursor) {
+            seenCursors.add(cursor);
+        }
+    } while (cursor);
+    return items;
+}
+function evaluateDataSourceAggregateQuery(aggregation, items) {
+    const result = {};
+    for (const measure of aggregation.Measures) {
+        const predicate = measure.Predicate;
+        const matchingItems = predicate
+            ? items.filter((item) => evaluateDataSourceAggregatePredicate(predicate, item))
+            : items;
+        writeObjectPath(result, measure.TargetPath, evaluateDataSourceAggregateMeasure(measure.Operator, measure.SourceField, matchingItems));
+    }
+    return result;
+}
+function evaluateDataSourceAggregateMeasure(operator, sourceField, items) {
+    if (matchesAggregateOperator(operator, aggregateOperators.count, 'count')) {
+        return items.length;
+    }
+    const values = sourceField
+        ? items.map((item) => readObjectPath(item, fieldPathToString(sourceField)))
+        : items;
+    if (matchesAggregateOperator(operator, aggregateOperators.sum, 'sum')) {
+        return values.reduce((sum, value) => sum + (typeof value === 'number' ? value : 0), 0);
+    }
+    if (matchesAggregateOperator(operator, aggregateOperators.min, 'min')) {
+        return values
+            .filter((value) => typeof value === 'number')
+            .reduce((min, value) => min === null ? value : Math.min(min, value), null);
+    }
+    if (matchesAggregateOperator(operator, aggregateOperators.max, 'max')) {
+        return values
+            .filter((value) => typeof value === 'number')
+            .reduce((max, value) => max === null ? value : Math.max(max, value), null);
+    }
+    if (matchesAggregateOperator(operator, aggregateOperators.any, 'any')) {
+        return values.some(Boolean);
+    }
+    if (matchesAggregateOperator(operator, aggregateOperators.all, 'all')) {
+        return values.every(Boolean);
+    }
+    return null;
+}
+function evaluateDataSourceAggregatePredicate(predicate, item) {
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.and, 'and')) {
+        return (predicate.Terms ?? []).every((term) => evaluateDataSourceAggregatePredicate(term, item));
+    }
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.or, 'or')) {
+        return (predicate.Terms ?? []).some((term) => evaluateDataSourceAggregatePredicate(term, item));
+    }
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.not, 'not')) {
+        const [term] = predicate.Terms ?? [];
+        return term ? !evaluateDataSourceAggregatePredicate(term, item) : true;
+    }
+    const value = readObjectPath(item, fieldPathToString(predicate.Field));
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.fieldEquals, 'fieldEquals')) {
+        return String(value) === predicate.Value;
+    }
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.fieldNotEquals, 'fieldNotEquals')) {
+        return String(value) !== predicate.Value;
+    }
+    if (matchesDataSourceAggregatePredicateKind(predicate.Kind, dataSourceAggregatePredicateKinds.fieldHasValue, 'fieldHasValue')) {
+        return hasAggregateValue(value);
+    }
+    return false;
+}
+function readPresentationDataSourceEndpointId(binding) {
+    return isApiEndpointBinding(binding) && binding?.EndpointId
+        ? binding.EndpointId
+        : null;
+}
+function applyDataSourceDefaults(binding, dataSource) {
+    if (!isTanStackQueryBinding(binding)) {
+        return binding;
+    }
+    return {
+        ...binding,
+        staleTime: binding.staleTime ?? readDataSourceStaleTime(dataSource),
+    };
+}
+function createUnboundDataSourceBinding(dataSource, authorization) {
+    return presentationDataSourceBindings.localValue({
+        authorization: authorization ??
+            presentationDataSourceAuthorization.required({
+                blockedLabel: `No frontend binding is registered for '${dataSource.Name}'.`,
+                isAuthorized: false,
+            }),
+        data: undefined,
+        dataSourceId: dataSource.Id,
+    });
+}
+function readDataSourceStaleTime(dataSource) {
+    const cache = dataSource.Cache;
+    if (!cache) {
+        return undefined;
+    }
+    if (cache.Kind === cachePolicyKinds.reactQuery ||
+        String(cache.Kind).toLocaleLowerCase() === 'reactquery') {
+        return cache.StaleAfterSeconds === null ||
+            cache.StaleAfterSeconds === undefined
+            ? undefined
+            : cache.StaleAfterSeconds * 1000;
+    }
+    return undefined;
+}
+function isApiEndpointBinding(binding) {
+    return (binding?.Kind === presentationBindingKinds.apiEndpoint ||
+        String(binding?.Kind).toLocaleLowerCase() === 'apiendpoint');
+}
+function isLocalStateBinding(binding) {
+    return (binding?.Kind === presentationBindingKinds.localState ||
+        String(binding?.Kind).toLocaleLowerCase() === 'localstate');
+}
+function readPresentationBindingStringOption(options, key) {
+    if (!options || typeof options !== 'object') {
+        return null;
+    }
+    const record = options;
+    const value = record[key] ??
+        record[capitalizeFirstCharacter(key)] ??
+        readCaseInsensitiveProperty(record, key);
+    return typeof value === 'string' && value.trim().length > 0
+        ? value
+        : null;
+}
+function readAggregateResponseItems(response, itemsPath) {
+    const value = itemsPath ? readObjectPath(response, itemsPath) : response;
+    if (Array.isArray(value)) {
+        return value;
+    }
+    const items = readObjectPath(response, 'Items');
+    return Array.isArray(items) ? items : [];
+}
+function readStringObjectPath(value, path) {
+    const raw = readObjectPath(value, path);
+    return typeof raw === 'string' && raw.trim().length > 0 ? raw.trim() : null;
+}
+function fieldPathToString(field) {
+    return field?.Segments.map((segment) => segment.Segment).filter(Boolean).join('.') ?? '';
+}
+function hasAggregateValue(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+function matchesAggregateOperator(value, numericValue, camelLabel) {
+    return matchesGeneratedEnum(value, numericValue, camelLabel);
+}
+function matchesDataSourceAggregateMaterializationKind(value, numericValue, camelLabel) {
+    return matchesGeneratedEnum(value, numericValue, camelLabel);
+}
+function matchesDataSourceAggregatePredicateKind(value, numericValue, camelLabel) {
+    return matchesGeneratedEnum(value, numericValue, camelLabel);
+}
+function matchesGeneratedEnum(value, numericValue, camelLabel) {
+    return (value === numericValue ||
+        String(value) === String(numericValue) ||
+        String(value).toLocaleLowerCase() === camelLabel.toLocaleLowerCase());
+}
+function readStringOption(options, key) {
+    const value = readObjectOption(options, key);
+    return typeof value === 'string' && value.trim().length > 0
+        ? value
+        : undefined;
+}
+function readObjectOption(options, key) {
+    return Object.prototype.hasOwnProperty.call(options, key)
+        ? options[key]
+        : readCaseInsensitiveProperty(options, key);
+}
+function readNumberOption(options, key) {
+    const value = readObjectOption(options, key);
+    return typeof value === 'number' && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function readSecondsOptionAsMilliseconds(options, key) {
+    const seconds = readNumberOption(options, key);
+    return seconds === undefined ? undefined : seconds * 1000;
+}
+function readRetryOption(options, key) {
+    const value = readObjectOption(options, key);
+    return typeof value === 'boolean' || typeof value === 'number'
+        ? value
+        : undefined;
+}
+function readCaseInsensitiveProperty(record, key) {
+    const normalizedKey = key.toLocaleLowerCase();
+    const match = Object.keys(record).find((candidate) => candidate.toLocaleLowerCase() === normalizedKey);
+    return match ? record[match] : undefined;
+}
+function capitalizeFirstCharacter(value) {
+    return value.length > 0
+        ? `${value.slice(0, 1).toLocaleUpperCase()}${value.slice(1)}`
+        : value;
+}
+function projectDataSourceRouteParameters(parameters, routeParameters) {
+    return Object.fromEntries(parameters.map((parameter) => [
+        parameter.Name,
+        readRouteParameterValue(routeParameters, parameter.Name),
+    ]));
+}
+function hasRequiredDataSourceRouteParameters(parameters, routeParameters) {
+    return parameters.every((parameter) => !parameter.IsRequired ||
+        typeof routeParameters[parameter.Name] === 'string' &&
+            routeParameters[parameter.Name].length > 0);
+}
+function readRouteParameterValue(routeParameters, parameterName) {
+    if (!routeParameters) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(routeParameters, parameterName)) {
+        return routeParameters[parameterName];
+    }
+    const match = Object.keys(routeParameters).find((candidate) => candidate.toLocaleLowerCase() === parameterName.toLocaleLowerCase());
+    return match ? routeParameters[match] : undefined;
+}
+function hasOwn(values, key) {
+    return Object.prototype.hasOwnProperty.call(values, key);
+}
+function resolveApiEndpointDataSourcePendingLabel(label, context) {
+    if (typeof label === 'function') {
+        return label(context);
+    }
+    return label ?? `Loading ${context.dataSource.Name.toLocaleLowerCase()}...`;
+}
+function createDefaultApiEndpointDataSourceQueryKey({ context, dataSource, endpointId, routeParameters, }) {
+    return [
+        'presentation-data-source',
+        dataSource.Id,
+        endpointId,
+        routeParameters,
+        ...(context.queryKeyParts ?? []),
+    ];
+}
+function mapFactories(factories, mapFactory) {
+    if (!factories) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(factories).map(([key, factory]) => [
+        key,
+        mapFactory(factory),
+    ]));
+}
+//# sourceMappingURL=data-source-projection.js.map