@takeshape/schema 11.40.0 → 11.41.0

package/dist/esm/src/template-shapes/where.js

@@ -0,0 +1,391 @@
+import unset from "lodash/unset.js";
+import isFunction from "lodash/isFunction.js";
+import uniqBy from "lodash/uniqBy.js";
+import md5 from "blueimp-md5";
+import { pascalCase, isDefined, formatShapeName } from "@takeshape/util";
+import { createSchemaPropertyList, createShape, getAllRefsInShapes } from "../schema-util.js";
+import { workflowsEnabled } from "../api-version.js";
+import { followRef, getRef, getRefOrItemsRef, hasRefProperty, hasResolvableRef, refItemToShape, refItemToNamespacedShapeName } from "../refs.js";
+import { enumerateOneOfKeys, isUnionSchema } from "../unions.js";
+import { isCachedShape, isObjectSchema, isPropertySchemaWithRelationship } from "../types/utils.js";
+import { isEqualRelationship, getRelationship, getRelationshipShapes } from "../relationships.js";
+export const MAX_RELATIONSHIP_DEPTH = 1;
+export const exceededRelationshipDepth = (depth = 0) => depth >= MAX_RELATIONSHIP_DEPTH;
+class ShapeCache {
+    thunks = new Map();
+    unresolved = new Set();
+    has(shapeName) {
+        return this.thunks.has(shapeName);
+    }
+    set(shapeName, thunk) {
+        this.thunks.set(shapeName, thunk);
+        if (isFunction(thunk)) {
+            this.unresolved.add(shapeName);
+        }
+    }
+    resolveAll() {
+        while (this.unresolved.size) {
+            const shapeName = this.unresolved.values().next().value;
+            const thunk = this.thunks.get(shapeName);
+            if (isFunction(thunk)) {
+                this.thunks.set(shapeName, thunk());
+                this.unresolved.delete(shapeName);
+            }
+        }
+        const result = {};
+        for (const [shapeName, shape] of this.thunks) {
+            result[shapeName] = shape;
+        }
+        return result;
+    }
+}
+export const fieldTypeComparison = {
+    id: { comparators: ["eq", "in"], type: "string" },
+    boolean: { comparators: ["eq"], type: "boolean" },
+    string: { comparators: ["eq", "in", "match", "regexp"], type: "string" },
+    date: { comparators: ["eq", "lt", "lte", "gt", "gte"], type: "string" },
+    number: { comparators: ["eq", "lt", "lte", "gt", "gte", "in"], type: "number" },
+    integer: { comparators: ["eq", "lt", "lte", "gt", "gte", "in"], type: "integer" },
+    workflow: { comparators: ["eq", "lt", "lte", "gt", "gte", "in"], type: "string" },
+    draftjs: { comparators: ["match"], type: "string" },
+    mdx: { comparators: ["match"], type: "string" }
+};
+export const comparatorDescriptions = {
+    eq: "Exact match",
+    gt: "Greater than",
+    gte: "Greater than or equal",
+    lt: "Less than",
+    lte: "Less than or equal",
+    in: "Array of possible exact match values.",
+    match: "Full text searching with fuzzy matching.",
+    regexp: "Regular expression string matching. Use of * wildcards could degrade performance."
+};
+export const booleanOperators = ["AND", "OR", "NOT"];
+export const boolOpDescriptionMap = {
+    AND: "AND takes an array of conditions that must appear in the matching results. Nested boolean operators can be used to create complex filters.",
+    OR: "OR takes an array of conditions that should appear in the matching results. Nested boolean operators can be used to create complex filters.",
+    NOT: "NOT takes a single condition that must not appear in the matching results."
+};
+function getConflictingProperties(projectSchema, shapes) {
+    const conflicts = new Set();
+    const allProps = {};
+    for (const shape of Object.values(shapes)) {
+        for (const [name, prop] of createSchemaPropertyList(projectSchema, shape).getNodes()) {
+            if (name in allProps && (allProps[name].type !== prop.type || !isEqualRelationship(allProps[name], prop))) {
+                conflicts.add(name);
+            }
+        }
+        if (isObjectSchema(shape.schema)) {
+            Object.assign(allProps, shape.schema.properties);
+        }
+    }
+    return conflicts;
+}
+export function getFieldTypeComparison(fieldType) {
+    const comparison = fieldTypeComparison[fieldType];
+    if (!comparison) {
+        return undefined;
+    }
+    const { comparators, type } = comparison;
+    const result = {};
+    for (const op of comparators) {
+        const description = comparatorDescriptions[op];
+        result[op] = op === "in" ? { type: "array", items: { type }, description } : { description, type };
+    }
+    return result;
+}
+function isId(name) {
+    return name === "_id" || name === "_contentTypeId" || name === "_shapeId";
+}
+function isNonRelationshipRef(prop) {
+    return Boolean(hasRefProperty(prop) && !getRelationship(prop));
+}
+function getPropType(projectSchema, name, prop) {
+    if (prop["@workflow"]) {
+        return "workflow";
+    }
+    if (prop["@tag"] === "draftjs") {
+        return "draftjs";
+    }
+    if (prop["@tag"] === "mdx") {
+        return "mdx";
+    }
+    if (prop.format === "date-time") {
+        return "date";
+    }
+    if (isId(name)) {
+        return "id";
+    }
+    if (isNonRelationshipRef(prop)) {
+        const followed = followRef(projectSchema, prop);
+        if (followed.enum) {
+            return "string";
+        }
+        return "object";
+    }
+    return prop.type;
+}
+function truncateNames(names) {
+    // For unions of many types hash the names this reduces shape name size while still allowing reuse
+    return names.length > 80 ? md5(names) : names;
+}
+/**
+ * Get a formatted string of related shape names from a property schema with a
+ * relationship resolver
+ */
+function getRelationshipShapeName(refs) {
+    return refs
+        .map(ref => {
+        const shapeName = ref.split(":")[1];
+        return formatShapeName(shapeName);
+    })
+        .sort()
+        .join("");
+}
+function joinShapeNames(shapes) {
+    return shapes.sort().join("");
+}
+function getTypeName(name, prop, shapeName, context) {
+    const { projectSchema, relationshipDepth, conflictingProperties } = context;
+    let type = getPropType(projectSchema, name, prop);
+    if (isId(name)) {
+        return `TSWhereID`;
+    }
+    const relationship = getRelationship(prop);
+    if (relationship) {
+        const relationshipName = getRelationshipShapeName(relationship.refs);
+        if (!relationshipName) {
+            throw new Error(`Relationship property "${prop.title ?? ""}" is missing related shapes`);
+        }
+        const shapeNames = truncateNames(relationshipName);
+        return `TSWhere${shapeNames}Relationship`;
+    }
+    if (isUnionSchema(prop)) {
+        if (prop.oneOf.length > 1) {
+            const shapeNames = truncateNames(joinShapeNames(enumerateOneOfKeys(projectSchema, prop.oneOf).map(child => child.shapeName)));
+            return `TSWhere${shapeNames}Union`;
+        }
+        type = "object";
+        prop = prop.oneOf[0];
+    }
+    if (type === "object" || type === "array") {
+        const prefix = `TS${relationshipDepth >= MAX_RELATIONSHIP_DEPTH ? "Shallow" : ""}Where`;
+        const fieldName = `${conflictingProperties?.has(name) ? "_" : ""}${formatShapeName(name)}`;
+        const refItem = getRefOrItemsRef(projectSchema, prop);
+        const suffix = refItem ? refItemToNamespacedShapeName(refItem) : `${shapeName}${fieldName}`;
+        return `${prefix}${suffix}`;
+    }
+    return `TSWhere${pascalCase(type)}`;
+}
+function skipField({ name, prop, workflowsEnabled, exceededRelationshipDepth, isIndexedShape }) {
+    const isRelationship = isPropertySchemaWithRelationship(prop);
+    return Boolean(prop["@sensitive"] ??
+        (Boolean(prop["@resolver"] && !isIndexedShape && !isRelationship) ||
+            Boolean(isRelationship && exceededRelationshipDepth) ||
+            Boolean((name === "_enabled" || name === "_enabledAt") && workflowsEnabled)));
+}
+export function getFields(typeName, shapes, context) {
+    const { relationshipDepth, booleanOperators, projectSchema } = context;
+    const result = {};
+    const tooDeep = exceededRelationshipDepth(relationshipDepth);
+    const conflictingProperties = shapes.length ? getConflictingProperties(projectSchema, shapes) : undefined;
+    const fieldContext = { ...context, conflictingProperties };
+    for (const shape of shapes) {
+        const nodes = createSchemaPropertyList(projectSchema, shape)
+            .filterBy(([name, prop]) => !skipField({
+            name,
+            prop,
+            workflowsEnabled: workflowsEnabled(projectSchema.apiVersion),
+            isIndexedShape: isCachedShape(shape),
+            exceededRelationshipDepth: exceededRelationshipDepth(relationshipDepth)
+        }))
+            .getNodes();
+        for (const [name, property] of nodes) {
+            Object.assign(result, getPropertyComparisonType(name, property, shape.name, fieldContext));
+        }
+    }
+    return tooDeep || booleanOperators === false ? result : Object.assign(result, getBooleanOperatorTypes(typeName));
+}
+function getBooleanOperatorTypes(typeName) {
+    const result = {};
+    for (const op of booleanOperators) {
+        const refSchema = { "@ref": `local:${typeName}` };
+        result[op] = op === "NOT" ? refSchema : { type: "array", items: refSchema };
+    }
+    return result;
+}
+export function getPropertyComparisonType(name, prop, shapeName, context) {
+    const { shapeCache, projectSchema, relationshipDepth, conflictingProperties } = context;
+    if (skipField({
+        name,
+        prop,
+        workflowsEnabled: workflowsEnabled(projectSchema.apiVersion),
+        isIndexedShape: isCachedShape(projectSchema.shapes[shapeName]),
+        exceededRelationshipDepth: exceededRelationshipDepth(relationshipDepth)
+    })) {
+        return undefined;
+    }
+    const fieldType = getPropType(projectSchema, name, prop) ?? "string";
+    const typeName = getTypeName(name, prop, shapeName, context);
+    const relationship = getRelationship(prop);
+    if (hasRefProperty(prop.items ?? prop)) {
+        if (!hasResolvableRef(projectSchema, prop.items ?? prop)) {
+            return undefined;
+        }
+        if (prop.items) {
+            prop = { ...prop, items: followRef(projectSchema, prop.items) };
+        }
+        else {
+            prop = followRef(projectSchema, prop);
+        }
+    }
+    if (!shapeCache.has(typeName) && !projectSchema.shapes[typeName]) {
+        shapeCache.set(typeName, () => {
+            let props;
+            const propOrItems = prop.items ?? prop;
+            if (isId(name)) {
+                props = getFieldTypeComparison("id");
+            }
+            else if (relationship) {
+                const shapes = getRelationshipShapes(projectSchema.shapes, relationship.refs);
+                props = getFields(typeName, shapes, {
+                    ...context,
+                    relationshipDepth: relationshipDepth + 1
+                });
+            }
+            else if (isUnionSchema(propOrItems)) {
+                const shapes = enumerateOneOfKeys(projectSchema, propOrItems.oneOf).map(option => projectSchema.shapes[option.shapeName]);
+                props = getFields(typeName, shapes, {
+                    ...context,
+                    booleanOperators: false
+                });
+            }
+            else if (fieldType === "object" || (fieldType === "array" && prop.items?.type === "object")) {
+                const properties = prop.items?.properties ?? prop.properties;
+                if (properties) {
+                    props ??= {};
+                    const fieldContext = {
+                        ...context,
+                        conflictingProperties: undefined // non-union objects have no conflicts
+                    };
+                    for (const propName of Object.keys(properties)) {
+                        Object.assign(props, getPropertyComparisonType(propName, properties[propName], shapeName, fieldContext));
+                    }
+                }
+            }
+            else {
+                // Treat non-object arrays as their base type
+                let type;
+                if (typeof prop.items?.type === "string") {
+                    type = prop.items.type;
+                }
+                else {
+                    type = fieldType;
+                }
+                props = getFieldTypeComparison(type);
+            }
+            return createShape(typeName, {
+                type: "object",
+                properties: props ?? {}
+            });
+        });
+    }
+    if (shapeCache.has(typeName) || projectSchema.shapes[typeName]) {
+        const fieldName = `${conflictingProperties?.has(name) ? `${shapeName}_` : ""}${name}`;
+        return {
+            [fieldName]: {
+                "@ref": `local:${typeName}`
+            }
+        };
+    }
+}
+function findEmpty(shapes) {
+    const empty = new Set();
+    for (const [shapeName, shape] of Object.entries(shapes)) {
+        if (isObjectSchema(shape.schema) && Object.keys(shape.schema.properties).length === 0) {
+            empty.add(shapeName);
+        }
+    }
+    return empty;
+}
+function getRefSummary(shapes) {
+    const result = {};
+    for (const ref of getAllRefsInShapes({ shapes, services: {} })) {
+        const path = ref.path.slice(1, ref.path.length - 1);
+        if (result[ref.typeName]) {
+            result[ref.typeName].push(path);
+        }
+        else {
+            result[ref.typeName] = [path];
+        }
+    }
+    return result;
+}
+function pruneEmpty(shapes) {
+    let toPrune = findEmpty(shapes);
+    if (toPrune.size) {
+        const refSummary = getRefSummary(shapes);
+        while (toPrune.size) {
+            for (const shapeName of toPrune) {
+                unset(shapes, shapeName);
+                for (const path of refSummary[shapeName] ?? []) {
+                    unset(shapes, path);
+                }
+            }
+            toPrune = findEmpty(shapes);
+        }
+    }
+    return shapes;
+}
+function getReferencedShape(context) {
+    return (prop) => {
+        const ref = getRef(context, prop);
+        return ref && refItemToShape(context, ref);
+    };
+}
+/**
+ * Expand union shapes
+ */
+function expandUnionShapes(projectSchema, shapes) {
+    return uniqBy(shapes.flatMap(shape => isUnionSchema(shape.schema) ? shape.schema.oneOf.map(getReferencedShape(projectSchema)).filter(isDefined) : shape), "name");
+}
+export function getWhereShape(projectSchema, selectedShapes) {
+    const shapeName = selectedShapes.length === 1 ? `TSWhere${pascalCase(selectedShapes[0].name)}Input` : "TSWhereInput";
+    if (projectSchema.shapes[shapeName]) {
+        return { shapeName, dependencies: {} };
+    }
+    const expandedShapes = expandUnionShapes(projectSchema, selectedShapes);
+    const isManyContentTypes = expandedShapes.length > 1;
+    const shapeCache = new ShapeCache();
+    const fields = getFields(shapeName, expandedShapes, {
+        projectSchema,
+        shapeCache,
+        relationshipDepth: 0
+    });
+    return {
+        shapeName,
+        dependencies: pruneEmpty({
+            [shapeName]: createShape(shapeName, {
+                type: "object",
+                properties: {
+                    ...fields,
+                    ...(isManyContentTypes && getBooleanOperatorTypes(shapeName))
+                }
+            }),
+            ...shapeCache.resolveAll()
+        })
+    };
+}
+export function getWhereSearchArg(projectSchema, selectedShapes) {
+    const { shapeName, dependencies } = getWhereShape(projectSchema, selectedShapes);
+    const schema = {
+        type: "object",
+        properties: {
+            where: {
+                "@ref": `local:${shapeName}`,
+                description: "The where clause uses the boolean AND, OR, and NOT parameters to construct complex filters based on the values of your fields. It applies an implicit AND to all the top-level keys. To avoid this, use a single OR or NOT key as the only top-level key."
+            }
+        }
+    };
+    return { schema, dependencies };
+}

package/dist/esm/src/types/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./transforms.js";

package/dist/esm/src/types/transforms.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/types/types.js

@@ -0,0 +1,18 @@
+export const projectSchemaImportOptionalProps = ['projectId', 'locales', 'defaultLocale', 'author'];
+export const legacyProjectSchemaImportOptionalProps = ['created', 'updated', 'version', 'dataKey'];
+/**
+ * Types of refs
+ */
+export var RefType;
+(function (RefType) {
+    RefType["@ref"] = "@ref";
+    RefType["$ref"] = "$ref";
+})(RefType || (RefType = {}));
+/**
+ * Types of args
+ */
+export var ArgsType;
+(function (ArgsType) {
+    ArgsType["@args"] = "@args";
+    ArgsType["args"] = "args";
+})(ArgsType || (ArgsType = {}));

package/dist/esm/src/types/utils.js

@@ -0,0 +1,279 @@
+import { isRecord } from "@takeshape/util";
+import isPlainObject from "lodash/isPlainObject.js";
+import isString from "lodash/isString.js";
+import isArray from "lodash/isArray.js";
+import has from "lodash/has.js";
+import isUndefined from "lodash/isUndefined.js";
+import { latestSchemaJson } from "../schemas/index.js";
+import { ArgsType, RefType } from "./types.js";
+/** Resolver Type Utils **/
+/**
+ * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
+ */
+export function isBasicResolver(resolver) {
+    return isRecord(resolver) && isString(resolver.name);
+}
+export function isServiceResolver(resolver) {
+    return isRecord(resolver) && isString(resolver.name) && isString(resolver.service);
+}
+export function isComposeResolver(resolver) {
+    return Boolean(isArray(resolver?.compose) &&
+        resolver.compose.length &&
+        resolver.compose.every(isBasicResolver));
+}
+const { definitions: { takeshapeResolver, shapedbResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = latestSchemaJson;
+export function isTakeshapeResolver(resolver) {
+    return isBasicResolver(resolver) && takeshapeResolver.properties.name.enum.includes(resolver.name);
+}
+export function isShapedbResolver(resolver) {
+    return isBasicResolver(resolver) && shapedbResolver.properties.name.enum.includes(resolver.name);
+}
+export function isGraphqlResolver(resolver) {
+    return isBasicResolver(resolver) && graphqlResolver.properties.name.enum.includes(resolver.name);
+}
+export function isRestResolver(resolver) {
+    return isBasicResolver(resolver) && restResolver.properties.name.enum.includes(resolver.name);
+}
+export function isAwsLambdaResolver(resolver) {
+    return isBasicResolver(resolver) && awsLambdaResolver.properties.name.enum.includes(resolver.name);
+}
+export function isUtilResolver(resolver) {
+    return isBasicResolver(resolver) && utilResolver.properties.name.enum.includes(resolver.name);
+}
+export const aiResolverNames = ["ai:generateText", "ai:chat"];
+export function isAIResolverName(name) {
+    return name ? aiResolverNames.includes(name) : false;
+}
+export function isAIResolver(resolver) {
+    return isBasicResolver(resolver) && isAIResolverName(resolver.name);
+}
+export function isAIAgentStateExecution(agentExecution) {
+    return agentExecution.type === "generate" || agentExecution.type === "chat";
+}
+export function isProjectSchemaWithServices(schema) {
+    return !isUndefined(schema.services);
+}
+export function containsResolver(resolver, predicate) {
+    if (isBasicResolver(resolver)) {
+        return predicate(resolver);
+    }
+    return Boolean(resolver.compose.find(resolver => containsResolver(resolver, predicate)));
+}
+/** Directive Mapping Utils **/
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
+ */
+export function isDirectiveMappingMap(maybeMap) {
+    return isPlainObject(maybeMap) && Object.keys(maybeMap).length > 0;
+}
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
+ */
+export function isDirectiveMappingArray(maybeArray) {
+    return isArray(maybeArray) && isArray(maybeArray[0]) && isString(maybeArray[0][0]) && isArray(maybeArray[0][1]);
+}
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveConfig array
+ */
+export function isDirectiveConfig(maybeConfig) {
+    return isArray(maybeConfig) && isArray(maybeConfig[0]) && isString(maybeConfig[0][0]) && isRecord(maybeConfig[0][1]);
+}
+/**
+ * Determine whether a ParameterSerializeOption is a content type serializer
+ */
+export function isParameterSerializeContentOptions(maybeContent) {
+    return Boolean(maybeContent.contentType);
+}
+/**
+ * Determine whether an unknown variable is a `ParameterOp`
+ */
+export function isParameterOp(maybeOp) {
+    const op = maybeOp;
+    if (!op.path) {
+        return false;
+    }
+    return isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op) || isParameterOpOp(op);
+}
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpNested`
+ */
+export function isParameterOpNested(maybeOp) {
+    return Boolean(maybeOp.ops);
+}
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+export function isParameterOpMapping(maybeOp) {
+    return Boolean(maybeOp.mapping);
+}
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpValue`
+ */
+export function isParameterOpValue(maybeOp) {
+    return Boolean(maybeOp.value);
+}
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpOp`
+ */
+export function isParameterOpOp(maybeOp) {
+    const op = maybeOp;
+    if (!op.op) {
+        return false;
+    }
+    return !(isParameterOpNested(op) || isParameterOpMapping(op) || isParameterOpValue(op));
+}
+const { definitions: { parameterSerializeStyleOptionsForSearchParams, parameterSerializeStyleOptionsForPathParams } } = latestSchemaJson;
+export function isParameterSerializeStyleForSearchParams(maybeParam) {
+    return Boolean(maybeParam && parameterSerializeStyleOptionsForSearchParams.properties.style.enum.includes(maybeParam));
+}
+export function isParameterSerializeStyleForPathParams(maybeParam) {
+    return Boolean(maybeParam && parameterSerializeStyleOptionsForPathParams.properties.style.enum.includes(maybeParam));
+}
+/**
+ * Determine whether a ParameterSerializeOption is a style serializer
+ */
+export function isParameterSerializeStyleOptions(maybeStyle) {
+    return Boolean(maybeStyle.style);
+}
+/** Typeguards for different types of shape schemas **/
+export function isRefSchema(propertySchema) {
+    return isString(propertySchema["@ref"]) || isString(propertySchema.$ref);
+}
+export function isRefSchemaLegacy(propertySchema) {
+    return isString(propertySchema.$ref);
+}
+export function isAllOfSchema(propertySchema) {
+    return isArray(propertySchema.allOf);
+}
+export function isExtendsSchema(propertySchema) {
+    return isRecord(propertySchema) && isArray(propertySchema.extends);
+}
+export function isOneOfSchema(propertySchema) {
+    return isArray(propertySchema.oneOf);
+}
+export function isEnumSchema(obj) {
+    return isArray(obj.enum);
+}
+export function isArraySchema(propertySchema) {
+    return propertySchema.type === "array" && isRecord(propertySchema.items);
+}
+export function isReturnShapeArraySchema(returnShape) {
+    return typeof returnShape === "object" && returnShape.type === "array";
+}
+export function isObjectSchema(propertySchema) {
+    return isRecord(propertySchema) && propertySchema.type === "object" && isRecord(propertySchema.properties);
+}
+/** Service Config Utils **/
+/**
+ * Test all required props, currently:
+ * "name", "slug", "provider", "serviceType", "authenticationType"
+ */
+export function isAnyServiceConfig(maybeConfig) {
+    return (maybeConfig &&
+        isString(maybeConfig.title) &&
+        isString(maybeConfig.id) &&
+        isString(maybeConfig.provider) &&
+        isString(maybeConfig.serviceType) &&
+        isString(maybeConfig.authenticationType));
+}
+export function isGraphQLServiceConfig(maybeConfig) {
+    return (isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === "graphql" && isString(maybeConfig.options?.endpoint));
+}
+export function isRESTServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === "rest";
+}
+export function isOpenAPIServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && maybeConfig.serviceType === "openapi";
+}
+export function isShopifyServiceConfig(maybeShopify) {
+    return maybeShopify.provider === "shopify";
+}
+export function isEncryptedServiceConfig(maybeConfig) {
+    return isAnyServiceConfig(maybeConfig) && isString(maybeConfig.authentication);
+}
+export function isServiceConfigWithOAuth2Authentication(maybeServiceConfig) {
+    return (isAnyServiceConfig(maybeServiceConfig) &&
+        isServiceAuthentication(maybeServiceConfig.authentication) &&
+        isOAuth2Authentication(maybeServiceConfig.authentication));
+}
+export function isServiceConfigWithCustomAuthentication(maybeServiceConfig) {
+    return (isAnyServiceConfig(maybeServiceConfig) &&
+        isServiceAuthentication(maybeServiceConfig.authentication) &&
+        isCustomAuthentication(maybeServiceConfig.authentication));
+}
+/** Authentication Utils **/
+export function isServiceAuthentication(maybeAuthentication) {
+    return maybeAuthentication?.type;
+}
+export function isBearerAuthentication(authentication) {
+    return authentication?.type === "bearer";
+}
+export function isBasicAuthentication(authentication) {
+    return authentication?.type === "basic";
+}
+export function isSearchParamsAuthentication(authentication) {
+    return authentication?.type === "searchParams";
+}
+export function isOAuth2Authentication(authentication) {
+    return authentication?.type === "oauth2";
+}
+export function isOAuth2BearerAuthentication(authentication) {
+    return authentication?.type === "oauth2Bearer";
+}
+export function isGoogleAuthentication(authentication) {
+    return authentication?.type === "google";
+}
+export function isCustomAuthentication(authentication) {
+    return authentication?.type === "custom";
+}
+/** Miscellaneous Utils **/
+/**
+ * A utility to return the type of args present on a schema.
+ *
+ * @param argsSchema Any schema that may have an `args` property.
+ */
+export const getArgsType = (argsSchema) => {
+    if (has(argsSchema, "@args")) {
+        return ArgsType["@args"];
+    }
+    if (has(argsSchema, "args")) {
+        return ArgsType.args;
+    }
+};
+/**
+ * A utility to return the type of ref present on a schema.
+ *
+ * @param refSchema Any schema that may have a `ref` property.
+ */
+export const getRefType = (refSchema) => {
+    if (has(refSchema, "@ref")) {
+        return RefType["@ref"];
+    }
+    if (has(refSchema, "$ref")) {
+        return RefType.$ref;
+    }
+};
+export function isPropertySchemaWithRelationship(schema) {
+    return schema["@resolver"]?.name === "shapedb:getRelated";
+}
+export function isModelShape(shape) {
+    return Boolean(shape.model);
+}
+export function isCachedShape(shape) {
+    return shape.cache?.enabled === true && shape.loaders !== undefined;
+}
+export function listCachedShapes(shapes) {
+    return Object.values(shapes).filter(isCachedShape);
+}
+export function getCachedShapeMap(shapes) {
+    const results = {};
+    for (const shape of Object.values(shapes)) {
+        if (isCachedShape(shape)) {
+            results[shape.name] = shape;
+        }
+    }
+    return results;
+}
+export function isMeshShape(shape) {
+    return Boolean(shape.joins);
+}