@conduit-client/model 3.7.0 → 3.8.0

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

@@ -1,3 +1,4 @@
 export * from './api';
 export * from './types';
-export * from './amf';
+export * from './parser/amf';
+export * from './parser/parser-utils';

package/dist/types/v1/parser/__tests__/test-utils.d.ts

@@ -0,0 +1,433 @@
+import amf from 'amf-client-js';
+import { AMFAPI } from '../amf/AMFAPI';
+import { AMFType } from '../amf/types';
+import { LoggerService } from '@conduit-client/utils';
+import { Mock } from 'vitest';
+import { TypeRegistry } from '../..';
+export type ParserKind = 'amf';
+type ClassOfConstructor<T> = T extends new () => infer R ? R : never;
+/**
+ * Extracts the shape value types from a TestOAS structure.
+ * These are the amf.AnyShape instances available as properties on the TestOAS object.
+ */
+export type TestOASShapeValue<T extends TestOAS<ParserKind, Record<string, new () => amf.AnyShape>, Record<string, string>>> = T extends {
+    document: amf.Document;
+} ? Exclude<T[keyof T], amf.Document | amf.EndPoint> : never;
+type TestAmfOAS<T extends Record<string, new () => amf.AnyShape>, E extends Record<string, string>> = {
+    document: amf.Document;
+} & {
+    [P in keyof T]: ClassOfConstructor<T[P]>;
+} & {
+    [P in keyof E]: amf.EndPoint;
+};
+export type TestOAS<K extends ParserKind, T extends Record<string, new () => amf.AnyShape>, E extends Record<string, string>> = K extends 'amf' ? TestAmfOAS<T, E> : never;
+declare const specFileConfigs: {
+    readonly amfApi: {
+        readonly file: "amf-api.yaml";
+        readonly shapes: {
+            readonly Object_Simple: typeof amf.NodeShape;
+            readonly Object_Flat: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly amfEndpoints: {
+        readonly file: "amf-endpoints.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly entityById: "/entity/{id}";
+            readonly entity: "/entity";
+            readonly auraEntityById: "/aura-entity/{id}";
+            readonly auraEntity: "/aura-entity";
+            readonly entityMissing: "/entity/missing";
+            readonly entityPost: "/entity-post";
+        };
+    };
+    readonly any: {
+        readonly file: "any.yaml";
+        readonly shapes: {
+            readonly Any: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly arrays: {
+        readonly file: "arrays.yaml";
+        readonly shapes: {
+            readonly Array_Scalar: typeof amf.ArrayShape;
+            readonly Array_NestedObjectArray: typeof amf.ArrayShape;
+            readonly Object_Flat: typeof amf.NodeShape;
+            readonly Array_NoItems: typeof amf.ArrayShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly datetimes: {
+        readonly file: "datetimes.yaml";
+        readonly shapes: {
+            readonly birthday: typeof amf.ScalarShape;
+            readonly created: typeof amf.ScalarShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly discriminators: {
+        readonly file: "discriminators.yaml";
+        readonly shapes: {
+            readonly Object_Discriminated: typeof amf.NodeShape;
+            readonly Object_Discriminated_Type1: typeof amf.NodeShape;
+            readonly Object_Discriminated_Type2: typeof amf.NodeShape;
+            readonly Object_Discriminated_Incorrect_Mapping: typeof amf.NodeShape;
+            readonly Pet: typeof amf.NodeShape;
+            readonly Dog: typeof amf.AnyShape;
+            readonly Cat: typeof amf.AnyShape;
+            readonly Puppy: typeof amf.AnyShape;
+            readonly NewbornPuppy: typeof amf.AnyShape;
+            readonly MultipleDiscriminatorInheritance: typeof amf.AnyShape;
+            readonly InlineDiscriminator: typeof amf.AnyShape;
+            readonly InlineInheritedDiscriminator: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly objects: {
+        readonly file: "objects.yaml";
+        readonly shapes: {
+            readonly Object_Simple: typeof amf.NodeShape;
+            readonly Object_Simple2: typeof amf.NodeShape;
+            readonly Object_Flat: typeof amf.NodeShape;
+            readonly Object_Nested: typeof amf.NodeShape;
+            readonly Object_With_Optional_Properties: typeof amf.NodeShape;
+            readonly Object_With_Explicit_Allowed_Additional_Properties: typeof amf.NodeShape;
+            readonly Object_No_Additional_Properties: typeof amf.NodeShape;
+            readonly Object_With_Inline_Additional_Properties_Schema: typeof amf.NodeShape;
+            readonly Object_With_Reference_Additional_Properties_Schema: typeof amf.NodeShape;
+            readonly StringType: typeof amf.ScalarShape;
+            readonly Object_Ref: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly not: {
+        readonly file: "not.yaml";
+        readonly shapes: {
+            readonly Object: typeof amf.NodeShape;
+            readonly NotObject: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly scalars: {
+        readonly file: "scalars.yaml";
+        readonly shapes: {
+            readonly Boolean: typeof amf.ScalarShape;
+            readonly Integer: typeof amf.ScalarShape;
+            readonly Int32: typeof amf.ScalarShape;
+            readonly Int64: typeof amf.ScalarShape;
+            readonly Number: typeof amf.ScalarShape;
+            readonly Float: typeof amf.ScalarShape;
+            readonly Double: typeof amf.ScalarShape;
+            readonly String: typeof amf.ScalarShape;
+            readonly Password: typeof amf.ScalarShape;
+            readonly AnyString: typeof amf.ScalarShape;
+            readonly Byte: typeof amf.ScalarShape;
+            readonly Binary: typeof amf.ScalarShape;
+            readonly Nullable_String: typeof amf.UnionShape;
+            readonly String_Inherited: typeof amf.ScalarShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly invalidScalars: {
+        readonly file: "scalars-invalid.yaml";
+        readonly shapes: {
+            readonly IncorrectlyAnnotated: typeof amf.ScalarShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly amfYamlExtensions: {
+        readonly file: "amf-extensions.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly entityById: "/entity/{id}";
+            readonly entityDetailsById: "/entity/{id}/details";
+            readonly entity: "/entity";
+        };
+    };
+    readonly amfAllOf: {
+        readonly file: "amf-allof.yaml";
+        readonly shapes: {
+            readonly Pet: typeof amf.NodeShape;
+            readonly Cat: typeof amf.AnyShape;
+            readonly Dog: typeof amf.AnyShape;
+            readonly AlternateDog: typeof amf.AnyShape;
+            readonly DiscriminatedPet: typeof amf.NodeShape;
+            readonly DiscriminatedCat: typeof amf.AnyShape;
+            readonly DiscriminatedDog: typeof amf.AnyShape;
+            readonly SelfReferencing: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly amfOneOf: {
+        readonly file: "amf-oneof.yaml";
+        readonly shapes: {
+            readonly Pet: typeof amf.AnyShape;
+            readonly Cat: typeof amf.NodeShape;
+            readonly Dog: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly amfAnyOf: {
+        readonly file: "amf-anyof.yaml";
+        readonly shapes: {
+            readonly Pet: typeof amf.AnyShape;
+            readonly Cat: typeof amf.NodeShape;
+            readonly Dog: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly amfOperationInvalidErrorStrategy: {
+        readonly file: "amf-extensions-error-strategy-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly invalidErrorStrategy: "/invalidErrorStrategy";
+        };
+    };
+    readonly amfOperationInvalidOperationType: {
+        readonly file: "amf-extensions-operation-type-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly invalidOperationType: "/invalidOperationType";
+        };
+    };
+    readonly amfOperationExposeRefresh: {
+        readonly file: "amf-extensions-operation-expose-refresh.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly exposeRefreshDefault: "/exposeRefreshDefault";
+            readonly exposeRefreshTrue: "/exposeRefreshTrue";
+            readonly exposeRefreshFalse: "/exposeRefreshFalse";
+        };
+    };
+    readonly amfOperationExposeRefreshMutationInvalid: {
+        readonly file: "amf-extensions-operation-invalid-mutation-refresh.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly exposeRefreshDefault: "/exposeRefreshDefault";
+            readonly exposeRefreshTrue: "/exposeRefreshTrue";
+            readonly exposeRefreshFalse: "/exposeRefreshFalse";
+        };
+    };
+    readonly amfOperationExposeRefreshLegacyInvalid: {
+        readonly file: "amf-extensions-operation-invalid-legacy-refresh.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly exposeRefreshDefault: "/exposeRefreshDefault";
+            readonly exposeRefreshTrue: "/exposeRefreshTrue";
+            readonly exposeRefreshFalse: "/exposeRefreshFalse";
+        };
+    };
+    readonly amfOperationExposeRefreshLegacyMixed: {
+        readonly file: "amf-extensions-operation-expose-refresh-legacy-mixed.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly exposeRefreshTrueMixed: "/exposeRefreshTrueMixed";
+        };
+    };
+    readonly amfBindings: {
+        readonly file: "bindings.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly defaultOperationTypeGet: "/defaults/operation-type-get-no-bindings";
+            readonly defaultOperationTypePost: "/defaults/operation-type-post-no-bindings";
+            readonly defaultIdentifierDefaultsToOpId: "/defaults/identifier-from-operation-id";
+            readonly defaultBindingMutation: "/defaults/binding-imperative-for-mutation";
+            readonly defaultBindingQuery: "/defaults/binding-wire-for-query";
+            readonly defaultBindingForGetWithMutationOperationType: "/defaults/binding-wire-for-get-with-mutation-operation-type";
+            readonly successQuery: "/success/query-wire-imperative";
+            readonly successMutation: "/success/mutation-imperative";
+            readonly successMultipleBindings: "/success/multiple-bindings-with-unique-identifiers";
+            readonly successMultipleOperationsUniqueBindingIdentifier: "/success/multiple-operations-with-unique-identifier";
+            readonly failInvalidBindingType: "/fail/invalid-binding-type";
+            readonly failMutationWire: "/fail/mutation-wire";
+            readonly failMutationImperativeInvoker: "/fail/mutation-imperative-legacy";
+            readonly failNoIdentifierMulti: "/fail/no-identifier-multiple-bindings";
+            readonly failDuplicateIdentifier: "/fail/duplicate-identifier";
+            readonly failGetMethodWithMutationOperationTypeAndWireBinding: "/fail/get-method-with-mutation-operation-type-and-wire-binding";
+            readonly failGetMethodWithMutationOperationTypeAndImperativeInvokerBinding: "/fail/get-method-with-mutation-operation-type-and-imperative-legacy-binding";
+            readonly failMultipleOperationsShareBindingIdentifier: "/fail/multiple-operations-share-binding-identifier";
+        };
+    };
+    readonly amfGraphQLBindings: {
+        readonly file: "amf-extensions-bindings-graphql.yaml";
+        readonly shapes: {};
+        readonly endpoints: {
+            readonly graphqlMutationBindingSuccess: "/graphql/success/mutation-binding";
+            readonly nonGraphqlWithMutationBinding: "/graphql/fail/non-graphql-mutation-binding";
+        };
+    };
+    readonly bindingsValidation: {
+        readonly file: "bindings-validation.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly enums: {
+        readonly file: "enums.yaml";
+        readonly shapes: {
+            readonly String_Enumerated: typeof amf.ScalarShape;
+            readonly String_Property_Enum: typeof amf.NodeShape;
+            readonly CustomDates: typeof amf.AnyShape;
+            readonly CustomCursorType: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly additionalProperties: {
+        readonly file: "additional-properties.yaml";
+        readonly shapes: {
+            readonly Object_Simple: typeof amf.NodeShape;
+            readonly AdditionalPropertiesScalar: typeof amf.NodeShape;
+            readonly AdditionalPropertiesObject: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly oneofs: {
+        readonly file: "oneof.yaml";
+        readonly shapes: {
+            readonly Object_Simple: typeof amf.NodeShape;
+            readonly Object_Simple2: typeof amf.NodeShape;
+            readonly OneOf: typeof amf.AnyShape;
+            readonly OneOf_Complex: typeof amf.AnyShape;
+            readonly OneOf_Inline_Inheritance: typeof amf.AnyShape;
+            readonly OneOf_Inline_Helper: typeof amf.NodeShape;
+            readonly OneOf_Inline_Properties: typeof amf.AnyShape;
+            readonly OneOf_With_Optional_Properties: typeof amf.AnyShape;
+            readonly CatOrDog: typeof amf.AnyShape;
+            readonly Cat: typeof amf.NodeShape;
+            readonly Dog: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly errors: {
+        readonly file: "error.yaml";
+        readonly shapes: {
+            readonly CustomNonScalarOneOf: typeof amf.AnyShape;
+            readonly CustomObjectEnumType: typeof amf.NodeShape;
+            readonly CustomArrayEnumType: typeof amf.ArrayShape;
+            readonly MissingPropertyType: typeof amf.NodeShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly base: {
+        readonly file: "base.yaml";
+        readonly shapes: {
+            readonly Anonymous: typeof amf.AnyShape;
+            readonly Identifiable: typeof amf.AnyShape;
+            readonly AnnotatedError: typeof amf.AnyShape;
+        };
+        readonly endpoints: {};
+    };
+    readonly typeValidation: {
+        readonly file: "type-validation.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly endpointValidation: {
+        readonly file: "endpoint-validation.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+};
+declare const defaultsConfigs: {
+    readonly apiOasUrl: {
+        readonly file: string;
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly errorRamlUrl: {
+        readonly file: string;
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly errorRamlUrl2: {
+        readonly file: string;
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+};
+declare const invalidationConfigs: {
+    readonly validOasUrl: {
+        readonly file: "amf-extensions-invalidation.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly keyNameInvalidOasUrl: {
+        readonly file: "amf-extensions-invalidation-key-name-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly keyValueInvalidOasUrl: {
+        readonly file: "amf-extensions-invalidation-key-value-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly keyValuePrefixInvalidOasUrl: {
+        readonly file: "amf-extensions-invalidation-key-value-prefix-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly invalidationInvalidOperationType: {
+        readonly file: "amf-extensions-invalidation-operation-type-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly typeInvalidOasUrl: {
+        readonly file: "amf-extensions-invalidation-type-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly typeInvalidFormatOasUrl: {
+        readonly file: "amf-extensions-invalidation-type-format-invalid.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly typeUnidentifiableOasUrl: {
+        readonly file: "amf-extensions-invalidation-unidentifiable-type.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+    readonly typeUnidentifiableInlineOasUrl: {
+        readonly file: "amf-extensions-invalidation-unidentifiable-type-inline.yaml";
+        readonly shapes: {};
+        readonly endpoints: {};
+    };
+};
+type SpecFileConfigs = typeof specFileConfigs;
+type DefaultsConfigs = typeof defaultsConfigs;
+type InvalidationConfigs = typeof invalidationConfigs;
+type ConfigToResult<K extends ParserKind, C> = C extends {
+    shapes: infer T;
+    endpoints: infer E;
+} ? T extends Record<string, new () => amf.AnyShape> ? E extends Record<string, string> ? TestOAS<K, T, E> : never : never : never;
+export type SpecFiles<K extends ParserKind> = {
+    [P in keyof SpecFileConfigs]: ConfigToResult<K, SpecFileConfigs[P]>;
+} & {
+    defaults: {
+        [P in keyof DefaultsConfigs]: ConfigToResult<K, DefaultsConfigs[P]>;
+    };
+    invalidation: {
+        [P in keyof InvalidationConfigs]: ConfigToResult<K, InvalidationConfigs[P]>;
+    };
+};
+export declare function readSpecFiles<K extends ParserKind>(kind: K): Promise<SpecFiles<K>>;
+export declare function createAmfAPI(oas: TestOAS<'amf', {}, {}>, logger: LoggerService): AMFAPI;
+export declare function createAmfTypeFactory(shape: amf.Shape, typeRegistry: TypeRegistry<AMFType>, logger: LoggerService, resolve?: boolean): AMFType;
+/**
+ * Helper to assert that a message was logged containing all specified patterns.
+ * This makes tests resilient to changes in log order.
+ */
+export declare function expectLogged(calls: Mock['mock']['calls'], ...patterns: string[]): void;
+/**
+ * Count how many times a pattern appears in log calls.
+ */
+export declare function countLogOccurrences(calls: Mock['mock']['calls'], pattern: string): number;
+/**
+ * Assert a pattern appears exactly once in log calls.
+ */
+export declare function expectLoggedOnce(calls: Mock['mock']['calls'], pattern: string): void;
+/**
+ * Assert that after pattern A appears, pattern B appears next.
+ */
+export declare function expectLogSequence(calls: Mock['mock']['calls'], patternA: string, patternB: string): void;
+export {};

package/dist/types/v1/{amf → parser/amf}/AMFAPI.d.ts

@@ -1,12 +1,10 @@
 import { type FileParserLogger, type NamedLoggerService } from '@conduit-client/utils';
-import { type ResolvedServiceOverrides } from '../api/service-overrides';
+import { type ResolvedServiceOverrides } from '../../api/service-overrides';
 import type { AMFType } from './types';
-import type { API, EndPoint, Server } from '../api';
-import type { ReadOnlyTypeRegistry, TypeRegistry } from '../types';
+import type { API, EndPoint, Server } from '../../api';
+import type { ReadOnlyTypeRegistry, TypeRegistry } from '../../types';
 import type * as amf from 'amf-client-js';
 import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
-export declare const V1_VERSION = "1.0.0";
-export declare const ANONYMOUS_TYPE_NAME = "<anonymous>";
 export declare class AMFAPI implements API {
     readonly document: amf.Document;
     private services;

package/dist/types/v1/{amf → parser/amf}/amf-api-service.d.ts

@@ -1,4 +1,4 @@
-import type { API, APIService } from '../api';
+import type { APIService } from '../../api';
 import type { NamedLoggerService } from '@conduit-client/utils';
 import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
 /**
@@ -6,10 +6,3 @@ import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-f
  * @returns a new APIService
  */
 export declare function amfAPIService(services: NamedLoggerService & NamedFeatureFlagsService): APIService;
-/**
- * Wraps an already-created API in an APIService.
- *
- * @param api an API
- * @returns
- */
-export declare function asAPIService(api: API): APIService;

package/dist/types/v1/{amf → parser/amf}/amf-utils.d.ts

@@ -1,5 +1,5 @@
 import amf from 'amf-client-js';
-import type { ScalarType } from '../types';
+import type { ScalarType } from '../../types';
 export declare const STRING_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#string";
 export declare const BOOLEAN_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#boolean";
 export declare const INTEGER_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#integer";

package/dist/types/v1/{amf → parser/amf}/endpoints/amf-endpoint.d.ts

@@ -1,6 +1,6 @@
-import type { AuraController, AuraEndPoint, BaseEndPoint, HttpEndPoint, Parameter, Operation, Server, API } from '../../api';
+import type { AuraController, AuraEndPoint, BaseEndPoint, HttpEndPoint, Parameter, Operation, Server, API } from '../../../api';
 import type { AMFType, AMFTypeFactory } from '../types';
-import type { TypeRegistry } from '../../types';
+import type { TypeRegistry } from '../../../types';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
 import type amf from 'amf-client-js';
 export type AmfEndPoint = AmfAuraEndpoint | AmfHttpEndPoint;