@takeshape/schema 12.1.1 → 12.1.5

package/dist/schemas/project-schema.json

@@ -0,0 +1,232 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schema.takeshape.io/project-schema#",
+  "title": "Any Project Schema",
+  "oneOf": [
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v1.0.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.0.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.1.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.2.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.3.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.4.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.5.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.5.1#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.6.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.7.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.8.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.9.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.10.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.11.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.12.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.12.1#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.12.2#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.12.3#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.13.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.14.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.15.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.16.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.17.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.17.1#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.18.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.18.1#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.18.2#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.19.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.20.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.21.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.22.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.23.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.24.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.25.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.26.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.27.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.28.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.29.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.30.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.31.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.32.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.33.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.34.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.35.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.36.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.37.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.38.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.39.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.40.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.41.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.42.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.43.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.44.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.45.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.46.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.47.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.48.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.49.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.50.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.51.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.52.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.53.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.54.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.55.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.56.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.57.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.58.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.59.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.60.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.61.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.62.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.63.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.64.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v3.65.0#"
+    },
+    {
+      "$ref": "https://schema.takeshape.io/project-schema/v4.0.0#"
+    }
+  ]
+}

package/dist/service-dependencies.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectSchemaJSON, PropertySchema } from './project-schema/index.ts';
+import { type ServicesContext } from './refs.ts';
+import { type ServiceLayers } from './types/index.ts';
+/**
+ * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
+ */
+export declare function collectReferencedShapeNames(context: ServicesContext, shapeNames: Set<string>): (schema: PropertySchema) => void;
+/**
+ * Returns a schema with all of its dependencies resolved.
+ * SHOULD only return the minimum set of remote dependencies required to enable
+ * the local shape definitions.
+ */
+export declare function resolveSchemaShapeDependencies(projectSchema: ProjectSchemaJSON, serviceLayers: ServiceLayers): ProjectSchemaJSON;

package/dist/service-dependencies.js

@@ -0,0 +1,165 @@
+import { addAll, deepClone, mapSet } from '@takeshape/util';
+import get from 'lodash/get.js';
+import isObject from 'lodash/isObject.js';
+import pick from 'lodash/pick.js';
+import set from 'lodash/set.js';
+import { getImplementationShapeNameMap, isInterfaceShape, pruneUnusedInterfaces } from "./interfaces.js";
+import { createGetNamespace, dereferenceObjectSchema, getAllPropertyRefs, getRef, getRefShapeName, isValidRefItem, propertyRefItemToPath, refExpressionToNamespacedName, refItemToNamespacedShapeName } from "./refs.js";
+import { getAllNamespaceShapes, getAllRefsInQuery, getArgsReference, visitSchemaProperties } from "./schema-util.js";
+import { isExtendsSchema, isObjectSchema, isProjectSchemaWithServices } from "./types/index.js";
+function getGraphQLServiceShapeMap(layers) {
+    return Object.assign({}, ...Object.values(layers).map((layer) => layer.schema?.shapes ?? {}));
+}
+function schemaExtendsShape(context, shapeName, schema) {
+    return (isExtendsSchema(schema) &&
+        schema.extends.some((item) => getRefShapeName(context, item) === shapeName));
+}
+function getMissingPropertyRefs(projectSchema, getNamespace) {
+    const propertyRefs = getAllPropertyRefs(projectSchema);
+    return propertyRefs.filter((ref) => {
+        const path = propertyRefItemToPath(getNamespace, ref);
+        return !get(projectSchema, path);
+    });
+}
+function refToQuery(serviceSchemas, ref) {
+    const serviceSchema = serviceSchemas[ref.layerId]?.schema;
+    if (serviceSchema) {
+        if (ref.shapeName === 'Query' || ref.shapeName === 'Mutation') {
+            const operation = ref.shapeName === 'Query' ? 'queries' : 'mutations';
+            return serviceSchema[operation][ref.propertyName];
+        }
+    }
+}
+function getShapeRefs(services, serviceSchemas, propertyRefs) {
+    const results = [];
+    for (const ref of propertyRefs) {
+        const query = refToQuery(serviceSchemas, ref);
+        const layerSchema = serviceSchemas[ref.layerId]?.schema;
+        if (query && layerSchema) {
+            const layerWithService = {
+                ...layerSchema,
+                services: pick(services, [ref.layerId]) // include own service so refs have isValidService: true
+            };
+            results.push(...getAllRefsInQuery(layerWithService, [], query));
+        }
+    }
+    return results;
+}
+function interfacesToShapeNames(projectSchema, shapeRefArray) {
+    return shapeRefArray.map((shapeRef) => refExpressionToNamespacedName(projectSchema, shapeRef));
+}
+/**
+ * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
+ */
+export function collectReferencedShapeNames(context, shapeNames) {
+    const addRef = (refItem) => {
+        shapeNames.add(refItemToNamespacedShapeName(context, refItem));
+    };
+    const collect = (schema) => {
+        const args = schema['@args'];
+        if (args && isObject(args) && isObjectSchema(args)) {
+            Object.values(args.properties).forEach(collect);
+        }
+        const argsRefItem = getArgsReference(context, schema);
+        if (argsRefItem) {
+            addRef(argsRefItem);
+        }
+        const refItem = getRef(context, schema);
+        if (refItem) {
+            addRef(refItem);
+        }
+    };
+    return collect;
+}
+/**
+ * Returns a schema with all of its dependencies resolved.
+ * SHOULD only return the minimum set of remote dependencies required to enable
+ * the local shape definitions.
+ */
+export function resolveSchemaShapeDependencies(projectSchema, serviceLayers) {
+    const newSchema = deepClone(projectSchema);
+    if (isProjectSchemaWithServices(projectSchema)) {
+        const newShapeMap = {};
+        const requiredShapeNames = new Set(getAllNamespaceShapes(projectSchema));
+        const getNamespace = createGetNamespace(projectSchema);
+        const missingPropertyRefs = getMissingPropertyRefs(projectSchema, getNamespace);
+        if (requiredShapeNames.size || missingPropertyRefs.length) {
+            const remoteShapeMap = getGraphQLServiceShapeMap(serviceLayers);
+            // Add shape references from queries
+            addAll(requiredShapeNames, getShapeRefs(projectSchema.services, serviceLayers, missingPropertyRefs)
+                .filter(isValidRefItem(projectSchema))
+                .map((item) => refItemToNamespacedShapeName(projectSchema, item)));
+            // Add referenced queries and mutations
+            for (const ref of missingPropertyRefs) {
+                const query = refToQuery(serviceLayers, ref);
+                if (query) {
+                    set(newSchema, propertyRefItemToPath(getNamespace, ref), query);
+                }
+            }
+            // Gather all the remote dependencies that our local schema requires.
+            // If the required shape exists in the remote shape map, visit the
+            // properties on the remote shape's schema and ensure they are required
+            // as well.
+            const collectDependencies = (shapeNames) => {
+                for (const name of shapeNames) {
+                    const localShape = newSchema.shapes[name];
+                    const remoteShape = remoteShapeMap[name];
+                    // Don't check for dependencies if the shape is already in our schema unless it extends a remote shape
+                    // getNamespacedShapeNameList already collected those dependencies
+                    if ((!localShape || (localShape && schemaExtendsShape(projectSchema, name, localShape.schema))) &&
+                        remoteShape) {
+                        visitSchemaProperties(remoteShape.schema, [remoteShape.name, 'schema'], collectReferencedShapeNames({ services: newSchema.services }, shapeNames));
+                    }
+                }
+            };
+            collectDependencies(requiredShapeNames);
+            // Collect interfaces that requiredShapeNames implement
+            const interfaceNames = new Set();
+            const requiredShapes = mapSet(requiredShapeNames, (shapeName) => newSchema.shapes[shapeName] ?? remoteShapeMap[shapeName]);
+            for (const shape of requiredShapes) {
+                if (shape?.interfaces) {
+                    addAll(interfaceNames, interfacesToShapeNames(projectSchema, shape.interfaces));
+                }
+            }
+            // Collect implementations for interfaces in requiredShapeNames
+            const implementationNames = new Set();
+            const implementations = getImplementationShapeNameMap({
+                ...newSchema.shapes,
+                ...remoteShapeMap
+            });
+            for (const shape of requiredShapes) {
+                if (isInterfaceShape(shape) && implementations[shape.name]) {
+                    addAll(implementationNames, implementations[shape.name]);
+                }
+            }
+            // Collect the dependencies for the interfaces and implementations
+            collectDependencies(interfaceNames);
+            collectDependencies(implementationNames);
+            addAll(requiredShapeNames, interfaceNames);
+            addAll(requiredShapeNames, implementationNames);
+            // Populate a ShapeMap with the remote shapes we've gathered
+            // A combined context which prefers remote shapes for use when merging/inlining
+            const mergingContext = {
+                services: newSchema.services,
+                shapes: { ...newSchema.shapes, ...remoteShapeMap }
+            };
+            for (const name of requiredShapeNames) {
+                const localShape = newSchema.shapes[name];
+                const remoteShape = remoteShapeMap[name];
+                if (localShape && remoteShape && schemaExtendsShape(mergingContext, name, localShape.schema)) {
+                    // Merge and inline combined shape when a local shape extends a remote shape
+                    newShapeMap[name] = {
+                        ...localShape,
+                        schema: dereferenceObjectSchema(mergingContext, newSchema.shapes[name].schema)
+                    };
+                }
+                else if (localShape ?? remoteShape) {
+                    newShapeMap[name] = localShape ?? remoteShape;
+                }
+            }
+        }
+        // Assign remote shapes to the new schema, mutating the new schema
+        Object.assign(newSchema.shapes, pruneUnusedInterfaces(newSchema, newShapeMap));
+    }
+    return newSchema;
+}

package/dist/services/services.d.ts

@@ -0,0 +1,31 @@
+import type { Overwrite } from '@takeshape/util';
+import { SERVICE_OBJECT_PATTERN_NAME } from '../constants.ts';
+import type { ProjectSchemaJSON, ServiceConfig, ServiceConfigJSON, ServiceMapJSON, ShapeJSON } from '../project-schema/index.ts';
+import type { PatternGenerator, ServiceConfigUpdate, ServiceInfo, ServiceMap } from '../types/types.ts';
+import type { DecryptFn, EncryptFn } from './types.ts';
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+export declare function decryptServiceConfig(decryptFn: DecryptFn, storedServiceConfig: ServiceConfigJSON): ServiceConfig;
+/**
+ * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+export declare function decryptServiceMap(decryptFn: DecryptFn, ServiceMapJSON: ServiceMapJSON): Promise<ServiceMap>;
+/**
+ * Validates a `ServiceConfig` validator based on the JSON-schema.
+ */
+export declare function validateServiceConfig(maybeServiceConfig: unknown): ServiceConfigJSON;
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+export declare function prepareServiceUpdate(encryptFn: EncryptFn, decryptFn: DecryptFn, projectSchema: ProjectSchemaJSON, serviceConfigUpdate: ServiceConfigUpdate, serviceKey: string): ServiceConfigJSON;
+export type ServiceInfoWithServiceObject = Overwrite<ServiceInfo, {
+    generators: {
+        [SERVICE_OBJECT_PATTERN_NAME]: PatternGenerator;
+    };
+}>;
+export declare function getServiceObjectFields(projectSchema: ProjectSchemaJSON, shape: ShapeJSON, provider: string): ServiceInfoWithServiceObject[];
+export declare function getServiceInfo(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): Record<string, ServiceInfo[]>;

package/dist/services/services.js

@@ -0,0 +1,145 @@
+import { SchemaValidationError } from '@takeshape/errors';
+import { createAjv } from '@takeshape/json-schema';
+import { mergeWithArrayMerge } from '@takeshape/util';
+import isEqual from 'lodash/isEqual.js';
+import isNull from 'lodash/isNull.js';
+import { SERVICE_OBJECT_PATTERN_NAME } from "../constants.js";
+import { createSchemaPropertyList, getGeneratorVersion, getServiceIdFieldName, getShapeDependencies, pathBetween } from "../schema-util.js";
+import { latestSchemaJson } from "../schemas/index.js";
+import { isEncryptedServiceConfig, isServiceAuthentication, isServiceResolver } from "../types/utils.js";
+import { formatError } from "../validate/errors.js";
+import { getStoredServiceConfig } from "./util.js";
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+export function decryptServiceConfig(decryptFn, storedServiceConfig) {
+    let authentication;
+    if (isEncryptedServiceConfig(storedServiceConfig)) {
+        const decrypted = decryptFn(storedServiceConfig.authentication);
+        if (isServiceAuthentication(decrypted)) {
+            authentication = decrypted;
+        }
+    }
+    return {
+        ...storedServiceConfig,
+        authentication
+    };
+}
+/**
+ * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+export async function decryptServiceMap(decryptFn, ServiceMapJSON) {
+    return Object.entries(ServiceMapJSON).reduce((result, [serviceKey, serviceConfig]) => {
+        return result.set(serviceKey, decryptServiceConfig(decryptFn, serviceConfig));
+    }, new Map());
+}
+function createServiceConfigValidator() {
+    const validator = createAjv();
+    const { serviceConfig, ...definitions } = latestSchemaJson.definitions;
+    return validator.compile({
+        $id: 'ServiceConfig',
+        definitions,
+        ...serviceConfig
+    });
+}
+const serviceConfigValidator = createServiceConfigValidator();
+/**
+ * Validates a `ServiceConfig` validator based on the JSON-schema.
+ */
+export function validateServiceConfig(maybeServiceConfig) {
+    if (serviceConfigValidator(maybeServiceConfig)) {
+        return maybeServiceConfig;
+    }
+    throw new SchemaValidationError('ServiceConfig was invalid', serviceConfigValidator.errors?.map(formatError));
+}
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+export function prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceConfigUpdate, serviceKey) {
+    const storedServiceConfig = getStoredServiceConfig(projectSchema, serviceKey);
+    let newServiceConfig = serviceConfigUpdate;
+    if (storedServiceConfig) {
+        const existingServiceConfig = decryptServiceConfig(decryptFn, storedServiceConfig);
+        newServiceConfig = mergeWithArrayMerge(existingServiceConfig, serviceConfigUpdate);
+    }
+    const { authentication, authenticationType } = newServiceConfig;
+    if (authenticationType === 'none' || isNull(authentication)) {
+        // biome-ignore lint/performance/noDelete: Property presence may matter here
+        delete newServiceConfig.authentication;
+    }
+    else if (authentication !== undefined) {
+        // Add the discriminator to the authentication object, set authenticationType
+        // to ensure the update is correct for the auth type.
+        newServiceConfig.authentication = {
+            ...authentication,
+            type: authenticationType
+        };
+    }
+    validateServiceConfig(newServiceConfig);
+    let serviceConfig;
+    if (newServiceConfig.authentication) {
+        serviceConfig = {
+            ...newServiceConfig,
+            authentication: encryptFn(newServiceConfig.authentication)
+        };
+    }
+    else {
+        serviceConfig = newServiceConfig;
+    }
+    return serviceConfig;
+}
+export function getServiceObjectFields(projectSchema, shape, provider) {
+    return (getServiceInfo(projectSchema, shape)[provider] ?? []).filter((serviceInfo) => serviceInfo.generators[SERVICE_OBJECT_PATTERN_NAME]);
+}
+// Returns info for all services found in shape, keyed by provider
+export function getServiceInfo(projectSchema, shape) {
+    const result = {};
+    // Get inline dependencies by not following refs with @resolver
+    const inlineDepShapes = getShapeDependencies(projectSchema, shape, (prop) => !prop['@resolver']).map((name) => projectSchema.shapes[name]);
+    const shapesToCheck = [shape, ...inlineDepShapes];
+    for (const thisShape of shapesToCheck) {
+        // biome-ignore lint/complexity/noForEach: Types for createSchemaPropertyList do not include the iterator
+        createSchemaPropertyList(projectSchema, thisShape).forEach(([key, value]) => {
+            const resolver = value['@resolver'];
+            if (!isServiceResolver(resolver)) {
+                return;
+            }
+            const serviceConfig = getStoredServiceConfig(projectSchema, resolver.service);
+            if (!serviceConfig) {
+                return;
+            }
+            const { provider } = serviceConfig;
+            const generators = {};
+            const tag = value['@tag'];
+            if (tag?.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
+                const idFieldName = getServiceIdFieldName(key);
+                const version = tag.substr(Number(tag.lastIndexOf(':')) + 1);
+                generators[SERVICE_OBJECT_PATTERN_NAME] = {
+                    version,
+                    currentVersion: getGeneratorVersion(SERVICE_OBJECT_PATTERN_NAME),
+                    idFieldName,
+                    serviceObjectType: resolver.fieldName
+                };
+            }
+            const serviceInfo = {
+                service: resolver.service,
+                fieldName: key,
+                path: pathBetween(shape, thisShape, projectSchema),
+                generators
+            };
+            if (Array.isArray(result[provider])) {
+                // Dedupe service info
+                if (!result[provider].find((existingServiceInfo) => isEqual(existingServiceInfo, serviceInfo))) {
+                    result[provider].push(serviceInfo);
+                }
+            }
+            else {
+                result[provider] = [serviceInfo];
+            }
+        });
+    }
+    return result;
+}

package/dist/services/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Decrypt an encrypted authentication JSON string
+ * Throws an error if decryption fails
+ */
+export type DecryptFn = (authentication: string) => object;
+/**
+ * Decrypt an encrypted authentication JSON string
+ * Returns undefined if decryption fails
+ */
+export type SafeDecryptFn = (authentication: string) => object | undefined;
+export type EncryptFn = (authentication: object) => string;

package/dist/services/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/util.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectSchemaJSON, Resolver, ServiceConfig, ServiceConfigJSON } from '../project-schema/index.ts';
+import type { ServiceKey } from '../types/types.ts';
+/**
+ * Get a service config from a project schema.
+ */
+export declare function getStoredServiceConfig(projectSchema: ProjectSchemaJSON, serviceKey: ServiceKey): ServiceConfigJSON | undefined;
+/**
+ * Get a `Map` keyed with all the service namespaces.
+ *
+ * @param context A partial project schema
+ *
+ * @returns A `Map` with namespaces as keys, and service keys as values.
+ */
+export declare function getServiceNamespaces(context: Pick<ProjectSchemaJSON, 'services'>): Map<string, string>;
+export declare function isMissingAuth(service: Pick<ServiceConfig | ServiceConfigJSON, 'authenticationType' | 'authentication'>): boolean;
+export declare function getResolverServices(resolver: Resolver): string[];

package/dist/services/util.js

@@ -0,0 +1,36 @@
+import { isDefined } from '@takeshape/util';
+import isEmpty from 'lodash/isEmpty.js';
+import uniq from 'lodash/uniq.js';
+/**
+ * Get a service config from a project schema.
+ */
+export function getStoredServiceConfig(projectSchema, serviceKey) {
+    return projectSchema.services?.[serviceKey];
+}
+/**
+ * Get a `Map` keyed with all the service namespaces.
+ *
+ * @param context A partial project schema
+ *
+ * @returns A `Map` with namespaces as keys, and service keys as values.
+ */
+export function getServiceNamespaces(context) {
+    const namespaces = new Map();
+    const { services } = context;
+    if (services) {
+        for (const serviceKey of Object.keys(services)) {
+            const namespace = services[serviceKey]?.namespace;
+            if (namespace) {
+                namespaces.set(namespace, serviceKey);
+            }
+        }
+    }
+    return namespaces;
+}
+export function isMissingAuth(service) {
+    return service.authenticationType !== 'none' && isEmpty(service.authentication);
+}
+export function getResolverServices(resolver) {
+    const resolverArray = 'compose' in resolver ? resolver.compose : [resolver];
+    return uniq(resolverArray.map((resolver) => ('service' in resolver ? resolver.service : undefined)).filter(isDefined));
+}

package/dist/shape-paths.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectSchemaJSON, ShapeJSON } from './project-schema/latest.ts';
+export interface GetShapePathsArgs {
+    includeRoot?: boolean;
+    prefix?: string;
+    depthLimit?: number;
+}
+export declare function getShapePaths(projectSchema: ProjectSchemaJSON, shape: ShapeJSON, args?: GetShapePathsArgs): string[];