@takeshape/schema 11.52.0 → 11.55.0

package/dist/types/types.d.ts

@@ -0,0 +1,211 @@
+import type { Overwrite } from '@takeshape/util';
+import type { XMLParser } from 'fast-xml-parser';
+import type { Merge, PartialDeep, SetOptional, SetRequired } from 'type-fest';
+import type { SERVICE_OBJECT_PATTERN_NAME } from '../constants.ts';
+import type { AnyProjectSchemaJSON, CachedFragmentConfig, CustomAuthentication, GetQueryLoaderConfig, ListQueryLoaderConfig, OAuth2Authentication, ProjectSchemaJSON, ProjectSchemaJSONV1_0_0, ProjectSchemaJSONV3_0_0, ProjectSchemaJSONV3_1_0, ProjectSchemaJSONV3_2_0, ProjectSchemaJSONV3_3_0, ProjectSchemaJSONV3_4_0, ProjectSchemaJSONV3_5_0, ProjectSchemaJSONV3_5_1, ProjectSchemaJSONV3_6_0, ProjectSchemaJSONV3_7_0, ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0, ProjectSchemaJSONV3_10_0, ProjectSchemaJSONV3_11_0, ProjectSchemaJSONV3_12_0, ProjectSchemaJSONV3_12_1, ProjectSchemaJSONV3_12_2, ProjectSchemaJSONV3_12_3, ProjectSchemaJSONV3_13_0, ProjectSchemaJSONV3_14_0, ProjectSchemaJSONV3_15_0, ProjectSchemaJSONV3_16_0, ProjectSchemaJSONV3_17_0, ProjectSchemaJSONV3_17_1, ProjectSchemaJSONV3_18_0, ProjectSchemaJSONV3_18_1, ProjectSchemaJSONV3_18_2, ProjectSchemaJSONV3_19_0, ProjectSchemaJSONV3_20_0, ProjectSchemaJSONV3_21_0, ProjectSchemaJSONV3_22_0, ProjectSchemaJSONV3_23_0, PropertySchema, QueryJSON, Ref, ServiceAuthentication, ServiceConfig, ServiceMapJSON, ShapeJSON } from '../project-schema/index.ts';
+export type ProjectSchemaJSONWithVersion = ProjectSchemaJSONV3_23_0 | ProjectSchemaJSONV3_22_0 | ProjectSchemaJSONV3_21_0 | ProjectSchemaJSONV3_20_0 | ProjectSchemaJSONV3_19_0 | ProjectSchemaJSONV3_18_2 | ProjectSchemaJSONV3_18_1 | ProjectSchemaJSONV3_18_0 | ProjectSchemaJSONV3_17_1 | ProjectSchemaJSONV3_17_0 | ProjectSchemaJSONV3_16_0 | ProjectSchemaJSONV3_15_0 | ProjectSchemaJSONV3_14_0 | ProjectSchemaJSONV3_13_0 | ProjectSchemaJSONV3_12_3 | ProjectSchemaJSONV3_12_2 | ProjectSchemaJSONV3_12_1 | ProjectSchemaJSONV3_12_0 | ProjectSchemaJSONV3_11_0 | ProjectSchemaJSONV3_10_0 | ProjectSchemaJSONV3_9_0 | ProjectSchemaJSONV3_8_0 | ProjectSchemaJSONV3_7_0 | ProjectSchemaJSONV3_6_0 | ProjectSchemaJSONV3_5_1 | ProjectSchemaJSONV3_5_0 | ProjectSchemaJSONV3_4_0 | ProjectSchemaJSONV3_3_0 | ProjectSchemaJSONV3_2_0 | ProjectSchemaJSONV3_1_0 | ProjectSchemaJSONV3_0_0 | ProjectSchemaJSONV1_0_0;
+export declare const projectSchemaImportOptionalProps: readonly ["projectId", "locales", "defaultLocale", "author"];
+export declare const legacyProjectSchemaImportOptionalProps: readonly ["created", "updated", "version", "dataKey"];
+export type ProjectSchemaImport = SetOptional<AnyProjectSchemaJSON, (typeof projectSchemaImportOptionalProps)[number]>;
+export type Content = {
+    [name: string]: any;
+    _id: string;
+};
+export type ServiceInfo = {
+    service: string;
+    fieldName: string;
+    path: string[];
+    generators: Record<typeof SERVICE_OBJECT_PATTERN_NAME, PatternGenerator | undefined>;
+};
+/**
+ * Remote service configuration types
+ */
+/**
+ * Old service authentication
+ * @deprecated
+ */
+export type ServiceConfigAccessToken = {
+    accessToken: string;
+    refreshToken?: string;
+    scope?: string;
+};
+export type ServiceKey = string;
+export type ServiceMap = Map<ServiceKey, ServiceConfig>;
+export type PatternGenerator = {
+    version: string;
+    currentVersion: string;
+    idFieldName: string;
+    serviceObjectType: string;
+};
+export type Headers = Record<string, string | string[]>;
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'HEAD' | 'DELETE' | 'OPTIONS' | 'TRACE' | 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace';
+export type AllowedRetryOptions = number | Partial<{
+    limit: number;
+    methods: Method[];
+    statusCodes: number[];
+    errorCodes: string[];
+    maxRetryAfter: number;
+    backoffLimit: number;
+    noise: number;
+}>;
+export type RESTServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'rest';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        headers?: Headers;
+        timeout?: number;
+        retry?: AllowedRetryOptions;
+        fastXmlParser?: ConstructorParameters<typeof XMLParser>[0];
+    };
+}>;
+export type GraphQLServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'graphql';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        headers?: Headers;
+        timeout?: number;
+    };
+}>;
+export type OpenAPIServiceConfig = Merge<ServiceConfig, {
+    serviceType: 'openapi';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        spec: string;
+        headers?: Headers;
+        timeout?: number;
+        retry?: AllowedRetryOptions;
+        useRestfulNames?: boolean;
+        introspectedAt?: string;
+        transformVersion?: string;
+    };
+}>;
+export type EncryptedServiceConfig = Overwrite<ServiceConfig, {
+    authentication: string;
+}>;
+export type ServiceConfigWithOAuth2Authentication = Merge<ServiceConfig, {
+    authentication: OAuth2Authentication;
+}>;
+export type ServiceConfigWithCustomAuthentication = Merge<ServiceConfig, {
+    authentication: CustomAuthentication;
+}>;
+/**
+ * Support null sentinels for authentication
+ */
+export type ServiceConfigWithNullSentinelAuthentication = Overwrite<ServiceConfig, {
+    authentication?: ServiceAuthentication | null;
+}>;
+/**
+ * A type suitable for service object updates, mostly concerns authentication
+ * requirements.
+ */
+export type ServiceConfigUpdate = SetRequired<PartialDeep<ServiceConfigWithNullSentinelAuthentication>, 'authenticationType'>;
+export type LatestProjectSchemaWithServices = {
+    services: ServiceMapJSON;
+} & ProjectSchemaJSON;
+/**
+ * Types of refs
+ */
+export declare enum RefType {
+    '@ref' = "@ref",
+    $ref = "$ref"
+}
+/**
+ * Stub of a PropertySchema that may contain a `$ref` or `@ref`.
+ */
+export type RefSchemaStub = {
+    items?: RefSchemaStub;
+} & Pick<PropertySchema, RefType>;
+export type SchemaWithRef = PropertySchema | RefSchemaStub;
+/**
+ * Types of args
+ */
+export declare enum ArgsType {
+    '@args' = "@args",
+    args = "args"
+}
+export type SchemaWithArgs = PropertySchema | QueryJSON;
+/**
+ * Types supporting schema iterators
+ */
+export type SchemaPropertyName = string;
+export type SchemaPropertyNode = [SchemaPropertyName, PropertySchema];
+export type SchemaPropertyIterator = SchemaPropertyNode[];
+export type ShopifyServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'graphql';
+    provider: 'shopify';
+    options: {
+        shop: string;
+        endpoint: string;
+    };
+}>;
+export type SchemaPath = Array<string | number>;
+export type LayerSchema = Pick<ProjectSchemaJSON, 'shapes' | 'queries' | 'mutations' | 'schemaVersion'>;
+export type ServiceLayers = Record<string, LayerState>;
+export type UndefinedLayerState = {
+    id: string;
+    schema: undefined;
+    status: 'disconnected' | 'error' | 'notAvailable';
+};
+export type DefinedLayerState = {
+    id: string;
+    schema: LayerSchema;
+    status: 'ok';
+};
+export type LayerState = UndefinedLayerState | DefinedLayerState;
+export type LayerStatus = LayerState['status'];
+export type UndefinedLayerStatus = UndefinedLayerState['status'];
+/**
+ * Shapes
+ */
+export type ShapeRefs = Ref[];
+/**
+ * Relationships
+ */
+export type PropertySchemaWithRelationship = PropertySchema & {
+    '@resolver': {
+        name: 'shapedb:getRelated';
+        service: 'shapedb';
+        options?: {
+            nullable?: boolean;
+        };
+    };
+};
+/**
+ * New relationship data, drawn from a PropertySchema.
+ */
+export type Relationship = {
+    isMultiple: boolean;
+    refs: ShapeRefs;
+    hasBackreference: boolean;
+    backreferenceName?: string;
+};
+/**
+ * The old relationship format, used in client UI.
+ */
+export type LegacyRelationship = {
+    shapeIds: string[];
+    type?: 'single' | 'multiple';
+};
+export type RelationshipEnv = {
+    shapeId: string;
+    path: string[];
+    hasBackreference: boolean;
+    relatedName?: string;
+    schema: PropertySchema;
+    shapeName: string;
+};
+export type CachedShape = SetRequired<ShapeJSON, 'loaders' | 'cache'>;
+export type CachedShapeMap = Record<string, CachedShape>;
+export type ListQueryIndexingConfig = CachedFragmentConfig & ListQueryLoaderConfig & {
+    shapeName: string;
+    idField: string;
+};
+export type GetQueryIndexingConfig = CachedFragmentConfig & GetQueryLoaderConfig & {
+    shapeName: string;
+    idField: string;
+};
+export type MeshShape = SetRequired<ShapeJSON, 'joins'>;
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,117 @@
+import type { Maybe } from '@takeshape/util';
+import type { AIGenerateTextResolver, AIResolverName, AgentExecution, AgentExecutionChat, AgentExecutionGenerate, AllOfSchema, AnyServiceConfig, AwsLambdaResolver, BasicAuthentication, BasicResolver, BearerAuthentication, ComposeResolver, CustomAuthentication, DirectiveConfig, DirectiveMappingArray, DirectiveMappingMap, ExtendsSchema, GoogleAuthentication, GraphqlResolver, OAuth2Authentication, OAuth2BearerAuthentication, ObjectSchema, OneOfSchema, ParameterOp, ParameterOpMapping, ParameterOpNested, ParameterOpOp, ParameterOpValue, ParameterSerializeContentOptions, ParameterSerializeOptions, ParameterSerializeStyleOptions, ParameterSerializeStyleOptionsForPathParams, ParameterSerializeStyleOptionsForSearchParams, ProjectSchemaJSON, PropertySchema, RefSchema, RefSchemaLegacy, Resolver, RestResolver, ReturnShape, ReturnShapeArraySchema, SearchParamsAuthentication, ServiceAuthentication, ServiceResolver, ShapeJSON, ShapeMap, ShapeSchemaEnum, ShapedbResolver, TakeshapeResolver, UtilResolver } from '../project-schema/index.ts';
+import { ArgsType, RefType } from './types.ts';
+import type { CachedShape, EncryptedServiceConfig, GraphQLServiceConfig, LatestProjectSchemaWithServices, MeshShape, OpenAPIServiceConfig, PropertySchemaWithRelationship, RESTServiceConfig, SchemaWithArgs, SchemaWithRef, ServiceConfigWithCustomAuthentication, ServiceConfigWithOAuth2Authentication, ShopifyServiceConfig } from './types.ts';
+/** Resolver Type Utils **/
+/**
+ * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
+ */
+export declare function isBasicResolver(resolver: unknown): resolver is BasicResolver;
+export declare function isServiceResolver(resolver: unknown): resolver is ServiceResolver;
+export declare function isComposeResolver(resolver: unknown): resolver is ComposeResolver;
+export declare function isTakeshapeResolver(resolver: unknown): resolver is TakeshapeResolver;
+export declare function isShapedbResolver(resolver: unknown): resolver is ShapedbResolver;
+export declare function isGraphqlResolver(resolver: unknown): resolver is GraphqlResolver;
+export declare function isRestResolver(resolver: unknown): resolver is RestResolver;
+export declare function isAwsLambdaResolver(resolver: unknown): resolver is AwsLambdaResolver;
+export declare function isUtilResolver(resolver: unknown): resolver is UtilResolver;
+export declare const aiResolverNames: AIResolverName[];
+export declare function isAIResolverName(name: string | undefined): name is AIResolverName;
+export declare function isAIResolver(resolver: unknown): resolver is AIGenerateTextResolver;
+export declare function isAIAgentStateExecution(agentExecution: AgentExecution): agentExecution is AgentExecutionGenerate | AgentExecutionChat;
+export declare function isProjectSchemaWithServices(schema: ProjectSchemaJSON): schema is LatestProjectSchemaWithServices;
+export declare function containsResolver(resolver: Resolver, predicate: (resolver: BasicResolver) => boolean): boolean;
+/** Directive Mapping Utils **/
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
+ */
+export declare function isDirectiveMappingMap(maybeMap: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeMap is DirectiveMappingMap;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
+ */
+export declare function isDirectiveMappingArray(maybeArray: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeArray is DirectiveMappingArray;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveConfig array
+ */
+export declare function isDirectiveConfig(maybeConfig: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeConfig is DirectiveConfig;
+/**
+ * Determine whether a ParameterSerializeOption is a content type serializer
+ */
+export declare function isParameterSerializeContentOptions(maybeContent: ParameterSerializeOptions): maybeContent is ParameterSerializeContentOptions;
+/**
+ * Determine whether an unknown variable is a `ParameterOp`
+ */
+export declare function isParameterOp(maybeOp: unknown): maybeOp is ParameterOp;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpNested`
+ */
+export declare function isParameterOpNested(maybeOp: ParameterOp): maybeOp is ParameterOpNested;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+export declare function isParameterOpMapping(maybeOp: ParameterOp): maybeOp is ParameterOpMapping;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpValue`
+ */
+export declare function isParameterOpValue(maybeOp: ParameterOp): maybeOp is ParameterOpValue;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpOp`
+ */
+export declare function isParameterOpOp(maybeOp: ParameterOp): maybeOp is ParameterOpOp;
+export declare function isParameterSerializeStyleForSearchParams(maybeParam: Maybe<string>): maybeParam is ParameterSerializeStyleOptionsForSearchParams['style'];
+export declare function isParameterSerializeStyleForPathParams(maybeParam: Maybe<string>): maybeParam is ParameterSerializeStyleOptionsForPathParams['style'];
+/**
+ * Determine whether a ParameterSerializeOption is a style serializer
+ */
+export declare function isParameterSerializeStyleOptions(maybeStyle: ParameterSerializeOptions): maybeStyle is ParameterSerializeStyleOptions;
+/** Typeguards for different types of shape schemas **/
+export declare function isRefSchema(propertySchema: PropertySchema): propertySchema is RefSchema | RefSchemaLegacy;
+export declare function isRefSchemaLegacy(propertySchema: PropertySchema): propertySchema is RefSchemaLegacy;
+export declare function isAllOfSchema(propertySchema: PropertySchema): propertySchema is AllOfSchema;
+export declare function isExtendsSchema(propertySchema: unknown): propertySchema is ExtendsSchema;
+export declare function isOneOfSchema(propertySchema: PropertySchema): propertySchema is OneOfSchema;
+export declare function isEnumSchema(obj: PropertySchema): obj is ShapeSchemaEnum;
+export declare function isArraySchema(propertySchema: PropertySchema): propertySchema is ReturnShapeArraySchema;
+export declare function isReturnShapeArraySchema(returnShape: ReturnShape): returnShape is ReturnShapeArraySchema;
+export declare function isObjectSchema(propertySchema: unknown): propertySchema is ObjectSchema;
+/** Service Config Utils **/
+/**
+ * Test all required props, currently:
+ * "name", "slug", "provider", "serviceType", "authenticationType"
+ */
+export declare function isAnyServiceConfig(maybeConfig: any): maybeConfig is AnyServiceConfig;
+export declare function isGraphQLServiceConfig(maybeConfig: any): maybeConfig is GraphQLServiceConfig;
+export declare function isRESTServiceConfig(maybeConfig: any): maybeConfig is RESTServiceConfig;
+export declare function isOpenAPIServiceConfig(maybeConfig: any): maybeConfig is OpenAPIServiceConfig;
+export declare function isShopifyServiceConfig(maybeShopify: AnyServiceConfig): maybeShopify is ShopifyServiceConfig;
+export declare function isEncryptedServiceConfig(maybeConfig: any): maybeConfig is EncryptedServiceConfig;
+export declare function isServiceConfigWithOAuth2Authentication(maybeServiceConfig: any): maybeServiceConfig is ServiceConfigWithOAuth2Authentication;
+export declare function isServiceConfigWithCustomAuthentication(maybeServiceConfig: any): maybeServiceConfig is ServiceConfigWithCustomAuthentication;
+/** Authentication Utils **/
+export declare function isServiceAuthentication(maybeAuthentication: any): maybeAuthentication is ServiceAuthentication;
+export declare function isBearerAuthentication(authentication: ServiceAuthentication): authentication is BearerAuthentication;
+export declare function isBasicAuthentication(authentication: ServiceAuthentication): authentication is BasicAuthentication;
+export declare function isSearchParamsAuthentication(authentication: ServiceAuthentication): authentication is SearchParamsAuthentication;
+export declare function isOAuth2Authentication(authentication: ServiceAuthentication): authentication is OAuth2Authentication;
+export declare function isOAuth2BearerAuthentication(authentication: ServiceAuthentication): authentication is OAuth2BearerAuthentication;
+export declare function isGoogleAuthentication(authentication: ServiceAuthentication): authentication is GoogleAuthentication;
+export declare function isCustomAuthentication(authentication: ServiceAuthentication): authentication is CustomAuthentication;
+/** 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 declare const getArgsType: (argsSchema: SchemaWithArgs) => Maybe<ArgsType>;
+/**
+ * A utility to return the type of ref present on a schema.
+ *
+ * @param refSchema Any schema that may have a `ref` property.
+ */
+export declare const getRefType: (refSchema: SchemaWithRef) => Maybe<RefType>;
+export declare function isPropertySchemaWithRelationship(schema: PropertySchema): schema is PropertySchemaWithRelationship;
+export declare function isModelShape(shape: ShapeJSON): boolean;
+export declare function isCachedShape(shape: ShapeJSON): shape is CachedShape;
+export declare function listCachedShapes(shapes: ShapeMap): CachedShape[];
+export declare function getCachedShapeMap(shapes: ShapeMap): Record<string, CachedShape>;
+export declare function isMeshShape(shape: ShapeJSON): shape is MeshShape;

package/dist/types/utils.js

@@ -0,0 +1,279 @@
+import { isRecord } from '@takeshape/util';
+import has from 'lodash/has.js';
+import isArray from 'lodash/isArray.js';
+import isPlainObject from 'lodash/isPlainObject.js';
+import isString from 'lodash/isString.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);
+}

package/dist/unions.d.ts

@@ -0,0 +1,14 @@
+import type { ObjectSchema, OneOfSchema, ProjectSchemaJSON, PropertySchema } from './project-schema/index.ts';
+import type { PropertyTransform } from './types/index.ts';
+export type UnionedShape = {
+    propName: string;
+    shapeName: string;
+    shapeId: string;
+    propSchema: PropertySchema;
+};
+export declare function enumerateOneOfKeys(projectSchema: ProjectSchemaJSON, oneOf: PropertySchema[]): UnionedShape[];
+export declare function isUnionSchema(schema: PropertySchema): schema is OneOfSchema;
+export declare function oneOfToObject(projectSchema: ProjectSchemaJSON, schema: PropertySchema): ObjectSchema;
+export type TransformProcessFactory = (projectSchema: ProjectSchemaJSON) => PropertyTransform['process'];
+export declare const createUnwrapTransform: TransformProcessFactory;
+export declare const createWrapTransform: TransformProcessFactory;