@takeshape/schema 11.52.0 → 11.55.0

package/dist/cjs/src/relationships.js

@@ -1,326 +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.getRelationshipSchema = getRelationshipSchema;
-exports.getRelationshipShapeRefs = getRelationshipShapeRefs;
-exports.getRelationshipShapes = getRelationshipShapes;
-exports.getRelationshipShapeIds = getRelationshipShapeIds;
-exports.getLegacyRelationship = getLegacyRelationship;
-exports.getRelationship = getRelationship;
-exports.findExistingRelationships = findExistingRelationships;
-exports.isEqualRelationship = isEqualRelationship;
-exports.hasUnequalRelationships = hasUnequalRelationships;
-exports.addRelatedFields = addRelatedFields;
-const util_1 = require("@takeshape/util");
-const camelCase_js_1 = __importDefault(require("lodash/camelCase.js"));
-const find_js_1 = __importDefault(require("lodash/find.js"));
-const uniq_js_1 = __importDefault(require("lodash/uniq.js"));
-const builtin_schema_1 = require("./builtin-schema");
-const refs_1 = require("./refs");
-const types_1 = require("./types");
-const unions_1 = require("./unions");
-const shapes_1 = require("./util/shapes");
-/**
- * Turn a LegacyRelationship into a partial PropertySchemaWithRelationship.
- */
-function getRelationshipSchema(projectSchema, relationship) {
-    const propertySchema = {
-        '@args': 'TSRelationshipArgs',
-        '@resolver': {
-            name: 'shapedb:getRelated',
-            service: 'shapedb',
-            options: {
-                nullable: true
-            }
-        }
-    };
-    let isMultiple;
-    let shapeRefs;
-    if ('shapeIds' in relationship) {
-        shapeRefs = relationship.shapeIds
-            .map((shapeId) => {
-            const shape = (0, shapes_1.getShapeById)(projectSchema, shapeId) ?? (0, find_js_1.default)(builtin_schema_1.builtInShapes, (shape) => shape.id === shapeId);
-            return (shape && {
-                '@ref': `local:${shape.name}`
-            });
-        })
-            .filter(util_1.isDefined);
-        isMultiple = relationship.type === 'multiple';
-    }
-    else {
-        shapeRefs = relationship.refs.map((refStr) => ({ '@ref': refStr }));
-        isMultiple = relationship.isMultiple;
-    }
-    if (!shapeRefs.length) {
-        throw new Error(`Invalid empty relationship ${JSON.stringify(relationship)}`);
-    }
-    const shapeRefsSchema = shapeRefs.length === 1 ? shapeRefs[0] : { oneOf: shapeRefs };
-    if (isMultiple) {
-        return {
-            ...propertySchema,
-            type: 'array',
-            items: shapeRefsSchema,
-            '@input': {
-                type: 'array',
-                items: {
-                    '@ref': 'local:TSRelationship'
-                }
-            }
-        };
-    }
-    return {
-        ...propertySchema,
-        ...shapeRefsSchema,
-        '@input': {
-            '@ref': 'local:TSRelationship'
-        }
-    };
-}
-/**
- * Get a list of refs given a property schema with a relationship resolver.
- */
-function getRelationshipShapeRefs(propertySchema) {
-    let refs = [];
-    const schema = propertySchema.items ?? propertySchema;
-    if (schema.oneOf) {
-        refs = schema.oneOf.map((schema) => schema['@ref']).filter(util_1.isDefined);
-    }
-    else if (schema['@ref']) {
-        refs = [schema['@ref']];
-    }
-    return refs;
-}
-/**
- * Get a list of shapes given a property schema with a relationship resolver.
- */
-function getRelationshipShapes(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(':')[1];
-        const shape = shapes[shapeName];
-        return shape ? shape : undefined;
-    })
-        .filter(util_1.isDefined);
-}
-/**
- * Get a list of shape ids given a property schema with a relationship resolver.
- */
-function getRelationshipShapeIds(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(':')[1];
-        const shape = shapes[shapeName];
-        return shape ? shape.id : undefined;
-    })
-        .filter(util_1.isDefined);
-}
-/**
- * Turn a Relationship into a LegacyRelationship object.
- */
-function getLegacyRelationship(projectSchema, relationship) {
-    return {
-        type: relationship.isMultiple ? 'multiple' : 'single',
-        shapeIds: getRelationshipShapeIds(projectSchema.shapes, relationship.refs)
-    };
-}
-/**
- * Get relationship details from a PropertySchema.
- */
-function getRelationship(propertySchema) {
-    propertySchema = propertySchema['@output'] ?? propertySchema;
-    if (!(0, types_1.isPropertySchemaWithRelationship)(propertySchema)) {
-        return;
-    }
-    const isMultiple = propertySchema.type === 'array';
-    const hasBackreference = Boolean(propertySchema['@backreference']?.enabled);
-    const backreferenceName = propertySchema['@backreference']?.name;
-    const refs = getRelationshipShapeRefs(propertySchema);
-    return {
-        isMultiple,
-        refs,
-        hasBackreference,
-        backreferenceName
-    };
-}
-function addRelationship(relationships, id, env) {
-    relationships[id] ||= [];
-    relationships[id].push(env);
-}
-function findExistingRelationships(projectSchema, shapes) {
-    const relationships = {};
-    const shapeArray = Object.values(shapes);
-    const shapesSeen = new Set();
-    const shapeIds = new Set(shapeArray.map((shape) => shape.id));
-    const findRelationships = (schema, path, parentShapeName) => {
-        const relationship = getRelationship(schema);
-        if (relationship) {
-            const relatedShapeIds = getRelationshipShapeIds(shapes, relationship.refs);
-            const relatedName = schema['@backreference']?.name;
-            for (const shapeId of relatedShapeIds) {
-                if (shapeIds.has(shapeId)) {
-                    addRelationship(relationships, shapeId, {
-                        relatedName,
-                        path: path.slice(1),
-                        shapeId: path[0],
-                        hasBackreference: Boolean(schema['@backreference']?.enabled),
-                        schema,
-                        shapeName: parentShapeName
-                    });
-                }
-            }
-        }
-        const shapeName = (0, refs_1.getRefShapeName)(projectSchema, schema);
-        if (shapeName && !shapes[shapeName]) {
-            return;
-        }
-        const prop = shapeName ? (0, refs_1.followRef)(projectSchema, schema) : schema;
-        if (shapeName) {
-            // Skip shapes we have already seen to avoid cycles
-            if (shapesSeen.has(shapeName)) {
-                return;
-            }
-            shapesSeen.add(shapeName);
-        }
-        if (!relationship) {
-            if (prop.properties) {
-                for (const name of Object.keys(prop.properties)) {
-                    findRelationships(prop.properties[name], path.concat(name), shapeName ?? parentShapeName);
-                }
-            }
-            else if (prop.items) {
-                findRelationships(prop.items, path, shapeName ?? parentShapeName);
-            }
-            else if ((0, unions_1.isUnionSchema)(prop)) {
-                for (const child of prop.oneOf) {
-                    findRelationships(child, path, shapeName ?? parentShapeName);
-                }
-            }
-        }
-    };
-    for (const shape of shapeArray) {
-        if ((0, types_1.isModelShape)(shape)) {
-            const { schema, id, name } = shape;
-            findRelationships(schema, [id], name);
-        }
-    }
-    return relationships;
-}
-/**
- * Test whether two PropertySchemas have equal realtionships
- */
-function isEqualRelationship(a, b) {
-    const relationshipA = getRelationship(a);
-    const relationshipB = getRelationship(b);
-    // non-relationships are considered equal in that they are both equal that regard
-    if (!relationshipA && !relationshipB) {
-        return true;
-    }
-    const refsA = relationshipA?.refs;
-    if (!refsA) {
-        return false;
-    }
-    const refsB = relationshipB?.refs;
-    if (!refsB || refsA.length !== refsB.length) {
-        return false;
-    }
-    const refSet = new Set(refsA);
-    return refsB.every((ref) => refSet.has(ref));
-}
-/**
- * Test whether an array of PropertySchemas have unequal relationships
- */
-function hasUnequalRelationships(relationships) {
-    return Boolean(relationships.find((propertySchema, index, allRelationships) => {
-        const nextPropertySchema = allRelationships[index + 1];
-        return nextPropertySchema ? !isEqualRelationship(propertySchema, nextPropertySchema) : false;
-    }));
-}
-function getRelatedShapeIds(relationships) {
-    return (0, uniq_js_1.default)(relationships.map((rel) => (rel.hasBackreference ? rel.shapeId : undefined)).filter(util_1.isDefined));
-}
-function getShapes(projectSchema, shapeIds) {
-    return shapeIds.map((shapeId) => (0, shapes_1.getShapeById)(projectSchema, shapeId)).filter(util_1.isDefined);
-}
-/**
- * Adds backreference fields to the schema.
- */
-function addRelatedFields(projectSchema, allRelationships) {
-    for (const [shapeId, shapeRelationships] of Object.entries(allRelationships)) {
-        const shape = (0, shapes_1.getShapeById)(projectSchema, shapeId);
-        if (shape && (0, types_1.isObjectSchema)(shape.schema)) {
-            const relatedShapeIds = getRelatedShapeIds(shapeRelationships);
-            const relatedShapeNames = getShapes(projectSchema, relatedShapeIds).map((shape) => shape.name);
-            if (relatedShapeNames.length) {
-                let shapeName;
-                if (relatedShapeNames.length === 1) {
-                    // If only one back reference exists, _references is a regular shape
-                    shapeName = relatedShapeNames[0];
-                }
-                else {
-                    // If many back references exist, _references will be a union of referring shapes
-                    shapeName = `${shape.name}Reference`;
-                    projectSchema.shapes[shapeName] = {
-                        id: shapeName,
-                        name: shapeName,
-                        title: shapeName,
-                        schema: {
-                            oneOf: relatedShapeNames.map((name) => ({
-                                '@ref': `local:${name}`
-                            }))
-                        }
-                    };
-                }
-                // _references, a list of all backreferences across all fields on this shape.
-                // It lists all the items that have references to the current item.
-                // It is for convenience.
-                if (shapeRelationships.some((rel) => rel.hasBackreference)) {
-                    shape.schema.properties._references = {
-                        '@args': `TSListArgs<local:${shapeName}>`,
-                        '@ref': `PaginatedList<local:${shapeName}>`,
-                        '@resolver': {
-                            name: 'shapedb:list',
-                            service: 'shapedb',
-                            args: {
-                                ops: [
-                                    { path: '$', mapping: '$args' },
-                                    { path: 'baseWhere._references.eq', mapping: '$source._id' },
-                                    { path: 'baseWhere._shapeId.in', value: relatedShapeIds }
-                                ]
-                            }
-                        }
-                    };
-                }
-            }
-            // Create a schema for the backreference on the referred-to shape
-            for (const relationship of shapeRelationships) {
-                const relatedShape = (0, shapes_1.getShapeById)(projectSchema, relationship.shapeId);
-                if (relatedShape && relationship.hasBackreference) {
-                    const { relatedName } = relationship;
-                    const relatedFieldName = relatedName ? relatedName : `${(0, camelCase_js_1.default)(relatedShape.name)}Set`;
-                    const filterField = relatedName ? relationship.path.concat('_id').join('.') : '_references';
-                    shape.schema.properties[relatedFieldName] = {
-                        '@args': `TSListArgs<local:${relatedShape.name}>`,
-                        '@ref': `PaginatedList<local:${relatedShape.name}>`,
-                        '@resolver': {
-                            name: 'shapedb:list',
-                            service: 'shapedb',
-                            args: {
-                                ops: [
-                                    { path: '$', mapping: '$args' },
-                                    {
-                                        path: `baseWhere.${filterField}.eq`,
-                                        mapping: '$source._id'
-                                    },
-                                    { path: 'baseWhere._shapeId.eq', value: relatedShape.id }
-                                ]
-                            }
-                        }
-                    };
-                }
-            }
-        }
-    }
-    return projectSchema;
-}

package/dist/cjs/src/runtime-schema.js

@@ -1,88 +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.applyDefaultsAndFlatten = void 0;
-exports.applyLegacyCompatibilityTweaks = applyLegacyCompatibilityTweaks;
-exports.buildRuntimeSchema = buildRuntimeSchema;
-const errors_1 = require("@takeshape/errors");
-const util_1 = require("@takeshape/util");
-const compose_js_1 = __importDefault(require("lodash/fp/compose.js"));
-const isError_js_1 = __importDefault(require("lodash/isError.js"));
-const set_js_1 = __importDefault(require("lodash/set.js"));
-const agents_1 = require("./agents");
-const flatten_templates_1 = require("./flatten-templates");
-const relationships_1 = require("./relationships");
-const schema_util_1 = require("./schema-util");
-const service_dependencies_1 = require("./service-dependencies");
-const types_1 = require("./types");
-function applyLegacyCompatibilityTweaks(projectSchema) {
-    const newSchema = (0, util_1.deepClone)(projectSchema);
-    let hasSearchableShapes = false;
-    for (const [shapeName, shape] of Object.entries(newSchema.shapes)) {
-        if ((0, types_1.isModelShape)(shape)) {
-            hasSearchableShapes = true;
-            // Magic _contentTypeId field used for V1 compatibility
-            (0, set_js_1.default)(shape, ['schema', 'properties', '_contentTypeId'], {
-                type: 'string'
-            });
-            (0, set_js_1.default)(shape, ['schema', 'properties', '_contentTypeName'], {
-                type: 'string'
-            });
-            if (shape.model?.type !== 'single') {
-                newSchema.queries[`search${shapeName}Index`] = {
-                    shape: `SearchResults<${shapeName}>`,
-                    resolver: {
-                        name: 'takeshape:search',
-                        service: 'takeshape',
-                        shapeName
-                    },
-                    args: `TSSearchArgs<${shapeName}>`
-                };
-            }
-        }
-        if (shapeName === 'Asset') {
-            // Magic s3Key field to provide V1 compatibility with old projects until the field is
-            // formally removed and users are notified
-            (0, set_js_1.default)(shape, ['schema', 'properties', 's3Key'], {
-                title: 's3 key',
-                type: 'string',
-                '@mapping': 'shapedb:Asset.Hk6FQuz5',
-                '@deprecationReason': 'Use path instead'
-            });
-        }
-    }
-    if (hasSearchableShapes) {
-        // A placeholder shape for the TSSearchable interface
-        newSchema.shapes.TSSearchable = (0, schema_util_1.createShape)('TSSearchable', {
-            type: 'object',
-            properties: {}
-        });
-        newSchema.queries.search = {
-            shape: 'SearchResults<TSSearchable>',
-            resolver: {
-                name: 'takeshape:search',
-                service: 'takeshape'
-            },
-            args: 'TSSearchArgs<TSSearchable>'
-        };
-    }
-    (0, relationships_1.addRelatedFields)(newSchema, (0, relationships_1.findExistingRelationships)(projectSchema, projectSchema.shapes));
-    return newSchema;
-}
-exports.applyDefaultsAndFlatten = (0, compose_js_1.default)(flatten_templates_1.flattenTemplates, applyLegacyCompatibilityTweaks, schema_util_1.applyDefaultsToSchema, agents_1.addAiQueries);
-function buildRuntimeSchema(projectSchema, serviceLayers, log) {
-    try {
-        const projectSchemaWithDependencies = (0, service_dependencies_1.resolveSchemaShapeDependencies)(projectSchema, serviceLayers);
-        return (0, exports.applyDefaultsAndFlatten)(projectSchemaWithDependencies);
-    }
-    catch (err) {
-        const error = new errors_1.SchemaBuildError('An error occurred while building the schema', {
-            cause: (0, isError_js_1.default)(err) ? err : undefined,
-            schema: projectSchema
-        });
-        log('build runtime error', error);
-        throw error;
-    }
-}

package/dist/cjs/src/scalars.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scalars = void 0;
-exports.isScalar = isScalar;
-exports.scalars = ['string', 'boolean', 'integer', 'number'];
-function isScalar(str) {
-    return Array.from(exports.scalars).includes(str);
-}

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

@@ -1,83 +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.wrapOneOfObjects = exports.unwrapOneOfObjects = void 0;
-exports.removePropertiesTransform = removePropertiesTransform;
-exports.toName = toName;
-exports.transformOneOf = transformOneOf;
-const util_1 = require("@takeshape/util");
-const pickBy_js_1 = __importDefault(require("lodash/pickBy.js"));
-const content_schema_transform_1 = require("./content-schema-transform");
-const types_1 = require("./types");
-const unions_1 = require("./unions");
-function createPropertiesPredicate(propertyNames) {
-    const byShape = new Map();
-    for (const name of propertyNames) {
-        const [shapeName, propName] = name.split('.');
-        const blacklist = byShape.get(shapeName);
-        if (!blacklist) {
-            byShape.set(shapeName, new Set([propName]));
-        }
-        else {
-            blacklist.add(propName);
-        }
-    }
-    return (shapeName, name) => {
-        const blacklist = byShape.get(byShape.has(shapeName) ? shapeName : '*');
-        return Boolean(blacklist?.has(name));
-    };
-}
-function removePropertiesTransform(propertyNames) {
-    const isBlacklisted = createPropertiesPredicate(propertyNames);
-    return (projectSchema) => {
-        (0, util_1.visit)(projectSchema, ['schema'], (value, path) => {
-            if (path.length === 3 && path[0] === 'shapes' && path[2] === 'schema') {
-                const shapeSchema = value;
-                if ((0, types_1.isObjectSchema)(shapeSchema)) {
-                    const { properties, required } = shapeSchema;
-                    shapeSchema.properties = (0, pickBy_js_1.default)(properties, (_, name) => !isBlacklisted(path[1], name));
-                    if (required) {
-                        shapeSchema.required = required.filter((name) => !isBlacklisted(path[1], name));
-                    }
-                }
-            }
-        });
-        return projectSchema;
-    };
-}
-function toName(name) {
-    return name;
-}
-function transformOneOf(process) {
-    return (projectSchema, schema, obj) => {
-        const transform = (0, content_schema_transform_1.getContentTransform)({
-            sourceKeyTransform: toName,
-            keyTransform: toName,
-            passThrough: true,
-            projectSchema,
-            transforms: {
-                '*': [
-                    {
-                        filter: unions_1.isUnionSchema,
-                        process: process(projectSchema)
-                    }
-                ]
-            }
-        });
-        return transform(schema, obj);
-    };
-}
-/**
- * Unwrap oneOf objects in "GraphQL oneOf" style wrapper objects
- * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
- * Opposite of `wrapOneOfObjects`
- */
-exports.unwrapOneOfObjects = transformOneOf(unions_1.createUnwrapTransform);
-/**
- * Wrap oneOf objects in "GraphQL oneOf" style wrapper objects
- * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
- * Opposite of `unwrapOneOfObjects`
- */
-exports.wrapOneOfObjects = transformOneOf(unions_1.createWrapTransform);