@takeshape/schema 11.52.0 → 11.56.1

package/dist/esm/src/relationships.js

@@ -1,311 +0,0 @@
-import { isDefined } from "@takeshape/util";
-import camelCase from "lodash/camelCase.js";
-import find from "lodash/find.js";
-import uniq from "lodash/uniq.js";
-import { builtInShapes } from "./builtin-schema.js";
-import { followRef, getRefShapeName } from "./refs.js";
-import { isModelShape, isObjectSchema, isPropertySchemaWithRelationship } from "./types/index.js";
-import { isUnionSchema } from "./unions.js";
-import { getShapeById } from "./util/shapes.js";
-/**
- * Turn a LegacyRelationship into a partial PropertySchemaWithRelationship.
- */
-export 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 = getShapeById(projectSchema, shapeId) ?? find(builtInShapes, (shape) => shape.id === shapeId);
-            return (shape && {
-                "@ref": `local:${shape.name}`
-            });
-        })
-            .filter(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.
- */
-export function getRelationshipShapeRefs(propertySchema) {
-    let refs = [];
-    const schema = propertySchema.items ?? propertySchema;
-    if (schema.oneOf) {
-        refs = schema.oneOf.map((schema) => schema["@ref"]).filter(isDefined);
-    }
-    else if (schema["@ref"]) {
-        refs = [schema["@ref"]];
-    }
-    return refs;
-}
-/**
- * Get a list of shapes given a property schema with a relationship resolver.
- */
-export function getRelationshipShapes(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(":")[1];
-        const shape = shapes[shapeName];
-        return shape ? shape : undefined;
-    })
-        .filter(isDefined);
-}
-/**
- * Get a list of shape ids given a property schema with a relationship resolver.
- */
-export function getRelationshipShapeIds(shapes, refs) {
-    return refs
-        .map((ref) => {
-        const shapeName = ref.split(":")[1];
-        const shape = shapes[shapeName];
-        return shape ? shape.id : undefined;
-    })
-        .filter(isDefined);
-}
-/**
- * Turn a Relationship into a LegacyRelationship object.
- */
-export function getLegacyRelationship(projectSchema, relationship) {
-    return {
-        type: relationship.isMultiple ? "multiple" : "single",
-        shapeIds: getRelationshipShapeIds(projectSchema.shapes, relationship.refs)
-    };
-}
-/**
- * Get relationship details from a PropertySchema.
- */
-export function getRelationship(propertySchema) {
-    propertySchema = propertySchema["@output"] ?? propertySchema;
-    if (!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);
-}
-export 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 = getRefShapeName(projectSchema, schema);
-        if (shapeName && !shapes[shapeName]) {
-            return;
-        }
-        const prop = shapeName ? 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 (isUnionSchema(prop)) {
-                for (const child of prop.oneOf) {
-                    findRelationships(child, path, shapeName ?? parentShapeName);
-                }
-            }
-        }
-    };
-    for (const shape of shapeArray) {
-        if (isModelShape(shape)) {
-            const { schema, id, name } = shape;
-            findRelationships(schema, [id], name);
-        }
-    }
-    return relationships;
-}
-/**
- * Test whether two PropertySchemas have equal realtionships
- */
-export 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
- */
-export 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 uniq(relationships.map((rel) => (rel.hasBackreference ? rel.shapeId : undefined)).filter(isDefined));
-}
-function getShapes(projectSchema, shapeIds) {
-    return shapeIds.map((shapeId) => getShapeById(projectSchema, shapeId)).filter(isDefined);
-}
-/**
- * Adds backreference fields to the schema.
- */
-export function addRelatedFields(projectSchema, allRelationships) {
-    for (const [shapeId, shapeRelationships] of Object.entries(allRelationships)) {
-        const shape = getShapeById(projectSchema, shapeId);
-        if (shape && 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 = getShapeById(projectSchema, relationship.shapeId);
-                if (relatedShape && relationship.hasBackreference) {
-                    const { relatedName } = relationship;
-                    const relatedFieldName = relatedName ? relatedName : `${camelCase(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/esm/src/runtime-schema.js

@@ -1,80 +0,0 @@
-import { SchemaBuildError } from "@takeshape/errors";
-import { deepClone } from "@takeshape/util";
-import compose from "lodash/fp/compose.js";
-import isError from "lodash/isError.js";
-import set from "lodash/set.js";
-import { addAiQueries } from "./agents.js";
-import { flattenTemplates } from "./flatten-templates.js";
-import { addRelatedFields, findExistingRelationships } from "./relationships.js";
-import { applyDefaultsToSchema, createShape } from "./schema-util.js";
-import { resolveSchemaShapeDependencies } from "./service-dependencies.js";
-import { isModelShape } from "./types/index.js";
-export function applyLegacyCompatibilityTweaks(projectSchema) {
-    const newSchema = deepClone(projectSchema);
-    let hasSearchableShapes = false;
-    for (const [shapeName, shape] of Object.entries(newSchema.shapes)) {
-        if (isModelShape(shape)) {
-            hasSearchableShapes = true;
-            // Magic _contentTypeId field used for V1 compatibility
-            set(shape, ["schema", "properties", "_contentTypeId"], {
-                type: "string"
-            });
-            set(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
-            set(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 = createShape("TSSearchable", {
-            type: "object",
-            properties: {}
-        });
-        newSchema.queries.search = {
-            shape: "SearchResults<TSSearchable>",
-            resolver: {
-                name: "takeshape:search",
-                service: "takeshape"
-            },
-            args: "TSSearchArgs<TSSearchable>"
-        };
-    }
-    addRelatedFields(newSchema, findExistingRelationships(projectSchema, projectSchema.shapes));
-    return newSchema;
-}
-export const applyDefaultsAndFlatten = compose(flattenTemplates, applyLegacyCompatibilityTweaks, applyDefaultsToSchema, addAiQueries);
-export function buildRuntimeSchema(projectSchema, serviceLayers, log) {
-    try {
-        const projectSchemaWithDependencies = resolveSchemaShapeDependencies(projectSchema, serviceLayers);
-        return applyDefaultsAndFlatten(projectSchemaWithDependencies);
-    }
-    catch (err) {
-        const error = new SchemaBuildError("An error occurred while building the schema", {
-            cause: isError(err) ? err : undefined,
-            schema: projectSchema
-        });
-        log("build runtime error", error);
-        throw error;
-    }
-}

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

@@ -1,74 +0,0 @@
-import { visit } from "@takeshape/util";
-import pickBy from "lodash/pickBy.js";
-import { getContentTransform } from "./content-schema-transform.js";
-import { isObjectSchema } from "./types/index.js";
-import { createUnwrapTransform, createWrapTransform, isUnionSchema } from "./unions.js";
-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));
-    };
-}
-export function removePropertiesTransform(propertyNames) {
-    const isBlacklisted = createPropertiesPredicate(propertyNames);
-    return (projectSchema) => {
-        visit(projectSchema, ["schema"], (value, path) => {
-            if (path.length === 3 && path[0] === "shapes" && path[2] === "schema") {
-                const shapeSchema = value;
-                if (isObjectSchema(shapeSchema)) {
-                    const { properties, required } = shapeSchema;
-                    shapeSchema.properties = pickBy(properties, (_, name) => !isBlacklisted(path[1], name));
-                    if (required) {
-                        shapeSchema.required = required.filter((name) => !isBlacklisted(path[1], name));
-                    }
-                }
-            }
-        });
-        return projectSchema;
-    };
-}
-export function toName(name) {
-    return name;
-}
-export function transformOneOf(process) {
-    return (projectSchema, schema, obj) => {
-        const transform = getContentTransform({
-            sourceKeyTransform: toName,
-            keyTransform: toName,
-            passThrough: true,
-            projectSchema,
-            transforms: {
-                "*": [
-                    {
-                        filter: 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`
- */
-export const unwrapOneOfObjects = transformOneOf(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`
- */
-export const wrapOneOfObjects = transformOneOf(createWrapTransform);