@takeshape/schema 11.144.1 → 11.154.1

package/dist/schemas/project-schema.json

@@ -1,214 +0,0 @@
-{
-  "$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/v4.0.0#"
-    }
-  ]
-}

package/dist/service-dependencies.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

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

package/dist/services/util.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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[];

package/dist/shape-paths.js

@@ -1,28 +0,0 @@
-import { dereferenceSchema } from "./refs.js";
-import { isArraySchema, isObjectSchema } from "./types/utils.js";
-export function getShapePaths(projectSchema, shape, args = {}) {
-    const { includeRoot = false, prefix = '', depthLimit = 2 } = args;
-    const options = [];
-    const visit = (propertySchema, path, depth) => {
-        if (depth > depthLimit) {
-            return;
-        }
-        if (depth !== 0 || includeRoot) {
-            options.push(path.join('.'));
-        }
-        const schema = dereferenceSchema(projectSchema, propertySchema);
-        if (isArraySchema(schema)) {
-            if (isObjectSchema(schema.items)) {
-                visit(schema.items, path, depth + 1);
-            }
-        }
-        else if (isObjectSchema(schema)) {
-            for (const [name, propSchema] of Object.entries(schema.properties)) {
-                const newPath = [...path, propSchema.type === 'array' ? `${name}[0]` : name];
-                visit(propSchema, newPath, depth + 1);
-            }
-        }
-    };
-    visit(shape.schema, prefix ? [prefix] : [], 0);
-    return options;
-}