@takeshape/schema 11.52.0 → 11.55.0

package/dist/types/src/types/utils.d.ts

@@ -1,117 +0,0 @@
-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';
-import { ArgsType, RefType } from './types';
-import type { CachedShape, EncryptedServiceConfig, GraphQLServiceConfig, LatestProjectSchemaWithServices, MeshShape, OpenAPIServiceConfig, PropertySchemaWithRelationship, RESTServiceConfig, SchemaWithArgs, SchemaWithRef, ServiceConfigWithCustomAuthentication, ServiceConfigWithOAuth2Authentication, ShopifyServiceConfig } from './types';
-/** 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/src/unions.d.ts

@@ -1,14 +0,0 @@
-import type { ObjectSchema, OneOfSchema, ProjectSchemaJSON, PropertySchema } from './project-schema';
-import type { PropertyTransform } from './types';
-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/types/src/user-schema.d.ts

@@ -1,38 +0,0 @@
-/**
- * This file was automatically generated by json-schema-to-typescript.
- * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
- * and run json-schema-to-typescript to regenerate this file.
- */
-export interface User {
-    id: string;
-    email: string;
-    fullName: string;
-    created: number;
-    updated: number;
-    firstTime: boolean;
-    avatarPath?: string;
-    intercomHash?: string;
-    googleUserId?: string;
-    comcastId?: string;
-    token?: string;
-    policies?: AccessPolicyDocument[];
-    preferences?: {
-        [k: string]: any;
-    };
-}
-export interface AccessPolicyDocument {
-    Version: string;
-    Statement: {
-        Effect?: 'Allow' | 'Deny';
-        Sid?: string;
-        Action?: string[];
-        NotAction?: string[];
-        Resource?: string[];
-        NotResource?: string[];
-        Principal?: {
-            AWS?: string[];
-            Service?: string[];
-        };
-        Condition?: {};
-    }[];
-}

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

@@ -1,3 +0,0 @@
-import type { AIToolConfig, AgentToolConfig } from '../project-schema/latest';
-export declare function getToolRef(tool: Pick<AIToolConfig, 'ref'> | string): string;
-export declare function normalizeToolConfig(tool: AIToolConfig | AgentToolConfig | string): AIToolConfig | AgentToolConfig;

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

@@ -1,9 +0,0 @@
-import { type Maybe } from '@takeshape/util';
-import type { ProjectSchemaJSON, ShapeLoaders } from '../project-schema';
-import type { GetQueryIndexingConfig, ListQueryIndexingConfig } from '../types';
-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/types/src/util/detect-cycles.d.ts

@@ -1,7 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema } from '../project-schema';
-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/types/src/util/find-shape-at-path.d.ts

@@ -1,21 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from '../project-schema';
-/**
- *
- * @param projectSchema
- * @param schema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
- */
-export declare function findSchemaAtPath(projectSchema: ProjectSchemaJSON, schema: PropertySchema, queryPath: string[]): PropertySchema | undefined;
-/**
- *
- * @param projectSchema
- * @param propSchema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
- */
-export declare function findShapeAtPath(projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, queryPath: string[]): ShapeJSON | undefined;

package/dist/types/src/util/form-config.d.ts

@@ -1,11 +0,0 @@
-import { type Maybe } from '@takeshape/util';
-import type { FormConfig, FormMap, ProjectSchemaJSON } from '../project-schema';
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-export declare function normalizeForms(projectSchema: ProjectSchemaJSON): FormMap;
-/**
- * Find the form config for a given shape name and the form key.
- */
-export declare function findShapeFormConfig(projectSchema: ProjectSchemaJSON, shapeName: string, formName: string): Maybe<FormConfig>;

package/dist/types/src/util/get-conflicting-properties.d.ts

@@ -1,6 +0,0 @@
-import type { ShapeJSON } from '../project-schema';
-import { type ServicesShapesContext } from '../refs';
-/**
- * Given a list of shapes find the conflicting props
- */
-export declare function getConflictingProperties(context: ServicesShapesContext, shapes: ShapeJSON[]): Set<string>;

package/dist/types/src/util/get-return-shape.d.ts

@@ -1,4 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, QueryJSON, ShapeJSON } from '../project-schema';
-import { type ServicesShapesContext } from '../refs';
-export declare function getReturnShapeRef(context: ServicesShapesContext, propOrQuery: PropertySchema | QueryJSON): import("@takeshape/util").Maybe<import("../refs").RefItem>;
-export declare function getReturnShape(projectSchema: ProjectSchemaJSON, propOrQuery: PropertySchema | QueryJSON): ShapeJSON | undefined;

package/dist/types/src/util/has-arg.d.ts

@@ -1,4 +0,0 @@
-import type { Args, ProjectSchemaJSON } from '../project-schema';
-import type { SchemaWithArgs } from '../types';
-export declare function getArgs(prop: SchemaWithArgs): Args | undefined;
-export declare function hasArg(projectSchema: ProjectSchemaJSON, prop: SchemaWithArgs, argPath: string | string[]): boolean;

package/dist/types/src/util/merge.d.ts

@@ -1,15 +0,0 @@
-import type { FormConfig, ObjectSchema, ProjectSchemaJSON } from '../project-schema';
-export declare function mergeObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
-export declare function mergeDeepObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
-export declare function mergeSchemaProperties(parent: ObjectSchema, overrides: ObjectSchema, deep?: boolean): ObjectSchema;
-export declare function rebaseSchemaProperties(base: ObjectSchema, parent: ObjectSchema, head: ObjectSchema): ObjectSchema;
-export declare function mergeFormProperties(parent: FormConfig, overrides: FormConfig): FormConfig;
-export declare function rebaseFormProperties(base: FormConfig, parent: FormConfig, head: FormConfig): FormConfig;
-export declare function mergeFormConfigs(...configs: FormConfig[]): FormConfig;
-export declare function mergeProjectSchemas(base: ProjectSchemaJSON, parent: ProjectSchemaJSON, head: ProjectSchemaJSON): {
-    error: string;
-    mergedSchema: undefined;
-} | {
-    error: undefined;
-    mergedSchema: ProjectSchemaJSON;
-};

package/dist/types/src/util/patch-schema.d.ts

@@ -1,8 +0,0 @@
-import type { ProjectSchemaUpdate } from '../migration/types';
-import type { ProjectSchemaJSON } from '../project-schema';
-/**
- * Apply a schema update to a schema. This can operate on a schema with frozen properties,
- * such as one produced by immer. Resulting schema is not assumed to be valid and should
- * be validated if appropriate.
- */
-export declare function patchSchema<T extends ProjectSchemaJSON>(projectSchema: T, schemaUpdate: ProjectSchemaUpdate): T;

package/dist/types/src/util/shapes.d.ts

@@ -1,5 +0,0 @@
-import type { ProjectSchemaJSON, ShapeJSON } from '../project-schema';
-export declare function getShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON | undefined;
-export declare function getShape(context: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON | undefined;
-export declare function ensureShape(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON;
-export declare function ensureShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON;

package/dist/types/src/validate.d.ts

@@ -1,75 +0,0 @@
-import { type SchemaValidationErrorItem } from '@takeshape/errors';
-import { type Entitlements } from '@takeshape/util';
-import type { ErrorObject } from 'ajv';
-import type { SetRequired } from 'type-fest';
-import type { RoleImport, RoleInput } from './auth-schemas';
-import type { AnyProjectSchemaJSON, ProjectSchemaJSON } from './project-schema';
-import type { LayerState, ProjectSchemaImport } from './types/types';
-export declare const builtInShapeNames: Set<string>;
-export type SchemaValidationResult = {
-    valid: true;
-    schema: AnyProjectSchemaJSON;
-    errors: undefined;
-} | {
-    valid: false;
-    schema: undefined;
-    errors: SchemaValidationErrorItem[];
-};
-export declare function formatError(error: ErrorObject): SchemaValidationErrorItem;
-export type Validation = {
-    version: string;
-    schemaId: string;
-    isVersion: (schemaVersion?: string) => boolean;
-    validate: (schema: unknown, options?: ValidateSyntaxOptions) => SchemaValidationResult;
-};
-export type ValidateSyntaxOptions = {
-    suppressErrorPaths?: string[];
-    resolveLayer?: ResolveLayer;
-};
-export type ResolveLayer = (layerId: string) => Promise<LayerState>;
-export type EntitlementsOptions = {
-    ignoreEntitlements: true;
-    entitlements?: Entitlements;
-} | {
-    ignoreEntitlements?: false;
-    entitlements: Entitlements;
-};
-export type ValidateContext = {
-    allowDisconnectedLayers?: boolean;
-} & EntitlementsOptions & ValidateSyntaxOptions;
-export type ValidateReferencesContext = SetRequired<ValidateContext, 'resolveLayer'>;
-export declare function validateSchemaSyntax(obj: unknown, options?: ValidateSyntaxOptions): SchemaValidationResult;
-/**
- * Validates a schema using a matching validation based on the `schemaVersion` property.
- */
-export declare function validateSchema(context: ValidateContext, obj: unknown): Promise<SchemaValidationResult>;
-export declare function ensureValidLatestSchemaSyntax(obj: unknown): ProjectSchemaJSON;
-/**
- * Validates and returns a `RoleInput`, which is a subset of the `Role`
- * type's properties suitable for importing.
- */
-export declare function validateRoleInput(maybeRoleInput: unknown): RoleInput;
-/**
- * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
- */
-export declare function ensureValidRoleImport(maybeRoles: unknown): RoleImport;
-export type ProjectSchemaImportValidationResult = {
-    valid: true;
-    schema: ProjectSchemaImport;
-    errors: undefined;
-} | {
-    valid: false;
-    schema: undefined;
-    errors: SchemaValidationErrorItem[];
-};
-/**
- * Only use when validating an imported schema! ignore fields optional when importing
- */
-export declare function validateProjectSchemaImport(maybeSchema: unknown): ProjectSchemaImportValidationResult;
-/**
- * Only use when validating an imported schema!
- *
- * New style validation for parity with the `validateRoleImport` fn. Returns
- * a valid, clean `ImportProjectSchema` or throws a `SchemaValidationError`.
- */
-export declare function ensureValidProjectSchemaImport(maybeSchema: unknown): ProjectSchemaImport;

package/dist/types/src/versions.d.ts

@@ -1,4 +0,0 @@
-export { CURRENT_SCHEMA_VERSION } from './schemas';
-export declare const LEGACY_SCHEMA_VERSION = "1.0.0";
-export declare const CURRENT_API_VERSION = "2";
-export declare const LEGACY_API_VERSION = "1";

package/dist/types/src/workflows.d.ts

@@ -1,14 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, ShapeJSON, Workflow, WorkflowMap, WorkflowStep } from './project-schema';
-export declare const defaultWorkflow: Workflow;
-export declare function getWorkflow(projectSchema: ProjectSchemaJSON, shapeId: string): Workflow;
-export type StepContext = {
-    index: number;
-    step: WorkflowStep;
-};
-export declare function statusFallback(workflow: Workflow, enabled: boolean): WorkflowStep;
-export declare function findWorkflowStep(workflow: Workflow, keyOrName: string): StepContext | undefined;
-export declare function getStatusField(workflows: WorkflowMap, shape: Pick<ShapeJSON, 'workflow'>): PropertySchema;
-export type WorkflowComparisonOperatorKey = 'lt' | 'lte' | 'gte' | 'gt' | 'eq' | 'in';
-export declare function getStepRange(steps: WorkflowStep[], index: number, op: WorkflowComparisonOperatorKey): WorkflowStep[];
-export declare function getWorkflowStepKeys(workflow: Workflow, stepKey: string, op: WorkflowComparisonOperatorKey): string[];
-export declare function getLiveStepKeys(workflow: Workflow): string[];