@conduit-client/model 2.0.0

package/dist/main/index.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/types/v1/__tests__/validation.spec.d.ts

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

package/dist/types/v1/__tests__/zod-utils.spec.d.ts

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

package/dist/types/v1/amf/AMFAPI.d.ts

@@ -0,0 +1,44 @@
+import { type FileParserLogger, type NamedLoggerService } from '@conduit-client/utils';
+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 * 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;
+    private fileParserlogger;
+    typeRegistry?: TypeRegistry<AMFType>;
+    _endpoints?: EndPoint[];
+    _servers?: Server[];
+    annotationsVersion?: string;
+    basePath: string;
+    private built;
+    private parsedDefaultOperationCacheStrategyType?;
+    private parsedDefaultTypeCacheControl?;
+    private parsedNamespace?;
+    private defaultedNamespace;
+    serviceOverrides?: ResolvedServiceOverrides;
+    constructor(document: amf.Document, services: NamedLoggerService & NamedFeatureFlagsService, fileParserlogger: FileParserLogger);
+    private build;
+    private buildEndpoints;
+    private buildServers;
+    private buildTypes;
+    get webApi(): amf.WebApi;
+    get endpoints(): ReadonlyArray<EndPoint>;
+    get defaults(): API['defaults'];
+    get servers(): ReadonlyArray<Server>;
+    get types(): ReadOnlyTypeRegistry<AMFType>;
+    get namespace(): string;
+    checkAnnotationsVersion(): void;
+    setRootLevelAnnotations(): void;
+    /**
+     * Validates all endpoints and types.  A validation error will be thrown if any are invalid.
+     *
+     * @protected
+     */
+    validate(): void;
+}

package/dist/types/v1/amf/__tests__/AMFAPI.spec.d.ts

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

package/dist/types/v1/amf/__tests__/amf-api-service.spec.d.ts

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

package/dist/types/v1/amf/__tests__/amf-extensions-services.spec.d.ts

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

package/dist/types/v1/amf/__tests__/amf-extensions.spec.d.ts

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

package/dist/types/v1/amf/__tests__/amf-utils.spec.d.ts

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

package/dist/types/v1/amf/__tests__/parser.spec.d.ts

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

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

@@ -0,0 +1,211 @@
+import amf from 'amf-client-js';
+type ClassOfConstructor<T> = T extends new () => infer R ? R : never;
+type TestRaml<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 declare function readSpecFiles(): Promise<{
+    amfApi: TestRaml<{
+        Object_Simple: typeof amf.NodeShape;
+        Object_Flat: typeof amf.NodeShape;
+    }, {}>;
+    amfEndpoints: TestRaml<{}, {
+        entityById: string;
+        entity: string;
+        auraEntityById: string;
+        auraEntity: string;
+        entityMissing: string;
+    }>;
+    any: TestRaml<{
+        readonly Any: typeof amf.AnyShape;
+    }, {}>;
+    arrays: TestRaml<{
+        Array_Scalar: typeof amf.ArrayShape;
+        Array_NestedObjectArray: typeof amf.ArrayShape;
+        Object_Flat: typeof amf.NodeShape;
+        Array_NoItems: typeof amf.ArrayShape;
+    }, {}>;
+    datetimes: TestRaml<{
+        birthday: typeof amf.ScalarShape;
+        created: typeof amf.ScalarShape;
+    }, {}>;
+    discriminators: TestRaml<{
+        Object_Discriminated: typeof amf.NodeShape;
+        Object_Discriminated_Type1: typeof amf.NodeShape;
+        Object_Discriminated_Type2: typeof amf.NodeShape;
+        Object_Discriminated_Incorrect_Mapping: typeof amf.NodeShape;
+        Pet: typeof amf.NodeShape;
+        Dog: typeof amf.AnyShape;
+        Cat: typeof amf.AnyShape;
+        Puppy: typeof amf.AnyShape;
+        NewbornPuppy: typeof amf.AnyShape;
+        MultipleDiscriminatorInheritance: typeof amf.AnyShape;
+        InlineDiscriminator: typeof amf.AnyShape;
+        InlineInheritedDiscriminator: typeof amf.AnyShape;
+    }, {}>;
+    objects: TestRaml<{
+        Object_Simple: typeof amf.NodeShape;
+        Object_Simple2: typeof amf.NodeShape;
+        Object_Flat: typeof amf.NodeShape;
+        Object_Nested: typeof amf.NodeShape;
+        Object_With_Optional_Properties: typeof amf.NodeShape;
+        Object_With_Explicit_Allowed_Additional_Properties: typeof amf.NodeShape;
+        Object_No_Additional_Properties: typeof amf.NodeShape;
+        Object_With_Inline_Additional_Properties_Schema: typeof amf.NodeShape;
+        Object_With_Reference_Additional_Properties_Schema: typeof amf.NodeShape;
+        StringType: typeof amf.ScalarShape;
+        Object_Ref: typeof amf.NodeShape;
+    }, {}>;
+    not: TestRaml<{
+        Object: typeof amf.NodeShape;
+        NotObject: typeof amf.AnyShape;
+    }, {}>;
+    scalars: TestRaml<{
+        Boolean: typeof amf.ScalarShape;
+        Integer: typeof amf.ScalarShape;
+        Int32: typeof amf.ScalarShape;
+        Int64: typeof amf.ScalarShape;
+        Number: typeof amf.ScalarShape;
+        Float: typeof amf.ScalarShape;
+        Double: typeof amf.ScalarShape;
+        String: typeof amf.ScalarShape;
+        Password: typeof amf.ScalarShape;
+        AnyString: typeof amf.ScalarShape;
+        Byte: typeof amf.ScalarShape;
+        Binary: typeof amf.ScalarShape;
+        Nullable_String: typeof amf.UnionShape;
+        String_Inherited: typeof amf.ScalarShape;
+    }, {}>;
+    invalidScalars: TestRaml<{
+        IncorrectlyAnnotated: typeof amf.ScalarShape;
+    }, {}>;
+    amfYamlExtensions: TestRaml<{}, {
+        entityById: string;
+        entityDetailsById: string;
+        entity: string;
+    }>;
+    amfAllOf: TestRaml<{
+        Pet: typeof amf.NodeShape;
+        Cat: typeof amf.AnyShape;
+        Dog: typeof amf.AnyShape;
+        AlternateDog: typeof amf.AnyShape;
+        DiscriminatedPet: typeof amf.NodeShape;
+        DiscriminatedCat: typeof amf.AnyShape;
+        DiscriminatedDog: typeof amf.AnyShape;
+        SelfReferencing: typeof amf.AnyShape;
+    }, {}>;
+    amfOneOf: TestRaml<{
+        Pet: typeof amf.AnyShape;
+        Cat: typeof amf.NodeShape;
+        Dog: typeof amf.NodeShape;
+    }, {}>;
+    amfAnyOf: TestRaml<{
+        Pet: typeof amf.AnyShape;
+        Cat: typeof amf.NodeShape;
+        Dog: typeof amf.NodeShape;
+    }, {}>;
+    amfOperationInvalidErrorStrategy: TestRaml<{}, {
+        invalidErrorStrategy: string;
+    }>;
+    amfOperationInvalidOperationType: TestRaml<{}, {
+        invalidOperationType: string;
+    }>;
+    amfOperationExposeRefresh: TestRaml<{}, {
+        exposeRefreshDefault: string;
+        exposeRefreshTrue: string;
+        exposeRefreshFalse: string;
+    }>;
+    amfOperationExposeRefreshMutationInvalid: TestRaml<{}, {
+        exposeRefreshDefault: string;
+        exposeRefreshTrue: string;
+        exposeRefreshFalse: string;
+    }>;
+    amfOperationExposeRefreshLegacyInvalid: TestRaml<{}, {
+        exposeRefreshDefault: string;
+        exposeRefreshTrue: string;
+        exposeRefreshFalse: string;
+    }>;
+    amfBindings: TestRaml<{}, {
+        defaultOperationTypeGet: string;
+        defaultOperationTypePost: string;
+        defaultIdentifierDefaultsToOpId: string;
+        defaultBindingMutation: string;
+        defaultBindingQuery: string;
+        defaultBindingForGetWithMutationOperationType: string;
+        successQuery: string;
+        successMutation: string;
+        successMultipleBindings: string;
+        successMultipleOperationsUniqueBindingIdentifier: string;
+        failInvalidBindingType: string;
+        failMutationWire: string;
+        failMutationImperativeInvoker: string;
+        failNoIdentifierMulti: string;
+        failDuplicateIdentifier: string;
+        failGetMethodWithMutationOperationTypeAndWireBinding: string;
+        failGetMethodWithMutationOperationTypeAndImperativeInvokerBinding: string;
+        failMultipleOperationsShareBindingIdentifier: string;
+    }>;
+    amfGraphQLBindings: TestRaml<{}, {
+        graphqlMutationBindingSuccess: string;
+        nonGraphqlWithMutationBinding: string;
+    }>;
+    bindingsValidation: TestRaml<{}, {}>;
+    enums: TestRaml<{
+        String_Enumerated: typeof amf.ScalarShape;
+        String_Property_Enum: typeof amf.NodeShape;
+        CustomDates: typeof amf.AnyShape;
+        CustomCursorType: typeof amf.AnyShape;
+    }, {}>;
+    additionalProperties: TestRaml<{
+        Object_Simple: typeof amf.NodeShape;
+        AdditionalPropertiesScalar: typeof amf.NodeShape;
+        AdditionalPropertiesObject: typeof amf.NodeShape;
+    }, {}>;
+    oneofs: TestRaml<{
+        Object_Simple: typeof amf.NodeShape;
+        Object_Simple2: typeof amf.NodeShape;
+        OneOf: typeof amf.AnyShape;
+        OneOf_Complex: typeof amf.AnyShape;
+        OneOf_Inline_Inheritance: typeof amf.AnyShape;
+        OneOf_Inline_Helper: typeof amf.NodeShape;
+        OneOf_Inline_Properties: typeof amf.AnyShape;
+        OneOf_With_Optional_Properties: typeof amf.AnyShape;
+        CatOrDog: typeof amf.AnyShape;
+        Cat: typeof amf.NodeShape;
+        Dog: typeof amf.NodeShape;
+    }, {}>;
+    errors: TestRaml<{
+        CustomNonScalarOneOf: typeof amf.AnyShape;
+        CustomObjectEnumType: typeof amf.NodeShape;
+        CustomArrayEnumType: typeof amf.ArrayShape;
+        MissingPropertyType: typeof amf.NodeShape;
+    }, {}>;
+    base: TestRaml<{
+        Anonymous: typeof amf.AnyShape;
+        Identifiable: typeof amf.AnyShape;
+        AnnotatedError: typeof amf.AnyShape;
+    }, {}>;
+    defaults: {
+        apiOasUrl: TestRaml<{}, {}>;
+        errorRamlUrl: TestRaml<{}, {}>;
+        errorRamlUrl2: TestRaml<{}, {}>;
+    };
+    typeValidation: TestRaml<{}, {}>;
+    endpointValidation: TestRaml<{}, {}>;
+    invalidation: {
+        validOasUrl: TestRaml<{}, {}>;
+        keyNameInvalidOasUrl: TestRaml<{}, {}>;
+        keyValueInvalidOasUrl: TestRaml<{}, {}>;
+        keyValuePrefixInvalidOasUrl: TestRaml<{}, {}>;
+        invalidationInvalidOperationType: TestRaml<{}, {}>;
+        typeInvalidOasUrl: TestRaml<{}, {}>;
+        typeInvalidFormatOasUrl: TestRaml<{}, {}>;
+        typeUnidentifiableOasUrl: TestRaml<{}, {}>;
+        typeUnidentifiableInlineOasUrl: TestRaml<{}, {}>;
+    };
+}>;
+export declare function readSpecFile<T extends Record<string, new () => amf.AnyShape>, E extends Record<string, string>>(specFileName: string, types: T, endpoints: E): Promise<TestRaml<T, E>>;
+export {};

package/dist/types/v1/amf/__tests__/validation.spec.d.ts

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

package/dist/types/v1/amf/__tests__/version.spec.d.ts

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

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

@@ -0,0 +1,15 @@
+import type { API, APIService } from '../api';
+import type { NamedLoggerService } from '@conduit-client/utils';
+import type { NamedFeatureFlagsService } from '@conduit-client/service-feature-flags/v1';
+/**
+ * Returns a new APIService based on the AMF API code.
+ * @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/amf-extensions.d.ts

@@ -0,0 +1,2 @@
+import type amf from 'amf-client-js';
+export declare function extractExtensions(customDomainProperties: ReadonlyArray<amf.DomainExtension>): Record<string, unknown>;

package/dist/types/v1/amf/amf-utils.d.ts

@@ -0,0 +1,36 @@
+import amf from 'amf-client-js';
+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";
+export declare const LONG_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#long";
+export declare const FLOAT_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#float";
+export declare const DOUBLE_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#double";
+export declare const NUMBER_DATA_TYPE = "http://a.ml/vocabularies/shapes#number";
+export declare const DATE_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#date";
+export declare const TIME_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#time";
+export declare const PASSWORD_DATA_TYPE = "http://a.ml/vocabularies/shapes#password";
+export declare const BYTE_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#byte";
+export declare const BINARY_DATA_TYPE = "http://www.w3.org/2001/XMLSchema#base64Binary";
+export declare const DATETIME_ONLY_TYPE = "http://a.ml/vocabularies/shapes#dateTimeOnly";
+export declare const DATETIME_TYPE = "http://www.w3.org/2001/XMLSchema#dateTime";
+export declare const DATATYPE_TO_SCALAR_TYPE: Record<string, ScalarType['type']>;
+export declare function isDomainElement(maybeDomainElement: any): maybeDomainElement is amf.DomainElement;
+export declare function isTypeShape(domainElement: amf.DomainElement): domainElement is amf.AnyShape;
+export declare function isAnyShape(domainElement: amf.DomainElement): domainElement is amf.AnyShape;
+export declare function isNilShape(shape: amf.Shape): shape is amf.NilShape;
+export declare function isNodeShape(node: amf.Shape): node is amf.NodeShape;
+export declare function isArrayShape(node: amf.Shape): node is amf.ArrayShape;
+export declare function isScalarShape(shape: amf.Shape): shape is amf.ScalarShape;
+export declare function isRefShape(shape: amf.Shape): boolean;
+export declare function isStringScalarShape(shape: amf.ScalarShape): boolean;
+export declare function isAnyOfShape(shape: amf.Shape): boolean;
+export declare function isOneOfShape(shape: amf.Shape): shape is amf.UnionShape;
+export declare function isAllOfShape(shape: amf.Shape): boolean;
+export declare function isNotShape(shape: amf.Shape): boolean;
+export declare function isScalarNode(node: amf.DataNode): node is amf.ScalarNode;
+export declare function isEnumShape(shape: amf.Shape): boolean;
+export declare function getEnumValuesFromShape<T extends string | number | boolean | null>(shape: amf.ScalarShape | amf.UnionShape | amf.NilShape): T[];
+export declare function coerceValueByType<D extends string | any>(value: string, type: {
+    type: 'boolean' | 'double' | 'integer' | 'number' | 'string' | 'date' | 'time' | 'datetime-only';
+}): string | boolean | number | null | D;

package/dist/types/v1/amf/endpoints/__tests__/amf-endpoint.spec.d.ts

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

package/dist/types/v1/amf/endpoints/__tests__/amf-operation.spec.d.ts

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

package/dist/types/v1/amf/endpoints/amf-endpoint.d.ts

@@ -0,0 +1,32 @@
+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 { FileParserLogger, LoggerService } from '@conduit-client/utils';
+import type amf from 'amf-client-js';
+export type AmfEndPoint = AmfAuraEndpoint | AmfHttpEndPoint;
+export type NetworkPreference = 'aura' | 'http';
+export declare function amfEndpointFactory(amfEndpoint: amf.EndPoint, amfTypeFactory: AMFTypeFactory, typeRegistry: TypeRegistry<AMFType>, logger: LoggerService, fileParserLogger: FileParserLogger, server: Server, api: API): AmfEndPoint | undefined;
+export declare abstract class AmfBaseEndpoint implements BaseEndPoint {
+    protected amfEndpoint: amf.EndPoint;
+    operations: ReadonlyArray<Operation>;
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    api: API;
+    path: string;
+    uriParameters: Record<string, Parameter>;
+    abstract type: 'aura' | 'http';
+    constructor(amfEndpoint: amf.EndPoint, operations: ReadonlyArray<Operation>, amfTypeFactory: AMFTypeFactory, typeRegistry: TypeRegistry<AMFType>, logger: LoggerService, fileParserLogger: FileParserLogger, api: API);
+}
+export declare class AmfHttpEndPoint extends AmfBaseEndpoint implements HttpEndPoint {
+    readonly type = "http";
+}
+export declare class AmfAuraEndpoint extends AmfBaseEndpoint implements AuraEndPoint {
+    protected logger: LoggerService;
+    protected fileParserLogger: FileParserLogger;
+    api: API;
+    networkPreference: NetworkPreference;
+    readonly type = "aura";
+    auraController: AuraController;
+    constructor(amfEndPoint: amf.EndPoint, operations: Operation[], amfTypeFactory: AMFTypeFactory, typeRegistry: TypeRegistry<AMFType>, logger: LoggerService, fileParserLogger: FileParserLogger, api: API, networkPreference: NetworkPreference);
+    buildAuraController(): AuraController;
+}