@takeshape/schema 11.40.0 → 11.40.3

package/dist/esm/src/relationships.js

@@ -0,0 +1,222 @@
+import { isDefined } from "@takeshape/util";
+import find from "lodash/find.js";
+import { isPropertySchemaWithRelationship, isModelShape } from "./types/index.js";
+import { getRefShapeName, followRef } from "./refs.js";
+import { isUnionSchema } from "./unions.js";
+import { builtInShapes } from "./builtin-schema.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;
+    }));
+}

package/dist/esm/src/scalars.js

@@ -0,0 +1,4 @@
+export const scalars = ['string', 'boolean', 'integer', 'number'];
+export function isScalar(str) {
+    return Array.from(scalars).includes(str);
+}

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

@@ -0,0 +1,74 @@
+import { visit } from "@takeshape/util";
+import pickBy from "lodash/pickBy.js";
+import { isObjectSchema } from "./types/index.js";
+import { createUnwrapTransform, createWrapTransform, isUnionSchema } from "./unions.js";
+import { getContentTransform } from "./content-schema-transform.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);