@takeshape/schema 11.144.1 → 11.154.2

package/dist/types/utils.d.ts

@@ -1,112 +0,0 @@
-import type { Maybe } from '@takeshape/util';
-import type { AgentExecution, AgentExecutionChat, AgentExecutionGenerate, AIGenerateTextResolver, AIResolverName, 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, ShapedbResolver, ShapeJSON, ShapeMap, ShapeSchemaEnum, TakeshapeResolver, UtilResolver } from '../project-schema/index.ts';
-import type { CachedShape, EncryptedServiceConfig, GraphQLServiceConfig, LatestProjectSchemaWithServices, MeshShape, OpenAPIServiceConfig, PropertySchemaWithRelationship, RESTServiceConfig, ReferenceableShape, SchemaWithArgs, ServiceConfigWithCustomAuthentication, ServiceConfigWithOAuth2Authentication, ShopifyServiceConfig } from './types.ts';
-import { ArgsType } 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>;
-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 isReferenceableShape(shape: ShapeJSON): shape is ReferenceableShape;
-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

@@ -1,269 +0,0 @@
-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 } 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;
-    }
-};
-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 isReferenceableShape(shape) {
-    return Boolean(shape.loaders?.get);
-}
-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

@@ -1,14 +0,0 @@
-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;

package/dist/unions.js

@@ -1,77 +0,0 @@
-import { BadDataError } from '@takeshape/errors';
-import { camelCase, isRecord } from '@takeshape/util';
-import omit from 'lodash/omit.js';
-import { getRef, refItemToNamespacedShapeName } from "./refs.js";
-import { getOutputShapeName } from "./template-shapes/names.js";
-import { isRefSchema } from "./types/utils.js";
-import { getShapeById } from "./util/shapes.js";
-export function enumerateOneOfKeys(projectSchema, oneOf) {
-    const result = [];
-    for (const child of oneOf) {
-        const refItem = getRef(projectSchema, child);
-        if (refItem) {
-            const shapeName = refItemToNamespacedShapeName(projectSchema, refItem);
-            if (projectSchema.shapes[shapeName]) {
-                const shapeId = projectSchema.shapes[shapeName].id;
-                result.push({
-                    propName: getOutputShapeName(camelCase(refItem.shapeName)),
-                    propSchema: child,
-                    shapeName,
-                    shapeId
-                });
-            }
-        }
-    }
-    return result;
-}
-function getOneOf(schema) {
-    if (!schema.oneOf) {
-        throw new Error(`Expected ${JSON.stringify(schema)} to be a oneOf schema`);
-    }
-    return schema.oneOf;
-}
-export function isUnionSchema(schema) {
-    return Boolean(schema.oneOf?.every(isRefSchema));
-}
-export function oneOfToObject(projectSchema, schema) {
-    const properties = {};
-    for (const { propName, propSchema: child } of enumerateOneOfKeys(projectSchema, getOneOf(schema))) {
-        properties[propName] = child;
-    }
-    return { ...omit(schema, 'oneOf'), type: 'object', properties };
-}
-function formatKeys(keys) {
-    return keys.map((k) => `"${k}"`).join(', ');
-}
-export const createUnwrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if (isRecord(obj)) {
-        const oneOfKeys = enumerateOneOfKeys(projectSchema, getOneOf(schema));
-        const objectKeys = Object.keys(obj);
-        if (objectKeys.length !== 1) {
-            const propNames = oneOfKeys.map((k) => k.propName);
-            throw new BadDataError(`Object should only specify one of the following keys: ${formatKeys(propNames)}, but found keys: ${formatKeys(objectKeys)}`);
-        }
-        for (const { propName, shapeId, propSchema } of oneOfKeys) {
-            const propValue = obj[propName];
-            if (isRecord(propValue)) {
-                const transformedPropValue = next(propValue, propSchema, name);
-                if (isRecord(transformedPropValue)) {
-                    return {
-                        ...transformedPropValue,
-                        _shapeId: shapeId
-                    };
-                }
-            }
-        }
-    }
-};
-export const createWrapTransform = (projectSchema) => (obj, schema, name, shape, next) => {
-    if (isRecord(obj) && typeof obj._shapeId === 'string') {
-        const shape = getShapeById(projectSchema, obj._shapeId);
-        if (shape) {
-            return {
-                [camelCase(shape.name)]: next(omit(obj, '_shapeId'), shape.schema, name)
-            };
-        }
-    }
-};

package/dist/util/ai-tools.d.ts

@@ -1,2 +0,0 @@
-import type { AgentToolConfig, AIToolConfig, ToolJSON } from '../project-schema/index.ts';
-export declare function normalizeToolConfig(tool: AIToolConfig | AgentToolConfig | ToolJSON | string): AgentToolConfig;

package/dist/util/ai-tools.js

@@ -1,14 +0,0 @@
-import { parsePropertyRef } from "../refs.js";
-export function normalizeToolConfig(tool) {
-    if (typeof tool === 'string') {
-        return {
-            name: parsePropertyRef(tool)?.propertyName ?? tool,
-            ref: tool
-        };
-    }
-    const name = 'name' in tool ? tool.name : (parsePropertyRef(tool.ref)?.propertyName ?? tool.ref);
-    return {
-        name,
-        ...tool
-    };
-}

package/dist/util/api-indexing.d.ts

@@ -1,9 +0,0 @@
-import { type Maybe } from '@takeshape/util';
-import type { ProjectSchemaJSON, ShapeLoaders } from '../project-schema/index.ts';
-import type { GetQueryIndexingConfig, ListQueryIndexingConfig } from '../types/index.ts';
-export declare function serviceHasIndexedShapes(schema: ProjectSchemaJSON, serviceId: string): boolean;
-export declare function getIndexedServices(projectSchema: ProjectSchemaJSON, configs: ShapeLoaders[keyof ShapeLoaders]): string[];
-type Getter<T> = (context: Pick<ProjectSchemaJSON, 'shapes'>, shapeName: string) => T;
-export declare const getListQueryIndexConfigs: Getter<ListQueryIndexingConfig[]>;
-export declare const getGetQueryIndexConfig: Getter<Maybe<GetQueryIndexingConfig>>;
-export {};

package/dist/util/api-indexing.js

@@ -1,57 +0,0 @@
-import { ensureArray } from '@takeshape/util';
-import { getQuery } from "../refs.js";
-import { getIdField } from "../schema-util.js";
-import { getResolverServices } from "../services/util.js";
-import { isCachedShape, isServiceResolver } from "../types/index.js";
-export function serviceHasIndexedShapes(schema, serviceId) {
-    for (const shape of Object.values(schema.shapes ?? {})) {
-        const indexingEnabled = isCachedShape(shape);
-        const listConfigs = shape.loaders?.list;
-        if (indexingEnabled && listConfigs) {
-            for (const { query: queryRef } of ensureArray(listConfigs)) {
-                const resolved = getQuery(schema, queryRef);
-                if (resolved && isServiceResolver(resolved.query.resolver) && resolved.query.resolver.service === serviceId) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-export function getIndexedServices(projectSchema, configs) {
-    return ensureArray(configs).reduce((services, queryConfig) => {
-        const resolved = queryConfig?.query ? getQuery(projectSchema, queryConfig.query) : undefined;
-        return resolved?.query ? [...services, ...getResolverServices(resolved.query.resolver)] : services;
-    }, []);
-}
-function flattenListQueryConfigs(base, queryConfig, maybeConfigArray) {
-    return (maybeConfigArray &&
-        ensureArray(maybeConfigArray).flatMap((config) => ensureArray(config.args).map((args) => ({
-            ...base,
-            ...queryConfig,
-            ...config,
-            args
-        }))));
-}
-function getQueryIndexConfigHelper(op) {
-    return ({ shapes }, shapeName) => {
-        const { cache, loaders } = shapes[shapeName] ?? {};
-        if (cache && loaders) {
-            const idField = getIdField(cache);
-            if (op === 'list') {
-                return flattenListQueryConfigs({ shapeName, idField }, cache.fragment, loaders.list);
-            }
-            const queryConfig = loaders.get;
-            if (queryConfig) {
-                return {
-                    idField,
-                    shapeName,
-                    ...cache.fragment,
-                    ...queryConfig
-                };
-            }
-        }
-    };
-}
-export const getListQueryIndexConfigs = getQueryIndexConfigHelper('list');
-export const getGetQueryIndexConfig = getQueryIndexConfigHelper('get');

package/dist/util/coerce-value.d.ts

@@ -1,9 +0,0 @@
-import type { PropertySchema } from '../project-schema/index.js';
-/**
- * Coerces a value to match the type specified in a PropertySchema only supporting primitive types
- * @param schema - The PropertySchema object defining the expected type
- * @param value - The value to coerce
- * @returns The coerced value
- * @throws Error if coercion fails or type is not supported
- */
-export declare function coercePrimitiveValue(schema: PropertySchema, value: unknown): any;

package/dist/util/coerce-value.js

@@ -1,32 +0,0 @@
-import { coerceToBoolean, coerceToInteger, coerceToNumber, coerceToString } from '@takeshape/util';
-/**
- * Coerces a value to match the type specified in a PropertySchema only supporting primitive types
- * @param schema - The PropertySchema object defining the expected type
- * @param value - The value to coerce
- * @returns The coerced value
- * @throws Error if coercion fails or type is not supported
- */
-export function coercePrimitiveValue(schema, value) {
-    // Handle undefined/null values
-    if (value === undefined) {
-        if (schema.default !== undefined) {
-            return schema.default;
-        }
-    }
-    const primaryType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-    switch (primaryType) {
-        case 'string':
-            return coerceToString(value);
-        case 'number':
-            return coerceToNumber(value);
-        case 'integer':
-            return coerceToInteger(value);
-        case 'boolean':
-            return coerceToBoolean(value);
-        case 'null':
-            return null;
-        default:
-            // If no type specified, return as-is
-            return value;
-    }
-}

package/dist/util/detect-cycles.d.ts

@@ -1,7 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema } from '../project-schema/index.ts';
-type SchemaPredicate = (projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, shapeName?: string, propName?: string) => boolean;
-/**
- * Use a basic depth-first search to determine whether a schema contains a cycle
- */
-export declare function hasCycle(projectSchema: ProjectSchemaJSON, schema: PropertySchema, predicate?: SchemaPredicate): boolean;
-export {};

package/dist/util/detect-cycles.js

@@ -1,45 +0,0 @@
-import { value } from '@takeshape/util';
-import { getRef, refItemToShape } from "../refs.js";
-function immutableSetAdd(set, str) {
-    const result = new Set(set);
-    result.add(str);
-    return result;
-}
-/**
- * Use a basic depth-first search to determine whether a schema contains a cycle
- */
-export function hasCycle(projectSchema, schema, predicate = value(true)) {
-    const hasCycleHelper = (schema, shapesSeen = new Set(), shapeName, propName) => {
-        if (!predicate(projectSchema, schema, shapeName, propName)) {
-            return false;
-        }
-        const refItem = getRef(projectSchema, schema);
-        if (refItem) {
-            const refShape = refItemToShape(projectSchema, refItem);
-            // If we have a refItem, but no shape, this is a dangling ref and has no cycles
-            if (!refShape) {
-                return false;
-            }
-            if (shapesSeen.has(refShape.name)) {
-                return true;
-            }
-            return hasCycleHelper(refShape.schema, immutableSetAdd(shapesSeen, refShape.name), refShape.name);
-        }
-        const combo = schema.oneOf ?? schema.allOf ?? schema.extends;
-        if (combo) {
-            return combo.some((childSchema) => hasCycleHelper(childSchema, shapesSeen, shapeName, propName));
-        }
-        if (schema.items) {
-            return hasCycleHelper(schema.items, shapesSeen, shapeName, propName);
-        }
-        const { properties } = schema;
-        if (properties) {
-            return Object.keys(properties).some((name) => {
-                const propSchema = properties[name];
-                return hasCycleHelper(propSchema, shapesSeen, shapeName, name);
-            });
-        }
-        return false;
-    };
-    return hasCycleHelper(schema);
-}