@takeshape/schema 11.52.0 → 11.55.0

package/dist/cjs/src/service-dependencies.js

@@ -1,172 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectReferencedShapeNames = collectReferencedShapeNames;
-exports.resolveSchemaShapeDependencies = resolveSchemaShapeDependencies;
-const util_1 = require("@takeshape/util");
-const get_js_1 = __importDefault(require("lodash/get.js"));
-const isObject_js_1 = __importDefault(require("lodash/isObject.js"));
-const pick_js_1 = __importDefault(require("lodash/pick.js"));
-const set_js_1 = __importDefault(require("lodash/set.js"));
-const interfaces_1 = require("./interfaces");
-const refs_1 = require("./refs");
-const schema_util_1 = require("./schema-util");
-const types_1 = require("./types");
-function getGraphQLServiceShapeMap(layers) {
-    return Object.assign({}, ...Object.values(layers).map((layer) => layer.schema?.shapes ?? {}));
-}
-function schemaExtendsShape(context, shapeName, schema) {
-    return ((0, types_1.isExtendsSchema)(schema) &&
-        schema.extends.some((item) => (0, refs_1.getRefShapeName)(context, item) === shapeName));
-}
-function getMissingPropertyRefs(projectSchema, getNamespace) {
-    const propertyRefs = (0, refs_1.getAllPropertyRefs)(projectSchema);
-    return propertyRefs.filter((ref) => {
-        const path = (0, refs_1.propertyRefItemToPath)(getNamespace, ref);
-        return !(0, get_js_1.default)(projectSchema, path);
-    });
-}
-function refToQuery(serviceSchemas, ref) {
-    const serviceSchema = serviceSchemas[ref.serviceId]?.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.serviceId]?.schema;
-        if (query && layerSchema) {
-            const layerWithService = {
-                ...layerSchema,
-                services: (0, pick_js_1.default)(services, [ref.serviceId]) // include own service so refs have isValidService: true
-            };
-            results.push(...(0, schema_util_1.getAllRefsInQuery)(layerWithService, [], query));
-        }
-    }
-    return results;
-}
-function interfacesToShapeNames(projectSchema, shapeRefArray) {
-    return shapeRefArray.map((shapeRef) => (0, refs_1.refItemToNamespacedShapeName)((0, refs_1.refExpressionToRefItem)(projectSchema, shapeRef)));
-}
-/**
- * Add all referenced shape names to the refSet meant to be used as a callback to visitSchemaProperties
- */
-function collectReferencedShapeNames(context, shapeNames) {
-    const addRef = (refItem) => {
-        shapeNames.add((0, refs_1.refItemToNamespacedShapeName)(refItem));
-    };
-    const collect = (schema) => {
-        const args = schema['@args'];
-        if (args && (0, isObject_js_1.default)(args) && (0, types_1.isObjectSchema)(args)) {
-            Object.values(args.properties).forEach(collect);
-        }
-        const argsRefItem = (0, schema_util_1.getArgsReference)(context, schema);
-        if (argsRefItem) {
-            addRef(argsRefItem);
-        }
-        const refItem = (0, refs_1.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.
- */
-function resolveSchemaShapeDependencies(projectSchema, serviceLayers) {
-    const newSchema = (0, util_1.deepClone)(projectSchema);
-    if ((0, types_1.isProjectSchemaWithServices)(projectSchema)) {
-        const newShapeMap = {};
-        const requiredShapeNames = new Set((0, schema_util_1.getAllNamespaceShapes)(projectSchema));
-        const getNamespace = (0, refs_1.createGetNamespace)(projectSchema);
-        const missingPropertyRefs = getMissingPropertyRefs(projectSchema, getNamespace);
-        if (requiredShapeNames.size || missingPropertyRefs.length) {
-            const remoteShapeMap = getGraphQLServiceShapeMap(serviceLayers);
-            // Add shape references from queries
-            (0, util_1.addAll)(requiredShapeNames, getShapeRefs(projectSchema.services, serviceLayers, missingPropertyRefs)
-                .filter(schema_util_1.isValidRefItem)
-                .map(refs_1.refItemToNamespacedShapeName));
-            // Add referenced queries and mutations
-            for (const ref of missingPropertyRefs) {
-                const query = refToQuery(serviceLayers, ref);
-                if (query) {
-                    (0, set_js_1.default)(newSchema, (0, refs_1.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) {
-                        (0, schema_util_1.visitSchemaProperties)(remoteShape.schema, [remoteShape.name, 'schema'], collectReferencedShapeNames({ services: newSchema.services }, shapeNames));
-                    }
-                }
-            };
-            collectDependencies(requiredShapeNames);
-            // Collect interfaces that requiredShapeNames implement
-            const interfaceNames = new Set();
-            const requiredShapes = (0, util_1.mapSet)(requiredShapeNames, (shapeName) => newSchema.shapes[shapeName] ?? remoteShapeMap[shapeName]);
-            for (const shape of requiredShapes) {
-                if (shape?.interfaces) {
-                    (0, util_1.addAll)(interfaceNames, interfacesToShapeNames(projectSchema, shape.interfaces));
-                }
-            }
-            // Collect implementations for interfaces in requiredShapeNames
-            const implementationNames = new Set();
-            const implementations = (0, interfaces_1.getImplementationShapeNameMap)({
-                ...newSchema.shapes,
-                ...remoteShapeMap
-            });
-            for (const shape of requiredShapes) {
-                if ((0, interfaces_1.isInterfaceShape)(shape) && implementations[shape.name]) {
-                    (0, util_1.addAll)(implementationNames, implementations[shape.name]);
-                }
-            }
-            // Collect the dependencies for the interfaces and implementations
-            collectDependencies(interfaceNames);
-            collectDependencies(implementationNames);
-            (0, util_1.addAll)(requiredShapeNames, interfaceNames);
-            (0, util_1.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: (0, refs_1.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, (0, interfaces_1.pruneUnusedInterfaces)(newSchema, newShapeMap));
-    }
-    return newSchema;
-}

package/dist/cjs/src/services/services.js

@@ -1,156 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decryptServiceConfig = decryptServiceConfig;
-exports.decryptServiceMap = decryptServiceMap;
-exports.validateServiceConfig = validateServiceConfig;
-exports.prepareServiceUpdate = prepareServiceUpdate;
-exports.getServiceObjectFields = getServiceObjectFields;
-exports.getServiceInfo = getServiceInfo;
-const errors_1 = require("@takeshape/errors");
-const json_schema_1 = require("@takeshape/json-schema");
-const util_1 = require("@takeshape/util");
-const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
-const isNull_js_1 = __importDefault(require("lodash/isNull.js"));
-const constants_1 = require("../constants");
-const schema_util_1 = require("../schema-util");
-const schemas_1 = require("../schemas");
-const utils_1 = require("../types/utils");
-const validate_1 = require("../validate");
-const util_2 = require("./util");
-/**
- * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
- * authentication object decrypted.
- */
-function decryptServiceConfig(decryptFn, storedServiceConfig) {
-    let authentication;
-    if ((0, utils_1.isEncryptedServiceConfig)(storedServiceConfig)) {
-        const decrypted = decryptFn(storedServiceConfig.authentication);
-        if ((0, utils_1.isServiceAuthentication)(decrypted)) {
-            authentication = decrypted;
-        }
-    }
-    return {
-        ...storedServiceConfig,
-        authentication
-    };
-}
-/**
- * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
- * authentication objects decrypted.
- */
-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 = (0, json_schema_1.createAjv)();
-    const { serviceConfig, ...definitions } = schemas_1.latestSchemaJson.definitions;
-    return validator.compile({
-        $id: 'ServiceConfig',
-        definitions,
-        ...serviceConfig
-    });
-}
-const serviceConfigValidator = createServiceConfigValidator();
-/**
- * Validates a `ServiceConfig` validator based on the JSON-schema.
- */
-function validateServiceConfig(maybeServiceConfig) {
-    if (serviceConfigValidator(maybeServiceConfig)) {
-        return maybeServiceConfig;
-    }
-    throw new errors_1.SchemaValidationError('ServiceConfig was invalid', serviceConfigValidator.errors?.map(validate_1.formatError));
-}
-/**
- * Prepare a `ServiceConfig` object update, validating the overall structure
- * and encrypting the `ServiceAuthentication` object.
- */
-function prepareServiceUpdate(encryptFn, decryptFn, projectSchema, serviceConfigUpdate, serviceKey) {
-    const storedServiceConfig = (0, util_2.getStoredServiceConfig)(projectSchema, serviceKey);
-    let newServiceConfig = serviceConfigUpdate;
-    if (storedServiceConfig) {
-        const existingServiceConfig = decryptServiceConfig(decryptFn, storedServiceConfig);
-        newServiceConfig = (0, util_1.mergeWithArrayMerge)(existingServiceConfig, serviceConfigUpdate);
-    }
-    const { authentication, authenticationType } = newServiceConfig;
-    if (authenticationType === 'none' || (0, isNull_js_1.default)(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;
-}
-function getServiceObjectFields(projectSchema, shape, provider) {
-    return (getServiceInfo(projectSchema, shape)[provider] ?? []).filter((serviceInfo) => serviceInfo.generators[constants_1.SERVICE_OBJECT_PATTERN_NAME]);
-}
-// Returns info for all services found in shape, keyed by provider
-function getServiceInfo(projectSchema, shape) {
-    const result = {};
-    // Get inline dependencies by not following refs with @resolver
-    const inlineDepShapes = (0, schema_util_1.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
-        (0, schema_util_1.createSchemaPropertyList)(projectSchema, thisShape).forEach(([key, value]) => {
-            const resolver = value['@resolver'];
-            if (!(0, utils_1.isServiceResolver)(resolver)) {
-                return;
-            }
-            const serviceConfig = (0, util_2.getStoredServiceConfig)(projectSchema, resolver.service);
-            if (!serviceConfig) {
-                return;
-            }
-            const { provider } = serviceConfig;
-            const generators = {};
-            const tag = value['@tag'];
-            if (tag?.startsWith(constants_1.SERVICE_OBJECT_PATTERN_NAME)) {
-                const idFieldName = (0, schema_util_1.getServiceIdFieldName)(key);
-                const version = tag.substr(Number(tag.lastIndexOf(':')) + 1);
-                generators[constants_1.SERVICE_OBJECT_PATTERN_NAME] = {
-                    version,
-                    currentVersion: (0, schema_util_1.getGeneratorVersion)(constants_1.SERVICE_OBJECT_PATTERN_NAME),
-                    idFieldName,
-                    serviceObjectType: resolver.fieldName
-                };
-            }
-            const serviceInfo = {
-                service: resolver.service,
-                fieldName: key,
-                path: (0, schema_util_1.pathBetween)(shape, thisShape, projectSchema),
-                generators
-            };
-            if (Array.isArray(result[provider])) {
-                // Dedupe service info
-                if (!result[provider].find((existingServiceInfo) => (0, isEqual_js_1.default)(existingServiceInfo, serviceInfo))) {
-                    result[provider].push(serviceInfo);
-                }
-            }
-            else {
-                result[provider] = [serviceInfo];
-            }
-        });
-    }
-    return result;
-}

package/dist/cjs/src/services/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/services/util.js

@@ -1,45 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStoredServiceConfig = getStoredServiceConfig;
-exports.getServiceNamespaces = getServiceNamespaces;
-exports.isMissingAuth = isMissingAuth;
-exports.getResolverServices = getResolverServices;
-const util_1 = require("@takeshape/util");
-const isEmpty_js_1 = __importDefault(require("lodash/isEmpty.js"));
-const uniq_js_1 = __importDefault(require("lodash/uniq.js"));
-/**
- * Get a service config from a project schema.
- */
-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.
- */
-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;
-}
-function isMissingAuth(service) {
-    return service.authenticationType !== 'none' && (0, isEmpty_js_1.default)(service.authentication);
-}
-function getResolverServices(resolver) {
-    const resolverArray = 'compose' in resolver ? resolver.compose : [resolver];
-    return (0, uniq_js_1.default)(resolverArray.map((resolver) => ('service' in resolver ? resolver.service : undefined)).filter(util_1.isDefined));
-}

package/dist/cjs/src/taxonomies.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTaxonomies = exports.getTaxonomyField = void 0;
-exports.getFirstStringFieldV3 = getFirstStringFieldV3;
-const util_1 = require("@takeshape/util");
-const schema_util_1 = require("./schema-util");
-function getFirstStringFieldV3(shape, projectSchema) {
-    const forms = projectSchema.forms?.[shape.name];
-    if (!forms?.default) {
-        return null;
-    }
-    const schemaProperties = (0, schema_util_1.createSchemaPropertyAccessor)(projectSchema, shape);
-    const { order } = forms.default;
-    const name = order.find((name) => schemaProperties.getValue(name)?.type === 'string');
-    return name ? { name, key: schemaProperties.getKey(name) } : null;
-}
-exports.getTaxonomyField = (0, util_1.weakMemoize)((shape, projectSchema) => shape.model?.type === 'taxonomy' ? getFirstStringFieldV3(shape, projectSchema) : null);
-exports.getTaxonomies = (0, util_1.weakMemoize)((projectSchema) => {
-    const { shapes } = projectSchema;
-    return Object.keys(shapes).reduce((result, shapeName) => {
-        const shape = shapes[shapeName];
-        const field = (0, exports.getTaxonomyField)(shape, projectSchema);
-        if (field) {
-            result.push({ shapeId: shape.id, field });
-        }
-        return result;
-    }, []);
-});

package/dist/cjs/src/template-shapes/index.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTemplate = resolveTemplate;
-exports.isValidTemplate = isValidTemplate;
-const templates_1 = require("./templates");
-const templateMappings = {
-    TSGetArgs: templates_1.TSGetArgs,
-    TSGetSingletonArgs: templates_1.TSGetSingletonArgs,
-    TSListArgs: templates_1.TSListArgs,
-    TSSearchArgs: templates_1.TSSearchArgs,
-    CreateArgs: templates_1.CreateArgs,
-    UpdateArgs: templates_1.UpdateArgs,
-    DuplicateArgs: templates_1.DuplicateArgs,
-    DeleteArgs: templates_1.DeleteArgs,
-    PaginatedList: templates_1.PaginatedList,
-    SearchResults: templates_1.SearchResults,
-    CreateResult: templates_1.CreateResult,
-    UpdateResult: templates_1.UpdateResult,
-    DuplicateResult: templates_1.DuplicateResult,
-    DeleteResult: templates_1.DeleteResult
-};
-function resolveTemplate(projectSchema, templateName, shapeName) {
-    const mapping = templateMappings[templateName];
-    if (!mapping) {
-        throw new Error(`Invalid shape template ${templateName}`);
-    }
-    if (projectSchema.shapes[shapeName] === undefined) {
-        throw new Error(`Unknown shape "${shapeName}" in template "${templateName}"`);
-    }
-    return mapping({ projectSchema }, projectSchema.shapes[shapeName]);
-}
-/**
- * Check if a string is a known template such as `PaginatedList`
- */
-function isValidTemplate(template) {
-    return Boolean(templateMappings[template]);
-}

package/dist/cjs/src/template-shapes/names.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMutationInputShapeName = getMutationInputShapeName;
-exports.getInputShapeName = getInputShapeName;
-exports.getOutputShapeName = getOutputShapeName;
-const util_1 = require("@takeshape/util");
-/**
- * Construct a shape name used for a mutation input shape.
- */
-function getMutationInputShapeName(verb) {
-    return (shapeName) => {
-        return (0, util_1.formatShapeName)([verb, shapeName, 'input'], { shapeNameIndex: 1 });
-    };
-}
-/**
- * Create a shape name variant for an input.
- */
-function getInputShapeName(shapeName) {
-    if (shapeName === 'TSRelationship') {
-        return shapeName;
-    }
-    return `${shapeName}Input`;
-}
-function getOutputShapeName(name) {
-    return name.replace(/(?:Input|PartialInput)$/, '');
-}