@conduit-client/model 2.0.0

package/dist/types/v1/api/endpoint.d.ts

@@ -0,0 +1,162 @@
+import type { ArrayType, ScalarType, Type, TypeCacheControlExtension } from '../types';
+import type { Server, API } from './api';
+import type { ResolvedOperationServices } from './service-overrides';
+import type { InvalidateConfig } from '@conduit-client/utils';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+export type StatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '306' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+export type Parameter<T extends Type = ScalarType> = {
+    type: T;
+    required: boolean;
+    explode?: boolean;
+    defaultValue?: T;
+};
+export type UrlParameter = Parameter<ScalarType>;
+export type QueryParameter = Parameter<ScalarType | (ArrayType & {
+    items?: ScalarType;
+})>;
+export type TypeOfParameter<P extends Parameter<any>> = P extends Parameter<infer T> ? T : never;
+export type ApplicationJsonContent<T extends Type> = {
+    mediaType: 'application/json';
+    data: T;
+};
+export type ApplicationXmlContent<T extends Type> = {
+    mediaType: 'application/xml';
+    data: T;
+};
+export type Payload<T extends Type = Type> = ApplicationJsonContent<T> | ApplicationXmlContent<T>;
+export type Request<T extends Type = Type> = {
+    queryParameters: Record<string, QueryParameter>;
+    uriParameters: Record<string, Parameter>;
+    payloads: Array<Payload<T>>;
+    cookies: Record<string, Parameter>;
+    headers: Record<string, Parameter>;
+};
+export type Response<T extends Type = Type> = {
+    statusCode: StatusCode;
+    payloads: Array<Payload<T>>;
+    headers: Record<string, Parameter>;
+    invalidation?: InvalidateConfig[];
+};
+export declare const BindingTypesEnum: readonly ["wire", "imperative", "imperative-legacy", "mutation"];
+export type BindingType = (typeof BindingTypesEnum)[number];
+export type Binding = {
+    type: BindingType;
+    identifier: string;
+};
+export type ConfigSchemaType = 'default' | 'flattened';
+export type OperationType = 'query' | 'mutation' | 'graphql';
+export type ResourceLevelCacheControl = {
+    'max-age': number;
+};
+export type OperationCacheControl = {
+    type: 'max-age';
+    'max-age': number;
+} | {
+    type: 'no-cache';
+};
+export type CacheStrategy = {
+    type: 'none';
+} | {
+    type: 'resource';
+    config: ResourceLevelCacheControl;
+} | {
+    type: 'normalized';
+    'cache-control': OperationCacheControl;
+    key?: Record<string, string>;
+};
+export type ErrorStrategy = {
+    type: 'stringified';
+} | {
+    type: 'fetchResponse';
+};
+export type BaseOperation<ResponseType extends Type = Type, RequestType extends Type = Type> = {
+    readonly type: 'aura' | 'http';
+    method: HttpMethod;
+    operationType: OperationType;
+    operationId: string | undefined;
+    configSchemaType: ConfigSchemaType;
+    requests: Request<RequestType>[];
+    responses: Response<ResponseType>[];
+    cacheStrategy: CacheStrategy;
+    errorStrategy: ErrorStrategy;
+    endpoint: EndPoint;
+    server: Server;
+    bindings: Binding[];
+    exposeRefresh: boolean;
+    basePath: string;
+    defaults: API['defaults'];
+    serviceOverrides: ResolvedOperationServices;
+};
+export type BaseOperationWithRequestBody<ResponseType extends Type = Type, RequestType extends Type = Type> = BaseOperation & {
+    configBodyParam: string;
+};
+export type BaseAuraOperation = BaseOperation & {
+    type: 'aura';
+    aura: {
+        methodName: string;
+    };
+};
+export type AuraOperationWithRequestBody = BaseOperationWithRequestBody & BaseAuraOperation & {
+    aura: BaseAuraOperation['aura'] & {
+        bodyParam: string;
+    };
+};
+export type BaseGraphQLOperation = BaseOperation & {
+    operationType: 'graphql';
+    graphqlConfig: GraphQLConfig;
+};
+export type BaseHttpOperation = BaseOperation & {
+    type: 'http';
+};
+export type HttpOperationWithRequestBody = BaseHttpOperation & BaseOperationWithRequestBody;
+export type HttpOperation = BaseHttpOperation | HttpOperationWithRequestBody;
+export type AuraOperation = BaseAuraOperation | AuraOperationWithRequestBody;
+export type AuraGraphQLOperation = AuraOperation & BaseGraphQLOperation;
+export type HttpGraphQLOperation = HttpOperation & BaseGraphQLOperation;
+export type GraphQLOperation = AuraGraphQLOperation | HttpGraphQLOperation;
+export type Operation = HttpOperation | AuraOperation | GraphQLOperation;
+export type NoCacheOperation = Operation & {
+    cacheStrategy: {
+        type: 'none';
+    };
+};
+export type ResourceCacheOperation = Operation & {
+    cacheStrategy: {
+        type: 'resource';
+    };
+};
+export type NormalizedOperation = Operation & {
+    cacheStrategy: {
+        type: 'normalized';
+    };
+};
+export type AuraController = {
+    name: string;
+};
+export type NetworkPreference = 'aura' | 'http';
+/**
+ * A particular endpoint provided by an API.
+ */
+export type BaseEndPoint = {
+    readonly type: 'aura' | 'http';
+    path: string;
+    uriParameters: Record<string, Parameter>;
+    operations: ReadonlyArray<Operation>;
+};
+export type AuraEndPoint = BaseEndPoint & {
+    auraController: AuraController;
+    networkPreference: NetworkPreference;
+};
+export type HttpEndPoint = BaseEndPoint & {
+    type: 'http';
+};
+export type EndPoint = HttpEndPoint | AuraEndPoint;
+export type GraphQLTypeMetadata = {
+    typename: string;
+    'cache-control': OperationCacheControl;
+};
+export type GraphQLConfig = {
+    schemaFilePath: string;
+    'type-metadata': GraphQLTypeMetadata[];
+    defaults?: Partial<TypeCacheControlExtension>;
+};

package/dist/types/v1/api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './endpoint';
+export * from './service';
+export { buildApiValidatorFor } from './validation';
+export * from './service-overrides';

package/dist/types/v1/api/service-overrides.d.ts

@@ -0,0 +1,249 @@
+import { z } from 'zod';
+/**
+ * Service Overrides parsing utilities for OAS `x-onestore` extensions.
+ *
+ * This module only provides schemas and helpers. Wiring into AMF parsing
+ * happens separately in the endpoint/operation builders.
+ */
+export type ServiceTypeName = string;
+export type ServiceVariantDescriptor = {
+    type: ServiceTypeName;
+    version: string;
+    tags?: Record<string, string>;
+    default?: boolean;
+};
+export type ServicesCatalog = Record<string, ServiceVariantDescriptor>;
+export type OperationServiceRef = {
+    ref: string;
+};
+export type OperationServiceInline = {
+    version: string;
+    tags?: Record<string, string>;
+};
+export type OperationServices = Record<ServiceTypeName, OperationServiceRef | OperationServiceInline>;
+export type ResolvedServiceOverrides = {
+    catalog: ServicesCatalog;
+    /** Map of service type -> alias key that is marked default */
+    defaultsByType: Record<ServiceTypeName, string>;
+};
+export declare const serviceVariantDescriptorSchema: z.ZodObject<{
+    type: z.ZodString;
+    version: z.ZodString;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    version: string;
+    tags?: Record<string, string> | undefined;
+    default?: boolean | undefined;
+}, {
+    type: string;
+    version: string;
+    tags?: Record<string, string> | undefined;
+    default?: boolean | undefined;
+}>;
+export declare const servicesCatalogSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    version: z.ZodString;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    version: string;
+    tags?: Record<string, string> | undefined;
+    default?: boolean | undefined;
+}, {
+    type: string;
+    version: string;
+    tags?: Record<string, string> | undefined;
+    default?: boolean | undefined;
+}>>;
+export declare const operationServiceRefSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    ref: string;
+}, {
+    ref: string;
+}>;
+export declare const operationServiceInlineSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodString;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}>, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}>;
+export declare const operationServicesSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    ref: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    ref: string;
+}, {
+    ref: string;
+}>, z.ZodEffects<z.ZodObject<{
+    version: z.ZodString;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}>, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}, {
+    version: string;
+    tags?: Record<string, string> | undefined;
+    optional?: boolean | undefined;
+}>]>>;
+export declare const componentsOnestoreServicesSchema: z.ZodObject<{
+    onestore: z.ZodObject<{
+        services: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            version: z.ZodString;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            default: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        services: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>;
+    }, {
+        services: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    onestore: {
+        services: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>;
+    };
+}, {
+    onestore: {
+        services: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>;
+    };
+}>;
+export declare const operationOnestoreServicesSchema: z.ZodObject<{
+    onestore: z.ZodObject<{
+        services: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            ref: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            ref: string;
+        }, {
+            ref: string;
+        }>, z.ZodEffects<z.ZodObject<{
+            version: z.ZodString;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }, {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>, {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }, {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        services: Record<string, {
+            ref: string;
+        } | {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>;
+    }, {
+        services: Record<string, {
+            ref: string;
+        } | {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    onestore: {
+        services: Record<string, {
+            ref: string;
+        } | {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>;
+    };
+}, {
+    onestore: {
+        services: Record<string, {
+            ref: string;
+        } | {
+            version: string;
+            tags?: Record<string, string> | undefined;
+            optional?: boolean | undefined;
+        }>;
+    };
+}>;
+/**
+ * Validates and normalizes a components-level services catalog.
+ * Enforces single default per service type.
+ */
+export declare function validateAndNormalizeCatalog(catalog: ServicesCatalog): ResolvedServiceOverrides;
+/**
+ * Given an operation-level services object and a catalog, produce a normalized mapping
+ * of canonical service type -> alias key (when $ref used) or inline descriptor.
+ *
+ * This does not perform runtime resolution or merging — it only standardizes shape.
+ */
+export type ResolvedServiceDescriptor = Pick<ServiceVariantDescriptor, 'type' | 'version' | 'tags' | 'default'>;
+export type ResolvedOperationServices = Record<ServiceTypeName, ResolvedServiceDescriptor>;
+export declare function resolveOperationServices(services: OperationServices, catalog?: ResolvedServiceOverrides): ResolvedOperationServices;
+export declare function resolveDefaultServiceOverrides(catalog?: ResolvedServiceOverrides): ResolvedOperationServices;

package/dist/types/v1/api/service.d.ts

@@ -0,0 +1,23 @@
+import type { NamedService } from '@conduit-client/utils';
+import type { API } from '../api';
+/**
+ * A Service that provides an API definition.
+ */
+export type APIService = {
+    /**
+     * Most recently-created API.
+     */
+    api: API;
+    /**
+     * Loads an IDL & creates an API model from it.
+     *
+     * @param args filename or url of the IDL from which to construct the API
+     * @returns API
+     */
+    build(args: {
+        url: URL;
+    } | {
+        filename: string;
+    }): Promise<API>;
+};
+export type NamedAPIService<Name extends string = 'api'> = NamedService<Name, APIService>;

package/dist/types/v1/api/validation/bindings.d.ts

@@ -0,0 +1,6 @@
+import { type ValidationResult, type Validator } from '../../validation';
+import { API, Operation } from '..';
+export declare class BindingsValidation<S extends API = API> implements Validator<S, Operation> {
+    constructor();
+    validate(api: S): ValidationResult<Operation>;
+}

package/dist/types/v1/api/validation/endpoint/__tests__/index.spec.d.ts

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

package/dist/types/v1/api/validation/endpoint/index.d.ts

@@ -0,0 +1,3 @@
+import type { API, EndPoint, Operation, Type } from '../../..';
+import { Validator } from '../../../validation';
+export declare function buildEndpointValidator(api: API): Validator<EndPoint, EndPoint | Operation | Type>;

package/dist/types/v1/api/validation/index.d.ts

@@ -0,0 +1,16 @@
+import type { API } from '../api';
+import { type Validator } from '../../validation';
+import type { Type } from '../../types';
+import type { EndPoint, Operation } from '../endpoint';
+type MessageSourceTypes = API | Type | EndPoint | Operation;
+export declare class ApiValidator implements Validator<API, MessageSourceTypes> {
+    private apiValidators;
+    private typeValidator;
+    private endpointValidator;
+    constructor(apiValidators: Validator<API, MessageSourceTypes>[], typeValidator: Validator<Type, Type>, endpointValidator: Validator<EndPoint, MessageSourceTypes>);
+    validate(subject: API): import("../../validation").ValidationResult<MessageSourceTypes>;
+    private validateCollection;
+}
+export declare function buildApiValidatorFor(api: API): Validator<API, MessageSourceTypes>;
+export declare function validateUniqueBindingIdentfiers(operations: readonly Operation[]): boolean;
+export {};

package/dist/types/v1/api/validation/operation/BodyDataValidator.d.ts

@@ -0,0 +1,13 @@
+import type { Operation, Type, Request, Response } from '../../..';
+import { Validator } from '../../../validation';
+import { KeySourcesValidator } from '../../../types/validators/extensions';
+/**
+ * Validates the body of a request or response supports a key path
+ */
+export declare class BodyDataValidator<T extends Operation = Operation> implements Validator<Operation, Operation | Type> {
+    private target;
+    private keys;
+    private keySourcesValidatorSupplier;
+    constructor(target: Response | Request, keys: string[], keySourcesValidatorSupplier: (sources: string[]) => KeySourcesValidator);
+    validate(operation: T): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, import("../../../validation").ValidationMessage<Type | Operation>[]>;
+}

package/dist/types/v1/api/validation/operation/InvalidationValidator.d.ts

@@ -0,0 +1,39 @@
+import { ValidationMessage, Validator } from '../../../validation';
+import { Operation, type Response } from '../../endpoint';
+import { type ReadOnlyTypeRegistry, Type } from '../../..';
+import { BodyDataValidator } from './BodyDataValidator';
+/**
+ * Validates the configuration of 'invalidation'
+ */
+export declare class InvalidationValidator implements Validator<Operation, Operation | Type> {
+    private types;
+    private bodyDataValidatorSupplier;
+    constructor(types: ReadOnlyTypeRegistry, bodyDataValidatorSupplier: (response: Response, sources: string[]) => BodyDataValidator);
+    validate(operation: Operation): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, ValidationMessage<Type | Operation>[]>;
+    /**
+     * Returns the last parameter from a open api string ref.
+     *
+     * @param path - Fully qualified path: ex: '#/components/schemas/Post'
+     * @returns string - the type name
+     */
+    private parseTypeNameFromRef;
+    /**
+     * Validates that the defined key on the invalidation config is present as a key on the type.
+     *
+     * @param type - the AMFType
+     * @param key - the key defined on the invalidation config
+     * @param operation - the current operation
+     * @param response - the response
+     * @returns boolean - true if valid, false if invalid
+     */
+    private validateInvalidationTypeCacheKey;
+    /**
+     * Validates that the key value on the invalidation config is valid.
+     *
+     * @param v - the value
+     * @param operation - the operation
+     * @param response - the response
+     * @returns boolean - true if valid, false if invalid.
+     */
+    private validateInvalidationKeyValue;
+}

package/dist/types/v1/api/validation/operation/KeyMatchValidator.d.ts

@@ -0,0 +1,7 @@
+import type { Operation, ReadOnlyTypeRegistry } from '../../..';
+import { ValidationMessage, Validator } from '../../../validation';
+export declare class KeyMatchValidator<T extends Operation = Operation> implements Validator<T, Operation> {
+    private types;
+    constructor(types: ReadOnlyTypeRegistry);
+    validate(operation: T): import("@conduit-client/utils").Err<never, ValidationMessage<Operation>[]> | import("@conduit-client/utils").Ok<ValidationMessage<Operation>[], never>;
+}

package/dist/types/v1/api/validation/operation/KeySourceValidator.d.ts

@@ -0,0 +1,25 @@
+import { type ValidationMessage, type Validator } from '../../../validation';
+import { Operation, Parameter, QueryParameter, Request } from '../../endpoint';
+import { Type } from '../../..';
+import { BodyDataValidator } from './BodyDataValidator';
+type KeyBySourceCollection = {
+    path: string[];
+    query: string[];
+    body: string[];
+    cookie: string[];
+    header: string[];
+    _extras: string[];
+};
+/**
+ * Validates that the sources (i.e., the value) for all key entries are valid
+ */
+export declare class KeySourceValidator implements Validator<Operation, Operation | Type> {
+    private bodyDataValidatorSupplier;
+    constructor(bodyDataValidatorSupplier: (request: Request, sources: string[]) => BodyDataValidator);
+    validate(operation: Operation): import("../../../validation").ValidationResult<Type | Operation>;
+    getKeysBySource(key: Record<string, string>): KeyBySourceCollection;
+    validateParameter(operation: Operation, bag: Record<string, QueryParameter | Parameter>, keys: KeyBySourceCollection, source: keyof KeyBySourceCollection): import("@conduit-client/utils").Err<never, ValidationMessage<Type | Operation>[]> | import("@conduit-client/utils").Ok<ValidationMessage<Type | Operation>[], never>;
+    validateBody(operation: Operation, bodyDataValidator: BodyDataValidator): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, ValidationMessage<Type | Operation>[]>;
+    validateKeysWhenMissingRequest(keysBySource: KeyBySourceCollection, operation: Operation): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, ValidationMessage<Operation>[]>;
+}
+export {};

package/dist/types/v1/api/validation/operation/NoNormalizedTypesValidator.d.ts

@@ -0,0 +1,19 @@
+import type { Operation, ReadOnlyTypeRegistry, Type } from '../../..';
+import { ValidationMessage, Validator } from '../../../validation';
+/**
+ * Validates that if an operation is not normalized, its responses payloads has
+ * NO references to identifiable (i.e., normalized) types
+ */
+export declare class NoNormalizedTypesValidator implements Validator<Operation, Operation | Type> {
+    private types;
+    constructor(types: ReadOnlyTypeRegistry);
+    validate(operation: Operation): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, ValidationMessage<Type | Operation>[]>;
+    /**
+     * Completes a breadth-first search of a Type to locate any nested types that are identifiable.
+     *
+     * @returns a Set of all nested types that are identifiable.
+     * @param start
+     * @protected
+     */
+    findNestedIdentifiableTypes(start: Type): Set<Type>;
+}