@takeshape/schema 11.52.0 → 11.56.1

package/dist/esm/src/unions.js

@@ -1,77 +0,0 @@
-import { BadDataError } from "@takeshape/errors";
-import { camelCase, isRecord } from "@takeshape/util";
-import omit from "lodash/omit.js";
-import { getRef, refItemToNamespacedShapeName } from "./refs.js";
-import { getOutputShapeName } from "./template-shapes/names.js";
-import { isRefSchema } from "./types/utils.js";
-import { getShapeById } from "./util/shapes.js";
-export function enumerateOneOfKeys(projectSchema, oneOf) {
-    const result = [];
-    for (const child of oneOf) {
-        const refItem = getRef(projectSchema, child);
-        if (refItem) {
-            const shapeName = refItemToNamespacedShapeName(refItem);
-            if (projectSchema.shapes[shapeName]) {
-                const shapeId = projectSchema.shapes[shapeName].id;
-                result.push({
-                    propName: getOutputShapeName(camelCase(refItem.typeName)),
-                    propSchema: child,
-                    shapeName,
-                    shapeId
-                });
-            }
-        }
-    }
-    return result;
-}
-function getOneOf(schema) {
-    if (!schema.oneOf) {
-        throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
-    }
-    return schema.oneOf;
-}
-export function isUnionSchema(schema) {
-    return Boolean(schema.oneOf?.every(isRefSchema));
-}
-export function oneOfToObject(projectSchema, schema) {
-    const properties = {};
-    for (const { propName, propSchema: child } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
-        properties[propName] = child;
-    }
-    return { ...omit(schema, "oneOf"), type: "object", properties };
-}
-function formatKeys(keys) {
-    return keys.map((k) => `"${k}"`).join(", ");
-}
-export const createUnwrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if (isRecord(obj)) {
-        const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
-        const objectKeys = Object.keys(obj);
-        if (objectKeys.length !== 1) {
-            const propNames = oneOfKeys.map((k) => k.propName);
-            throw new BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
-        }
-        for (const { propName, shapeId, propSchema } of oneOfKeys) {
-            const propValue = obj[propName];
-            if (isRecord(propValue)) {
-                const transformedPropValue = next(propValue, propSchema, name);
-                if (isRecord(transformedPropValue)) {
-                    return {
-                        ...transformedPropValue,
-                        _shapeId: shapeId
-                    };
-                }
-            }
-        }
-    }
-};
-export const createWrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if (isRecord(obj) && typeof obj._shapeId === "string") {
-        const shape = getShapeById(projectSchema, obj._shapeId);
-        if (shape) {
-            return {
-                [camelCase(shape.name)]: next(omit(obj, "_shapeId"), shape.schema, name)
-            };
-        }
-    }
-};

package/dist/esm/src/user-schema.js

@@ -1,7 +0,0 @@
-/* tslint:disable */
-/**
- * This file was automatically generated by json-schema-to-typescript.
- * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
- * and run json-schema-to-typescript to regenerate this file.
- */
-export {};

package/dist/esm/src/util/api-indexing.js

@@ -1,57 +0,0 @@
-import { ensureArray } from "@takeshape/util";
-import { getQuery } from "../refs.js";
-import { getIdField } from "../schema-util.js";
-import { getResolverServices } from "../services/util.js";
-import { isCachedShape, isServiceResolver } from "../types/index.js";
-export function serviceHasIndexedShapes(schema, serviceId) {
-    for (const shape of Object.values(schema.shapes ?? {})) {
-        const indexingEnabled = isCachedShape(shape);
-        const listConfigs = shape.loaders?.list;
-        if (indexingEnabled && listConfigs) {
-            for (const { query: queryRef } of ensureArray(listConfigs)) {
-                const resolved = getQuery(schema, queryRef);
-                if (resolved && isServiceResolver(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-export function getIndexedServices(projectSchema, configs) {
-    return ensureArray(configs).reduce((services, queryConfig) => {
-        const resolved = queryConfig?.query ? getQuery(projectSchema, queryConfig.query) : undefined;
-        return resolved?.query ? [...services, ...getResolverServices(resolved.query.resolver)] : services;
-    }, []);
-}
-function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-    return (maybeConfigArray &&
-        ensureArray(maybeConfigArray).flatMap((config) => ensureArray(config.args).map((args) => ({
-            ...base,
-            ...queryConfig,
-            ...config,
-            args
-        }))));
-}
-function getQueryIndexConfigHelper(op) {
-    return ({ shapes }, shapeName) => {
-        const { cache, loaders } = shapes[shapeName] ?? {};
-        if (cache && loaders) {
-            const idField = getIdField(cache);
-            if (op === "list") {
-                return flattenListQueryConfigs({ shapeName, idField }, cache.fragment, loaders.list);
-            }
-            const queryConfig = loaders.get;
-            if (queryConfig) {
-                return {
-                    idField,
-                    shapeName,
-                    ...cache.fragment,
-                    ...queryConfig
-                };
-            }
-        }
-    };
-}
-export const getListQueryIndexConfigs = getQueryIndexConfigHelper("list");
-export const getGetQueryIndexConfig = getQueryIndexConfigHelper("get");

package/dist/esm/src/util/detect-cycles.js

@@ -1,45 +0,0 @@
-import { value } from "@takeshape/util";
-import { getRef, refItemToShape } from "../refs.js";
-function immutableSetAdd(set, str) {
-    const result = new Set(set);
-    result.add(str);
-    return result;
-}
-/**
- * Use a basic depth-first search to determine whether a schema contains a cycle
- */
-export function hasCycle(projectSchema, schema, predicate = value(true)) {
-    const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
-        if (!predicate(projectSchema, schema, shapeName, propName)) {
-            return false;
-        }
-        const refItem = getRef(projectSchema, schema);
-        if (refItem) {
-            const refShape = refItemToShape(projectSchema, refItem);
-            // If we have a refItem, but no shape, this is a dangling ref and has no cycles
-            if (!refShape) {
-                return false;
-            }
-            if (shapesSeen.has(refShape.name)) {
-                return true;
-            }
-            return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
-        }
-        const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
-        if (combo) {
-            return combo.some((childSchema) => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
-        }
-        if (schema.items) {
-            return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
-        }
-        const { properties } = schema;
-        if (properties) {
-            return Object.keys(properties).some((name) => {
-                const propSchema = properties[name];
-                return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
-            });
-        }
-        return false;
-    };
-    return hasCycleHelper(schema);
-}

package/dist/esm/src/util/form-config.js

@@ -1,62 +0,0 @@
-import { deepClone } from "@takeshape/util";
-import { getRefOrItemsRef, refItemToNamespacedShapeName } from "../refs.js";
-import { createSchemaPropertyAccessor } from "../schema-util.js";
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-export function normalizeForms(projectSchema) {
-    const normalizedForms = {};
-    const { forms = {} } = projectSchema;
-    const storeSourceForm = (shapeName, formConfig, propName) => {
-        // Leave original forms intact for backwards compatibility
-        if (!forms[shapeName]) {
-            normalizedForms[shapeName] ||= { default: deepClone(formConfig) };
-            // Remove prop now that it has been normalized
-            delete normalizedForms[shapeName].default.properties[propName];
-        }
-    };
-    const normalizeNested = (shapeName, formConfig) => {
-        const shape = projectSchema.shapes[shapeName];
-        if (!shape || !formConfig.properties) {
-            return;
-        }
-        const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
-        for (const propName of Object.keys(formConfig.properties)) {
-            const propConfig = formConfig.properties[propName];
-            const propSchema = propertyAccessor.getValue(propName);
-            if (propSchema) {
-                const ref = getRefOrItemsRef(projectSchema, propSchema);
-                if (ref && propConfig.properties) {
-                    const nestedShapeName = refItemToNamespacedShapeName(ref);
-                    normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
-                    storeSourceForm(shapeName, formConfig, propName);
-                    normalizeNested(nestedShapeName, propConfig);
-                }
-            }
-        }
-    };
-    if (forms) {
-        for (const shapeName of Object.keys(forms)) {
-            normalizeNested(shapeName, forms[shapeName].default);
-            // copy forms with no changes
-            normalizedForms[shapeName] ||= forms[shapeName];
-        }
-    }
-    return normalizedForms;
-}
-const cache = new WeakMap();
-/**
- * Find the form config for a given shape name and the form key.
- */
-export function findShapeFormConfig(projectSchema, shapeName, formName) {
-    if (!projectSchema.forms) {
-        return;
-    }
-    let normalizedForms = cache.get(projectSchema);
-    if (!normalizedForms) {
-        normalizedForms = normalizeForms(projectSchema);
-        cache.set(projectSchema, normalizedForms);
-    }
-    return normalizedForms[shapeName]?.[formName];
-}

package/dist/esm/src/util/get-conflicting-properties.js

@@ -1,55 +0,0 @@
-import { isDefined, setIsEqual } from "@takeshape/util";
-import { dereferenceSchema, getRef, refItemToAtRef } from "../refs.js";
-import { isObjectSchema } from "../types/index.js";
-/**
- * Normalize ref, oneOf and array schemas and get a list of @ref expressions
- */
-function getRefStrings(context, propertySchema) {
-    const schema = propertySchema.items ?? propertySchema;
-    const schemas = schema.oneOf ? schema.oneOf : [schema];
-    return schemas
-        .map((propertySchema) => {
-        const ref = getRef(context, propertySchema);
-        return ref ? refItemToAtRef(ref) : undefined;
-    })
-        .filter(isDefined);
-}
-function isRefEqual(context, a, b) {
-    return setIsEqual(getRefStrings(context, a), getRefStrings(context, b));
-}
-/**
- * Given a list of shapes find the conflicting props
- */
-export function getConflictingProperties(context, shapes) {
-    const conflicts = new Set();
-    const allProps = {};
-    for (const shape of Object.values(shapes)) {
-        const schema = dereferenceSchema(context, shape.schema, ["shapes", shape.name]);
-        if (!isObjectSchema(schema)) {
-            continue;
-        }
-        const required = new Set(schema.required ?? []);
-        for (const [name, prop] of Object.entries(schema.properties)) {
-            // skip props that we know already have  conflict
-            if (conflicts.has(name)) {
-                continue;
-            }
-            const isRequired = required.has(name);
-            if (allProps[name]) {
-                if (
-                // same type
-                allProps[name][0].type !== prop.type ||
-                    // same refs
-                    !isRefEqual(context, allProps[name][0], prop) ||
-                    // same nullability
-                    isRequired !== allProps[name][1]) {
-                    conflicts.add(name);
-                }
-            }
-            else {
-                allProps[name] = [prop, isRequired];
-            }
-        }
-    }
-    return conflicts;
-}

package/dist/esm/src/util/get-return-shape.js

@@ -1,30 +0,0 @@
-import { getRef, parseReturnShape, refItemToShape } from "../refs.js";
-function isQuery(propOrQuery) {
-    return "shape" in propOrQuery && "resolver" in propOrQuery;
-}
-function getReturnShapeHelper(projectSchema, propOrQuery) {
-    let shape;
-    if (isQuery(propOrQuery)) {
-        const { shapeName } = parseReturnShape(projectSchema, propOrQuery.shape);
-        shape = projectSchema.shapes[shapeName];
-    }
-    else {
-        const ref = getRef(projectSchema, propOrQuery);
-        if (ref) {
-            shape = refItemToShape(projectSchema, ref);
-        }
-    }
-    return shape;
-}
-export function getReturnShapeRef(context, propOrQuery) {
-    return isQuery(propOrQuery) ? parseReturnShape(context, propOrQuery.shape).ref : getRef(context, propOrQuery);
-}
-const cache = new WeakMap();
-export function getReturnShape(projectSchema, propOrQuery) {
-    let result = cache.get(propOrQuery);
-    if (result === undefined) {
-        result = getReturnShapeHelper(projectSchema, propOrQuery);
-        cache.set(propOrQuery, result ?? null);
-    }
-    return result ?? undefined;
-}

package/dist/esm/src/util/has-arg.js

@@ -1,13 +0,0 @@
-import { findSchemaAtPath } from "./find-shape-at-path.js";
-export function getArgs(prop) {
-    return "@args" in prop ? prop["@args"] : "args" in prop ? prop.args : undefined;
-}
-export function hasArg(projectSchema, prop, argPath) {
-    const args = getArgs(prop);
-    if (!args) {
-        return false;
-    }
-    const schema = typeof args === "string" ? projectSchema.shapes[args]?.schema : args;
-    const pathArray = Array.isArray(argPath) ? argPath : argPath.split(".");
-    return Boolean(findSchemaAtPath(projectSchema, schema, pathArray));
-}

package/dist/esm/src/util/merge.js

@@ -1,256 +0,0 @@
-import { assert, deepClone, isDefined, rebaseArray, rebaseObject } from "@takeshape/util";
-import { assignWith } from "lodash";
-import difference from "lodash/difference.js";
-import isEqual from "lodash/isEqual.js";
-import last from "lodash/last.js";
-import omit from "lodash/omit.js";
-import pickBy from "lodash/pickBy.js";
-import set from "lodash/set.js";
-import union from "lodash/union.js";
-import unset from "lodash/unset.js";
-import { isExtendsSchema, isObjectSchema, isRefSchema } from "../types/index.js";
-export function mergeObjectSchemas(...args) {
-    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas), {
-        type: "object",
-        properties: {}
-    });
-}
-export function mergeDeepObjectSchemas(...args) {
-    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas, true), {
-        type: "object",
-        properties: {}
-    });
-}
-export function mergeSchemaProperties(parent, overrides, deep = false) {
-    const result = {
-        ...parent,
-        properties: deep
-            ? assignWith({}, parent.properties, overrides.properties, (objValue, srcValue) => {
-                // merge objects if possible
-                if (objValue !== undefined && srcValue !== undefined) {
-                    // skip merging if they are equal this avoids allOf with duplicate refs
-                    if (isEqual(objValue, srcValue)) {
-                        return objValue;
-                    }
-                    if (isObjectSchema(objValue) && isObjectSchema(srcValue)) {
-                        return mergeObjectSchemas(objValue, srcValue);
-                    }
-                    if ((isObjectSchema(objValue) || isRefSchema(objValue)) &&
-                        (isObjectSchema(srcValue) || isRefSchema(srcValue))) {
-                        return { allOf: [objValue, srcValue] };
-                    }
-                }
-            })
-            : { ...parent.properties, ...overrides.properties }
-    };
-    const required = union(parent.required, overrides.required);
-    if (required.length) {
-        result.required = required;
-    }
-    return result;
-}
-export function rebaseSchemaProperties(base, parent, head) {
-    const { properties: toProperties, required: toRequired, ...toOther } = base;
-    const { properties: baseProperties, required: baseRequired, ...baseOther } = parent;
-    const { properties: fromProperties, required: fromRequired, ...fromOther } = head;
-    const newSchema = {
-        ...rebaseObject(toOther, baseOther, fromOther),
-        type: "object",
-        properties: rebaseObject(toProperties, baseProperties, fromProperties)
-    };
-    const required = rebaseArray(toRequired ?? [], baseRequired ?? [], fromRequired ?? []);
-    if (required.length) {
-        newSchema.required = required;
-    }
-    return newSchema;
-}
-export function mergeFormProperties(parent, overrides) {
-    const result = {
-        ...parent,
-        properties: {
-            ...parent.properties,
-            ...overrides.properties
-        }
-    };
-    const order = union(parent.order, overrides.order);
-    if (order.length) {
-        result.order = order;
-    }
-    return result;
-}
-export function rebaseFormProperties(base, parent, head) {
-    const { properties: toProperties, order: toOrder, ...toOther } = base;
-    const { properties: baseProperties, order: baseOrder, ...baseOther } = parent;
-    const { properties: fromProperties, order: fromOrder, ...fromOther } = head;
-    const newForm = {
-        ...rebaseObject(toOther, baseOther, fromOther),
-        properties: rebaseObject(toProperties, baseProperties, fromProperties)
-    };
-    const order = rebaseArray(toOrder ?? [], baseOrder ?? [], fromOrder ?? []);
-    if (order.length) {
-        newForm.order = order;
-    }
-    return newForm;
-}
-export function mergeFormConfigs(...configs) {
-    return configs.reduce(mergeFormProperties, { properties: {}, order: [] });
-}
-const mergeableSections = ["shapes", "mutations", "queries", "forms", "services"];
-const isMergeableSection = (str) => {
-    return mergeableSections.includes(str);
-};
-const pickUnmergeable = (projectSchema) => {
-    return pickBy(projectSchema, (_value, key) => !isMergeableSection(key));
-};
-function compareSection(section, original, updated) {
-    const changes = [];
-    const originalKeys = Object.keys(original);
-    const updatedKeys = Object.keys(updated);
-    for (const removedKey of difference(originalKeys, updatedKeys)) {
-        changes.push({ path: [section, removedKey], section, op: "remove" });
-    }
-    for (const [key, value] of Object.entries(updated)) {
-        if (!original[key]) {
-            changes.push({ path: [section, key], section, op: "add", value });
-        }
-        else if (!isEqual(original[key], updated[key])) {
-            changes.push({ path: [section, key], section, op: "update", value });
-        }
-    }
-    return changes;
-}
-function compareSections(parent, branch) {
-    return mergeableSections.flatMap((section) => (parent[section] ?? branch[section]) ? compareSection(section, parent[section] ?? {}, branch[section] ?? {}) : []);
-}
-function findChangedShape(schema, change) {
-    return schema.shapes[change.path[1]];
-}
-function getChangedShape(schema, change) {
-    const shape = findChangedShape(schema, change);
-    assert(shape, "Expected shape not found");
-    return shape;
-}
-function rebaseShapeProperties(toShape, fromShape, baseShape) {
-    return baseShape
-        ? rebaseObject(omit(toShape, "schema"), omit(baseShape, "schema"), omit(fromShape, "schema"))
-        : { ...toShape, ...fromShape };
-}
-// eslint-disable-next-line complexity
-function attemptToMerge(base, parent, head, change) {
-    const toShape = getChangedShape(base, change);
-    const fromShape = getChangedShape(head, change);
-    const toSchema = toShape.schema;
-    const fromSchema = fromShape.schema;
-    if (isEqual(toSchema, fromSchema)) {
-        const baseShape = findChangedShape(parent, change);
-        return {
-            ...rebaseShapeProperties(toShape, fromShape, baseShape),
-            schema: toSchema
-        };
-    }
-    if (isObjectSchema(toSchema) && isObjectSchema(fromSchema)) {
-        const baseShape = findChangedShape(parent, change);
-        const baseSchema = baseShape?.schema;
-        return {
-            ...rebaseShapeProperties(toShape, fromShape, baseShape),
-            schema: change.op === "update" && baseSchema && isObjectSchema(baseSchema)
-                ? rebaseSchemaProperties(toSchema, baseSchema, fromSchema)
-                : mergeSchemaProperties(toSchema, fromSchema)
-        };
-    }
-    if (isExtendsSchema(toSchema) &&
-        isExtendsSchema(fromSchema) &&
-        toSchema.extends.length === fromSchema.extends.length) {
-        const fromExtends = fromSchema.extends;
-        const toObj = last(toSchema.extends);
-        const fromObj = last(fromSchema.extends);
-        if (toObj &&
-            isObjectSchema(toObj) &&
-            fromObj &&
-            isObjectSchema(fromObj) &&
-            toSchema.extends.slice(0, toSchema.extends.length - 1).every((item, i) => isEqual(item, fromExtends[i]))) {
-            let mergedObjSchema;
-            const baseShape = findChangedShape(parent, change);
-            const baseSchema = baseShape?.schema;
-            if (change.op === "update" && baseSchema && isExtendsSchema(baseSchema)) {
-                const baseObj = last(baseSchema.extends);
-                if (baseObj && isObjectSchema(baseObj)) {
-                    mergedObjSchema = rebaseSchemaProperties(toObj, baseObj, fromObj);
-                }
-            }
-            mergedObjSchema ||= mergeSchemaProperties(toObj, fromObj);
-            return {
-                ...rebaseShapeProperties(toShape, fromShape, baseShape),
-                schema: {
-                    extends: [...toSchema.extends.slice(0, toSchema.extends.length - 1), mergedObjSchema]
-                }
-            };
-        }
-    }
-}
-function applyChange(base, parent, head, change) {
-    if (change.op === "remove") {
-        unset(base, change.path);
-    }
-    else if (change.op === "add") {
-        set(base, change.path, change.value);
-    }
-    else if (change.op === "update") {
-        if (change.section === "shapes") {
-            const mergedShape = attemptToMerge(base, parent, head, change);
-            if (mergedShape) {
-                set(base, change.path, mergedShape);
-                return;
-            }
-        }
-        else if (change.section === "forms") {
-            const shapeName = change.path[1];
-            const toForm = base.forms?.[shapeName]?.default;
-            const fromForm = head.forms?.[shapeName]?.default;
-            if (toForm && fromForm) {
-                const baseForm = parent.forms?.[shapeName]?.default;
-                set(base, change.path, {
-                    default: baseForm ? rebaseFormProperties(toForm, baseForm, fromForm) : mergeFormConfigs(toForm, fromForm)
-                });
-                return;
-            }
-        }
-        set(base, change.path, change.value);
-    }
-}
-export function mergeProjectSchemas(base, parent, head) {
-    const changesTo = compareSections(parent, base);
-    const changesFrom = compareSections(parent, head);
-    const mergedSchema = deepClone(base);
-    for (let change of changesFrom) {
-        const potentialConflict = changesTo.find((changeTo) => isEqual(changeTo.path, change.path));
-        if (potentialConflict) {
-            if (potentialConflict.op === "remove" && change.op !== "remove") {
-                return {
-                    error: `Attempting to ${change.op} ${change.path.join(".")} which has already been removed`,
-                    mergedSchema: undefined
-                };
-            }
-            if ((potentialConflict.op === "add" && change.op === "add") ||
-                (potentialConflict.op === "update" && change.op === "update")) {
-                if (change.section === "shapes") {
-                    const mergedValue = attemptToMerge(base, parent, head, change);
-                    // eslint-disable-next-line max-depth
-                    if (!mergedValue) {
-                        return {
-                            error: `Unable to merge ${change.path.join(".")} schemas conflict`,
-                            mergedSchema: undefined
-                        };
-                    }
-                    change = { ...change, op: "add", value: mergedValue };
-                }
-                else if (change.section === "forms") {
-                    change = { ...change, op: "update" };
-                }
-            }
-        }
-        applyChange(mergedSchema, parent, head, change);
-    }
-    Object.assign(mergedSchema, rebaseObject(pickUnmergeable(base), pickUnmergeable(parent), pickUnmergeable(head)));
-    return { error: undefined, mergedSchema };
-}