@product-live/api-sdk 2.5.1 → 2.10.0

package/apis/baseapi.ts

@@ -0,0 +1,37 @@
+import { Configuration } from '../configuration'
+
+/**
+ *
+ * @export
+ */
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+
+/**
+ *
+ * @export
+ * @class BaseAPI
+ */
+export class BaseAPIRequestFactory {
+
+    constructor(protected configuration: Configuration) {
+    }
+};
+
+/**
+ *
+ * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+export class RequiredError extends Error {
+    name: "RequiredError" = "RequiredError";
+    constructor(public api: string, public method: string, public field: string) {
+        super("Required parameter " + field + " was null or undefined when calling " + api + "." + method + ".");
+    }
+}

package/apis/exception.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents an error caused by an api call i.e. it has attributes for a HTTP status code
+ * and the returned body object.
+ *
+ * Example
+ * API returns a ErrorMessageObject whenever HTTP status code is not in [200, 299]
+ * => ApiException(404, someErrorMessageObject)
+ *
+ */
+export class ApiException<T> extends Error {
+    public constructor(public code: number, message: string, public body: T, public headers: { [key: string]: string; }) {
+        super("HTTP-Code: " + code + "\nMessage: " + message + "\nBody: " + JSON.stringify(body) + "\nHeaders: " +
+        JSON.stringify(headers))
+    }
+}

package/auth/auth.ts

@@ -0,0 +1,107 @@
+import { RequestContext } from "../http/http";
+
+/**
+ * Interface authentication schemes.
+ */
+export interface SecurityAuthentication {
+    /*
+     * @return returns the name of the security authentication as specified in OAI
+     */
+    getName(): string;
+
+    /**
+     * Applies the authentication scheme to the request context
+     *
+     * @params context the request context which should use this authentication scheme
+     */
+    applySecurityAuthentication(context: RequestContext): void | Promise<void>;
+}
+
+export interface TokenProvider {
+  getToken(): Promise<string> | string;
+}
+
+/**
+ * Applies apiKey authentication to the request context.
+ */
+export class ApiKeyAuthHeaderAuthentication implements SecurityAuthentication {
+    /**
+     * Configures this api key authentication with the necessary properties
+     *
+     * @param apiKey: The api key to be used for every request
+     */
+    public constructor(private apiKey: string) {}
+
+    public getName(): string {
+        return "ApiKeyAuthHeader";
+    }
+
+    public applySecurityAuthentication(context: RequestContext) {
+        context.setHeaderParam("X-Api-Key", this.apiKey);
+    }
+}
+
+/**
+ * Applies apiKey authentication to the request context.
+ */
+export class ApiKeyAuthQueryAuthentication implements SecurityAuthentication {
+    /**
+     * Configures this api key authentication with the necessary properties
+     *
+     * @param apiKey: The api key to be used for every request
+     */
+    public constructor(private apiKey: string) {}
+
+    public getName(): string {
+        return "ApiKeyAuthQuery";
+    }
+
+    public applySecurityAuthentication(context: RequestContext) {
+        context.setQueryParam("api_key", this.apiKey);
+    }
+}
+
+
+export type AuthMethods = {
+    "default"?: SecurityAuthentication,
+    "ApiKeyAuthHeader"?: SecurityAuthentication,
+    "ApiKeyAuthQuery"?: SecurityAuthentication
+}
+
+export type ApiKeyConfiguration = string;
+export type HttpBasicConfiguration = { "username": string, "password": string };
+export type HttpBearerConfiguration = { tokenProvider: TokenProvider };
+export type OAuth2Configuration = { accessToken: string };
+
+export type AuthMethodsConfiguration = {
+    "default"?: SecurityAuthentication,
+    "ApiKeyAuthHeader"?: ApiKeyConfiguration,
+    "ApiKeyAuthQuery"?: ApiKeyConfiguration
+}
+
+/**
+ * Creates the authentication methods from a swagger description.
+ *
+ */
+export function configureAuthMethods(config: AuthMethodsConfiguration | undefined): AuthMethods {
+    let authMethods: AuthMethods = {}
+
+    if (!config) {
+        return authMethods;
+    }
+    authMethods["default"] = config["default"]
+
+    if (config["ApiKeyAuthHeader"]) {
+        authMethods["ApiKeyAuthHeader"] = new ApiKeyAuthHeaderAuthentication(
+            config["ApiKeyAuthHeader"]
+        );
+    }
+
+    if (config["ApiKeyAuthQuery"]) {
+        authMethods["ApiKeyAuthQuery"] = new ApiKeyAuthQueryAuthentication(
+            config["ApiKeyAuthQuery"]
+        );
+    }
+
+    return authMethods;
+}

package/configuration.ts

@@ -0,0 +1,82 @@
+import { HttpLibrary } from "./http/http";
+import { Middleware, PromiseMiddleware, PromiseMiddlewareWrapper } from "./middleware";
+import { IsomorphicFetchHttpLibrary as DefaultHttpLibrary } from "./http/isomorphic-fetch";
+import { BaseServerConfiguration, server1 } from "./servers";
+import { configureAuthMethods, AuthMethods, AuthMethodsConfiguration } from "./auth/auth";
+
+export interface Configuration {
+    readonly baseServer: BaseServerConfiguration;
+    readonly httpApi: HttpLibrary;
+    readonly middleware: Middleware[];
+    readonly authMethods: AuthMethods;
+}
+
+
+/**
+ * Interface with which a configuration object can be configured.
+ */
+export interface ConfigurationParameters {
+    /**
+     * Default server to use - a list of available servers (according to the 
+     * OpenAPI yaml definition) is included in the `servers` const in `./servers`. You can also
+     * create your own server with the `ServerConfiguration` class from the same 
+     * file.
+     */
+    baseServer?: BaseServerConfiguration;
+    /**
+     * HTTP library to use e.g. IsomorphicFetch. This can usually be skipped as 
+     * all generators come with a default library.
+     * If available, additional libraries can be imported from `./http/*`
+     */
+    httpApi?: HttpLibrary;
+
+    /**
+     * The middlewares which will be applied to requests and responses. You can 
+     * add any number of middleware components to modify requests before they 
+     * are sent or before they are deserialized by implementing the `Middleware`
+     * interface defined in `./middleware`
+     */
+    middleware?: Middleware[];
+    /**
+     * Configures middleware functions that return promises instead of 
+     * Observables (which are used by `middleware`). Otherwise allows for the 
+     * same functionality as `middleware`, i.e., modifying requests before they 
+     * are sent and before they are deserialized.
+     */
+    promiseMiddleware?: PromiseMiddleware[];
+    /**
+     * Configuration for the available authentication methods (e.g., api keys) 
+     * according to the OpenAPI yaml definition. For the definition, please refer to 
+     * `./auth/auth`
+     */
+    authMethods?: AuthMethodsConfiguration
+}
+
+/**
+ * Provide your `ConfigurationParameters` to this function to get a `Configuration`
+ * object that can be used to configure your APIs (in the constructor or 
+ * for each request individually).
+ *
+ * If a property is not included in conf, a default is used:
+ *    - baseServer: server1
+ *    - httpApi: IsomorphicFetchHttpLibrary
+ *    - middleware: []
+ *    - promiseMiddleware: []
+ *    - authMethods: {}
+ *
+ * @param conf partial configuration
+ */
+export function createConfiguration(conf: ConfigurationParameters = {}): Configuration {
+    const configuration: Configuration = {
+        baseServer: conf.baseServer !== undefined ? conf.baseServer : server1,
+        httpApi: conf.httpApi || new DefaultHttpLibrary(),
+        middleware: conf.middleware || [],
+        authMethods: configureAuthMethods(conf.authMethods)
+    };
+    if (conf.promiseMiddleware) {
+        conf.promiseMiddleware.forEach(
+            m => configuration.middleware.push(new PromiseMiddlewareWrapper(m))
+        );
+    }
+    return configuration;
+}

package/dist/apis/DataFactoryFileApi.d.ts

@@ -1,20 +1,15 @@
-import * as runtime from '../runtime';
-import type { FileDto, GetFiles200Response } from '../models';
-export interface GetFileByIdRequest {
-    id: string;
-}
-export interface GetFilesRequest {
-    size?: number;
-    page?: number;
-}
-export interface UploadFileRequest {
-    file: Blob;
-}
-export declare class DataFactoryFileApi extends runtime.BaseAPI {
-    getFileByIdRaw(requestParameters: GetFileByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileDto>>;
-    getFileById(requestParameters: GetFileByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDto>;
-    getFilesRaw(requestParameters: GetFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetFiles200Response>>;
-    getFiles(requestParameters?: GetFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetFiles200Response>;
-    uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileDto>>;
-    uploadFile(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileDto>;
+import { BaseAPIRequestFactory } from './baseapi';
+import { Configuration } from '../configuration';
+import { RequestContext, ResponseContext, HttpFile } from '../http/http';
+import { FileDto } from '../models/FileDto';
+import { GetFiles200Response } from '../models/GetFiles200Response';
+export declare class DataFactoryFileApiRequestFactory extends BaseAPIRequestFactory {
+    getFileById(id: string, _options?: Configuration): Promise<RequestContext>;
+    getFiles(size?: number, page?: number, _options?: Configuration): Promise<RequestContext>;
+    uploadFile(file: HttpFile, _options?: Configuration): Promise<RequestContext>;
+}
+export declare class DataFactoryFileApiResponseProcessor {
+    getFileById(response: ResponseContext): Promise<FileDto>;
+    getFiles(response: ResponseContext): Promise<GetFiles200Response>;
+    uploadFile(response: ResponseContext): Promise<FileDto>;
 }