@takeshape/schema 11.52.0 → 11.56.1

package/dist/esm/src/schemas/project-schema.json

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

package/dist/esm/src/schemas/user-schema.json

@@ -1,51 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://schema.takeshape.io/user-schema#",
-  "title": "User",
-  "properties": {
-    "id": {
-      "type": "string"
-    },
-    "email": {
-      "type": "string"
-    },
-    "fullName": {
-      "type": "string"
-    },
-    "created": {
-      "type": "number"
-    },
-    "updated": {
-      "type": "number"
-    },
-    "firstTime": {
-      "type": "boolean"
-    },
-    "avatarPath": {
-      "type": "string"
-    },
-    "intercomHash": {
-      "type": "string"
-    },
-    "googleUserId": {
-      "type": "string"
-    },
-    "comcastId": {
-      "type": "string"
-    },
-    "token": {
-      "type": "string"
-    },
-    "policies": {
-      "type": "array",
-      "items": {
-        "$ref": "src/schemas/auth-schemas.json#/definitions/AccessPolicyDocument"
-      }
-    },
-    "preferences": {
-      "type": "object"
-    }
-  },
-  "additionalProperties": false,
-  "required": ["id", "email", "fullName", "created", "updated", "firstTime"]
-}

package/dist/esm/src/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, propertyRefItemToPath, refExpressionToRefItem, refItemToNamespacedShapeName } from "./refs.js";
-import { getAllNamespaceShapes, getAllRefsInQuery, getArgsReference, isValidRefItem, 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.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: pick(services, [ref.serviceId]) // include own service so refs have isValidService: true
-            };
-            results.push(...getAllRefsInQuery(layerWithService, [], query));
-        }
-    }
-    return results;
-}
-function interfacesToShapeNames(projectSchema, shapeRefArray) {
-    return shapeRefArray.map((shapeRef) => refItemToNamespacedShapeName(refExpressionToRefItem(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(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)
-                .map(refItemToNamespacedShapeName));
-            // 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/esm/src/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.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/esm/src/taxonomies.js

@@ -1,24 +0,0 @@
-import { weakMemoize } from "@takeshape/util";
-import { createSchemaPropertyAccessor } from "./schema-util.js";
-export function getFirstStringFieldV3(shape, projectSchema) {
-    const forms = projectSchema.forms?.[shape.name];
-    if (!forms?.default) {
-        return null;
-    }
-    const schemaProperties = 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;
-}
-export const getTaxonomyField = weakMemoize((shape, projectSchema) => shape.model?.type === "taxonomy" ? getFirstStringFieldV3(shape, projectSchema) : null);
-export const getTaxonomies = weakMemoize((projectSchema) => {
-    const { shapes } = projectSchema;
-    return Object.keys(shapes).reduce((result, shapeName) => {
-        const shape = shapes[shapeName];
-        const field = getTaxonomyField(shape, projectSchema);
-        if (field) {
-            result.push({ shapeId: shape.id, field });
-        }
-        return result;
-    }, []);
-});