@takeshape/schema 11.40.0 → 11.41.0

package/dist/cjs/src/content-schema-transform.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyInfo = exports.getContentTransform = exports.findTransforms = exports.preferSourceKey = exports.preferName = exports.preferKey = exports.getType = void 0;
+const forEach_js_1 = __importDefault(require("lodash/forEach.js"));
+const difference_js_1 = __importDefault(require("lodash/difference.js"));
+const pick_js_1 = __importDefault(require("lodash/pick.js"));
+const get_js_1 = __importDefault(require("lodash/get.js"));
+const schema_util_1 = require("./schema-util");
+const utils_1 = require("./types/utils");
+const refs_1 = require("./refs");
+const unions_1 = require("./unions");
+const typeCache = new WeakMap();
+function getType(schema) {
+    let type = typeCache.get(schema);
+    if (type) {
+        return type;
+    }
+    type = schema.type;
+    // Handle nullable types for example: ['object', 'null']
+    if (Array.isArray(type)) {
+        const filtered = type.filter(name => name !== 'null');
+        if (!filtered.length) {
+            throw new Error(`Invalid schema`);
+        }
+        type = filtered[0];
+    }
+    typeCache.set(schema, type);
+    return type;
+}
+exports.getType = getType;
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function preferKey(name, schema) {
+    return (0, schema_util_1.getStorageKey)(schema) ?? name;
+}
+exports.preferKey = preferKey;
+/**
+ * A key transform to select the field name
+ */
+const preferName = name => name;
+exports.preferName = preferName;
+function getLocalizedKey(key, locale) {
+    return locale ? `${key}:${locale}` : key;
+}
+function getNonDefaultLocales(projectSchema) {
+    return projectSchema.locales.filter(locale => locale !== projectSchema.defaultLocale);
+}
+function getLocalizedSourceKeys(keys, locales) {
+    return keys.flatMap(key => [{ key }, ...locales.map(locale => ({ key: `${key}:${locale}`, locale }))]);
+}
+function preferSourceKey(name, schema) {
+    const key = (0, schema_util_1.getStorageKey)(schema);
+    return key ? [key, name] : [name];
+}
+exports.preferSourceKey = preferSourceKey;
+function findTransforms(pluginMap, schema, name, shape) {
+    const type = getType(schema);
+    if (pluginMap && (pluginMap[type] ?? pluginMap['*'])) {
+        const plugins = (pluginMap[type] ?? []).concat(pluginMap['*'] ?? []);
+        return plugins.find(plugin => plugin.filter(schema, name, shape));
+    }
+    return undefined;
+}
+exports.findTransforms = findTransforms;
+function getContentTransform({ transforms, accumulators, keyTransform = preferKey, sourceKeyTransform = preferSourceKey, passThrough = true, allowNullObjects = false, projectSchema }) {
+    const nonDefaultLocales = getNonDefaultLocales(projectSchema);
+    const prepare = (schema, obj, name = '') => {
+        const shapeName = (0, refs_1.getRefShapeName)(projectSchema, schema);
+        schema = (0, refs_1.dereferenceSchema)(projectSchema, schema);
+        if (accumulators) {
+            accumulators.forEach(accumulator => {
+                accumulator.accumulate(obj, schema, name);
+            });
+        }
+        const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
+        const transform = findTransforms(transforms, schema, name, shape);
+        if (transform) {
+            const next = (value, schema, name) => prepare(schema, value, name);
+            return transform.process(obj, schema, name, shape, next);
+        }
+        if (obj && (0, unions_1.isUnionSchema)(schema)) {
+            for (const { shapeId, propSchema } of (0, unions_1.enumerateOneOfKeys)(projectSchema, schema.oneOf)) {
+                if (obj._shapeId === shapeId) {
+                    return prepare(propSchema, obj, name);
+                }
+            }
+        }
+        if (obj && (0, utils_1.isObjectSchema)(schema)) {
+            const result = {};
+            const assigned = new Set();
+            (0, forEach_js_1.default)(schema.properties, (fieldSchema, name) => {
+                const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
+                const localizedSourceKeys = getLocalizedSourceKeys(sourceKeys, nonDefaultLocales);
+                for (const { key: sourceKey, locale } of localizedSourceKeys) {
+                    const value = prepare(fieldSchema, (0, get_js_1.default)(obj, sourceKey), name);
+                    if (value !== undefined) {
+                        assigned.add(sourceKey);
+                        const transform = findTransforms(transforms, (0, refs_1.dereferenceSchema)(projectSchema, fieldSchema), name);
+                        const getKey = transform?.keyTransform ? transform.keyTransform : keyTransform;
+                        const key = getLocalizedKey(getKey(name, fieldSchema, sourceKey), locale);
+                        result[key] = value;
+                    }
+                }
+            });
+            if (passThrough && obj) {
+                const keys = (0, difference_js_1.default)(Object.keys(obj), [...assigned]);
+                if (keys.length) {
+                    Object.assign(result, (0, pick_js_1.default)(obj, keys));
+                }
+            }
+            return result;
+        }
+        if ((0, utils_1.isArraySchema)(schema)) {
+            const itemSchema = schema.items;
+            if (Array.isArray(obj)) {
+                return obj.map(item => prepare(itemSchema, item, name));
+            }
+            if (obj === undefined) {
+                prepare(itemSchema, obj, name);
+            }
+        }
+        if (allowNullObjects && (0, utils_1.isObjectSchema)(schema) && obj === null) {
+            return null;
+        }
+        // Allow properties that have not been transformed
+        return passThrough ? obj : undefined;
+    };
+    return prepare;
+}
+exports.getContentTransform = getContentTransform;
+function transformKey(transforms, propSchema, name, transform = preferKey) {
+    const schemaTransform = findTransforms(transforms, propSchema, name);
+    if (schemaTransform?.keyTransform) {
+        transform = schemaTransform.keyTransform;
+    }
+    return transform(name, propSchema);
+}
+function getPropertyInfo(context, schema, path) {
+    const { projectSchema, transforms, keyTransform } = context;
+    const result = [];
+    const findProperty = (currentSchema, name, rest, path) => {
+        if ((0, utils_1.isObjectSchema)(currentSchema)) {
+            const propSchema = currentSchema.properties[name];
+            const isRequired = currentSchema.required?.includes(name) ?? false;
+            if (!propSchema) {
+                return;
+            }
+            const refSchema = (0, refs_1.dereferenceSchema)(projectSchema, propSchema);
+            const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
+            if (rest.length) {
+                const [nextName, ...nextRest] = rest;
+                findProperty(refSchema, nextName, nextRest, nextPath);
+            }
+            else {
+                result.push({ schema: refSchema, key: nextPath.join('.'), isRequired });
+            }
+        }
+        else if ((0, unions_1.isUnionSchema)(currentSchema)) {
+            for (const optionSchema of currentSchema.oneOf) {
+                findProperty((0, refs_1.dereferenceSchema)(projectSchema, optionSchema), name, rest, path);
+            }
+        }
+        else if ((0, utils_1.isArraySchema)(currentSchema)) {
+            findProperty((0, refs_1.dereferenceSchema)(projectSchema, currentSchema.items), name, rest, path);
+        }
+    };
+    const [first, ...rest] = path.split('.');
+    findProperty((0, refs_1.dereferenceSchema)(projectSchema, schema), first, rest, []);
+    return result;
+}
+exports.getPropertyInfo = getPropertyInfo;

package/dist/cjs/src/create-input-schema.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInputSchema = void 0;
+const defaults_js_1 = __importDefault(require("lodash/fp/defaults.js"));
+const util_1 = require("@takeshape/util");
+const inputSchemaCache = new Map();
+function getInputSchemaCache(options) {
+    // Ensure key order does not invalidate the cache
+    const key = JSON.stringify(options, Object.keys(options).sort());
+    let cache = inputSchemaCache.get(key);
+    if (!cache) {
+        cache = new WeakMap();
+        inputSchemaCache.set(key, cache);
+    }
+    return cache;
+}
+/**
+ * Convert all output properties in the schema to be input properties,
+ * For an update, remove `required` and `default` fields as well.
+ */
+function createInputSchema(schema, options = {}) {
+    const inputSchemaCache = getInputSchemaCache((0, defaults_js_1.default)({ isUpdate: false }, options));
+    let rewrittenSchema = inputSchemaCache.get(schema);
+    if (rewrittenSchema) {
+        return rewrittenSchema;
+    }
+    rewrittenSchema = (0, util_1.deepCloneWith)(schema, (value, key, parent, clone) => {
+        // Remove required
+        if (options.isUpdate && key === 'required' && Array.isArray(value) && value.length) {
+            return util_1.REMOVE;
+        }
+        // Remove default
+        if (options.isUpdate &&
+            key === 'default' &&
+            value !== undefined &&
+            (0, util_1.isIterableObject)(parent) &&
+            parent.type !== undefined) {
+            return util_1.REMOVE;
+        }
+        if (key === 'properties' && (0, util_1.isIterableObject)(value) && (0, util_1.isIterableObject)(parent) && parent.type === 'object') {
+            const newProperties = {};
+            for (const [key, prop] of Object.entries(value)) {
+                if ((0, util_1.isIterableObject)(prop) && (!prop['@resolver'] || prop['@input'])) {
+                    newProperties[key] = clone(prop, key, value);
+                }
+            }
+            return newProperties;
+        }
+        if ((0, util_1.isIterableObject)(value) && (0, util_1.isIterableObject)(value['@input'])) {
+            const { '@input': input, '@l10n': l10n, '@syncLocaleStructure': syncLocaleStructure, '@mapping': mapping, title, ...output } = value;
+            return {
+                ...clone(input, '@input', value),
+                title,
+                '@l10n': l10n,
+                '@syncLocaleStructure': syncLocaleStructure,
+                '@mapping': mapping,
+                '@output': output
+            };
+        }
+    });
+    inputSchemaCache.set(schema, rewrittenSchema);
+    return rewrittenSchema;
+}
+exports.createInputSchema = createInputSchema;

package/dist/cjs/src/enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnumLikeSchema = void 0;
+function isEnumLikeSchema(schema) {
+    if (schema.enum) {
+        return true;
+    }
+    if (schema.oneOf) {
+        return schema.oneOf.every(optionSchema => optionSchema.title !== undefined && (optionSchema.enum ?? optionSchema.const));
+    }
+    return false;
+}
+exports.isEnumLikeSchema = isEnumLikeSchema;

package/dist/cjs/src/flatten-templates.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenTemplates = void 0;
+const set_js_1 = __importDefault(require("lodash/set.js"));
+const util_1 = require("@takeshape/util");
+const template_shapes_1 = require("./template-shapes");
+const schema_util_1 = require("./schema-util");
+const refs_1 = require("./refs");
+function flattenTemplates(projectSchema) {
+    const templateRefs = (0, schema_util_1.getAllRefs)(projectSchema, ref => Boolean(ref.template));
+    if (!templateRefs.length) {
+        return projectSchema;
+    }
+    const newSchema = (0, util_1.deepClone)(projectSchema);
+    for (const ref of templateRefs) {
+        if (ref.template && (0, template_shapes_1.isValidTemplate)(ref.template)) {
+            const { shapeName, dependencies } = (0, template_shapes_1.resolveTemplate)(newSchema, ref.template, (0, refs_1.refItemToNamespacedShapeName)(ref));
+            (0, set_js_1.default)(newSchema, ref.path, ref.path[ref.path.length - 1] === '@ref' ? `local:${shapeName}` : shapeName);
+            Object.assign(newSchema.shapes, dependencies);
+        }
+    }
+    return newSchema;
+}
+exports.flattenTemplates = flattenTemplates;

package/dist/cjs/src/get-is-leaf.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsLeaf = void 0;
+const content_schema_transform_1 = require("./content-schema-transform");
+const schema_util_1 = require("./schema-util");
+const refs_1 = require("./refs");
+const types_1 = require("./types");
+const scalarTags = new Set(['draftjs']);
+function isLeafTypeV3(projectSchema, propertySchema) {
+    const type = (0, content_schema_transform_1.getType)(propertySchema);
+    return Boolean(
+    // Must have key
+    (0, schema_util_1.getStorageKey)(propertySchema) &&
+        // If is not a structure, then is a leaf
+        (!['object', 'array'].includes(type) ||
+            // If is relationship, then is a leaf
+            (0, types_1.isPropertySchemaWithRelationship)(propertySchema['@output'] ?? propertySchema) ||
+            Boolean(propertySchema['@tag'] && scalarTags.has(propertySchema['@tag'])) ||
+            // If is array, then should not be a synchronized structure
+            (type === 'array' && !propertySchema['@syncLocaleStructure']) ||
+            (0, schema_util_1.isBuiltinType)(projectSchema, propertySchema)));
+}
+function getIsLeaf(projectSchema, shapeSchema) {
+    const leafMap = new Set();
+    const shapesSeen = new Set();
+    const collectLeaves = (schema) => {
+        const shapeName = (0, refs_1.getRefShapeName)(projectSchema, schema);
+        schema = shapeName ? (0, refs_1.followRef)(projectSchema, schema) : schema;
+        const key = (0, schema_util_1.getStorageKey)(schema);
+        if (key && isLeafTypeV3(projectSchema, schema)) {
+            leafMap.add(key);
+        }
+        if (shapeName) {
+            // Skip shapes we have already seen to avoid cycles
+            if (shapesSeen.has(shapeName)) {
+                return;
+            }
+            shapesSeen.add(shapeName);
+        }
+        const combo = schema.oneOf ?? schema.allOf;
+        if (combo) {
+            combo.map(collectLeaves);
+        }
+        else if (schema.properties) {
+            for (const name of Object.keys(schema.properties)) {
+                collectLeaves(schema.properties[name]);
+            }
+        }
+        else if (schema.items) {
+            collectLeaves(schema.items);
+        }
+    };
+    collectLeaves(shapeSchema);
+    return (key) => {
+        // Remove locale suffix
+        key = key ? key.split(':')[0] : key;
+        return Boolean(key && leafMap.has(key));
+    };
+}
+exports.getIsLeaf = getIsLeaf;

package/dist/cjs/src/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./content-schema-transform"), exports);
+__exportStar(require("./get-is-leaf"), exports);
+__exportStar(require("./project-schema"), exports);
+__exportStar(require("./project-schema/migrate"), exports);
+__exportStar(require("./schema-util"), exports);
+__exportStar(require("./template-shapes"), exports);
+__exportStar(require("./taxonomies"), exports);
+__exportStar(require("./workflows"), exports);
+__exportStar(require("./auth-schemas"), exports);
+__exportStar(require("./api-version"), exports);
+__exportStar(require("./migration"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./builtin-schema"), exports);
+__exportStar(require("./versions"), exports);
+__exportStar(require("./mocks"), exports);
+__exportStar(require("./scalars"), exports);
+__exportStar(require("./refs"), exports);
+__exportStar(require("./unions"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./patterns"), exports);
+__exportStar(require("./types/transforms"), exports);
+__exportStar(require("./types/types"), exports);
+__exportStar(require("./types/utils"), exports);
+__exportStar(require("./flatten-templates"), exports);
+__exportStar(require("./relationships"), exports);
+__exportStar(require("./create-input-schema"), exports);
+__exportStar(require("./schema-transform"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./agents"), exports);
+__exportStar(require("./services/services"), exports);
+__exportStar(require("./services/util"), exports);
+__exportStar(require("./services/types"), exports);
+__exportStar(require("./util/api-indexing"), exports);
+__exportStar(require("./util/form-config"), exports);
+__exportStar(require("./util/ai-tools"), exports);
+__exportStar(require("./util/detect-cycles"), exports);
+__exportStar(require("./util/find-shape-at-path"), exports);
+__exportStar(require("./util/get-conflicting-properties"), exports);
+__exportStar(require("./util/get-return-shape"), exports);
+__exportStar(require("./util/has-arg"), exports);
+__exportStar(require("./util/merge"), exports);
+__exportStar(require("./util/patch-schema"), exports);
+__exportStar(require("./util/shapes"), exports);
+__exportStar(require("./constants"), exports);

package/dist/cjs/src/interfaces.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPossibleShapeNames = exports.interfaceToUnion = exports.getImplementingShapes = exports.pruneUnusedInterfaces = exports.getImplementationShapeNameMap = exports.getImplementationShapeMap = exports.isInterfaceRef = exports.isInterfaceShape = void 0;
+const mapValues_js_1 = __importDefault(require("lodash/mapValues.js"));
+const util_1 = require("@takeshape/util");
+const refs_1 = require("./refs");
+const unions_1 = require("./unions");
+function isInterfaceShape(shape) {
+    return shape?.type === 'interface';
+}
+exports.isInterfaceShape = isInterfaceShape;
+function isInterfaceRef(context, propertySchema) {
+    const ref = (0, refs_1.getRef)(context, propertySchema);
+    return Boolean(ref && isInterfaceShape((0, refs_1.refItemToShape)(context, ref)));
+}
+exports.isInterfaceRef = isInterfaceRef;
+function add(record, key, value) {
+    if (!record[key]) {
+        record[key] = new Set([value]);
+    }
+    else {
+        record[key].add(value);
+    }
+}
+function getImplementationsHelper(shapeMap, mapFn) {
+    const result = {};
+    for (const shape of Object.values(shapeMap)) {
+        for (const interfaceName of shape.interfaces ?? []) {
+            add(result, interfaceName, mapFn(shape));
+        }
+    }
+    return result;
+}
+function getImplementationShapeMap(shapeMap) {
+    return getImplementationsHelper(shapeMap, x => x);
+}
+exports.getImplementationShapeMap = getImplementationShapeMap;
+function getImplementationShapeNameMap(shapeMap) {
+    return getImplementationsHelper(shapeMap, shape => shape.name);
+}
+exports.getImplementationShapeNameMap = getImplementationShapeNameMap;
+function pruneUnusedInterfaces(projectSchema, shapeMap) {
+    return (0, mapValues_js_1.default)(shapeMap, shape => {
+        const { interfaces } = shape;
+        if (interfaces?.length) {
+            const filteredInterfaces = interfaces.filter(refExpression => shapeMap[(0, refs_1.refItemToNamespacedShapeName)((0, refs_1.refExpressionToRefItem)(projectSchema, refExpression))]);
+            if (interfaces.length !== filteredInterfaces.length) {
+                return { ...shape, interfaces: filteredInterfaces };
+            }
+        }
+        return shape;
+    });
+}
+exports.pruneUnusedInterfaces = pruneUnusedInterfaces;
+function compareRefItems(refItem1, refItem2) {
+    return refItem1.typeName === refItem2.typeName && refItem1.serviceKey === refItem2.serviceKey;
+}
+function getImplementingShapes(context, interfaceRef) {
+    const shapeMap = context.shapes;
+    const implementingShapes = [];
+    for (const shape of Object.values(shapeMap)) {
+        if (shape.interfaces?.find(interfaceRefExpression => compareRefItems((0, refs_1.refExpressionToRefItem)(context, interfaceRefExpression), interfaceRef))) {
+            implementingShapes.push(shape);
+        }
+    }
+    return implementingShapes;
+}
+exports.getImplementingShapes = getImplementingShapes;
+function interfaceToUnion(context, interfaceRef) {
+    const shapes = getImplementingShapes(context, interfaceRef);
+    return {
+        oneOf: shapes.map(shape => ({ '@ref': (0, refs_1.normalizeRefExpression)(context, shape.name) }))
+    };
+}
+exports.interfaceToUnion = interfaceToUnion;
+function getPossibleShapeNames(projectSchema, shape) {
+    let names;
+    if (isInterfaceShape(shape)) {
+        names = getImplementingShapes(projectSchema, (0, refs_1.shapeToRefItem)(projectSchema, shape)).map(shape => shape.name);
+    }
+    else if ((0, unions_1.isUnionSchema)(shape.schema)) {
+        names = shape.schema.oneOf
+            .map(member => {
+            const ref = (0, refs_1.getRef)(projectSchema, member);
+            return ref && (0, refs_1.refItemToNamespacedShapeName)(ref);
+        })
+            .filter(util_1.isDefined);
+    }
+    else {
+        names = [shape.name];
+    }
+    return names;
+}
+exports.getPossibleShapeNames = getPossibleShapeNames;