@quantum-hub/qhub-api 1.0.10 → 1.0.13

package/src/api/service/auth/index.ts

@@ -1 +0,0 @@
-export { BearerAuthProvider } from "./BearerAuthProvider.js";

package/src/api/service/core/auth/AuthProvider.ts

@@ -1,6 +0,0 @@
-import type { EndpointMetadata } from "../fetcher/EndpointMetadata.js";
-import type { AuthRequest } from "./AuthRequest.js";
-
-export interface AuthProvider {
-    getAuthRequest(arg?: { endpointMetadata?: EndpointMetadata }): Promise<AuthRequest>;
-}

package/src/api/service/core/auth/AuthRequest.ts

@@ -1,9 +0,0 @@
-/**
- * Request parameters for authentication requests.
- */
-export interface AuthRequest {
-    /**
-     * The headers to be included in the request.
-     */
-    headers: Record<string, string>;
-}

package/src/api/service/core/auth/BasicAuth.ts

@@ -1,32 +0,0 @@
-import { base64Decode, base64Encode } from "../base64.js";
-
-export interface BasicAuth {
-    username: string;
-    password: string;
-}
-
-const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
-
-export const BasicAuth = {
-    toAuthorizationHeader: (basicAuth: BasicAuth | undefined): string | undefined => {
-        if (basicAuth == null) {
-            return undefined;
-        }
-        const token = base64Encode(`${basicAuth.username}:${basicAuth.password}`);
-        return `Basic ${token}`;
-    },
-    fromAuthorizationHeader: (header: string): BasicAuth => {
-        const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
-        const decoded = base64Decode(credentials);
-        const [username, ...passwordParts] = decoded.split(":");
-        const password = passwordParts.length > 0 ? passwordParts.join(":") : undefined;
-
-        if (username == null || password == null) {
-            throw new Error("Invalid basic auth");
-        }
-        return {
-            username,
-            password,
-        };
-    },
-};

package/src/api/service/core/auth/BearerToken.ts

@@ -1,20 +0,0 @@
-export type BearerToken = string;
-
-const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
-
-function toAuthorizationHeader(token: string | undefined): string | undefined {
-    if (token == null) {
-        return undefined;
-    }
-    return `Bearer ${token}`;
-}
-
-export const BearerToken: {
-    toAuthorizationHeader: typeof toAuthorizationHeader;
-    fromAuthorizationHeader: (header: string) => BearerToken;
-} = {
-    toAuthorizationHeader: toAuthorizationHeader,
-    fromAuthorizationHeader: (header: string): BearerToken => {
-        return header.replace(BEARER_AUTH_HEADER_PREFIX, "").trim() as BearerToken;
-    },
-};

package/src/api/service/core/auth/NoOpAuthProvider.ts

@@ -1,8 +0,0 @@
-import type { AuthProvider } from "./AuthProvider.js";
-import type { AuthRequest } from "./AuthRequest.js";
-
-export class NoOpAuthProvider implements AuthProvider {
-    public getAuthRequest(): Promise<AuthRequest> {
-        return Promise.resolve({ headers: {} });
-    }
-}

package/src/api/service/core/fetcher/EndpointMetadata.ts

@@ -1,13 +0,0 @@
-export type SecuritySchemeKey = string;
-/**
- * A collection of security schemes, where the key is the name of the security scheme and the value is the list of scopes required for that scheme.
- * All schemes in the collection must be satisfied for authentication to be successful.
- */
-export type SecuritySchemeCollection = Record<SecuritySchemeKey, AuthScope[]>;
-export type AuthScope = string;
-export type EndpointMetadata = {
-    /**
-     * An array of security scheme collections. Each collection represents an alternative way to authenticate.
-     */
-    security?: SecuritySchemeCollection[];
-};

package/src/api/service/core/fetcher/EndpointSupplier.ts

@@ -1,14 +0,0 @@
-import type { EndpointMetadata } from "./EndpointMetadata.js";
-import type { Supplier } from "./Supplier.js";
-
-type EndpointSupplierFn<T> = (arg: { endpointMetadata?: EndpointMetadata }) => T | Promise<T>;
-export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
-export const EndpointSupplier = {
-    get: async <T>(supplier: EndpointSupplier<T>, arg: { endpointMetadata?: EndpointMetadata }): Promise<T> => {
-        if (typeof supplier === "function") {
-            return (supplier as EndpointSupplierFn<T>)(arg);
-        } else {
-            return supplier;
-        }
-    },
-};

package/src/api/service/core/fetcher/Headers.ts

@@ -1,93 +0,0 @@
-let Headers: typeof globalThis.Headers;
-
-if (typeof globalThis.Headers !== "undefined") {
-    Headers = globalThis.Headers;
-} else {
-    Headers = class Headers implements Headers {
-        private headers: Map<string, string[]>;
-
-        constructor(init?: HeadersInit) {
-            this.headers = new Map();
-
-            if (init) {
-                if (init instanceof Headers) {
-                    init.forEach((value, key) => this.append(key, value));
-                } else if (Array.isArray(init)) {
-                    for (const [key, value] of init) {
-                        if (typeof key === "string" && typeof value === "string") {
-                            this.append(key, value);
-                        } else {
-                            throw new TypeError("Each header entry must be a [string, string] tuple");
-                        }
-                    }
-                } else {
-                    for (const [key, value] of Object.entries(init)) {
-                        if (typeof value === "string") {
-                            this.append(key, value);
-                        } else {
-                            throw new TypeError("Header values must be strings");
-                        }
-                    }
-                }
-            }
-        }
-
-        append(name: string, value: string): void {
-            const key = name.toLowerCase();
-            const existing = this.headers.get(key) || [];
-            this.headers.set(key, [...existing, value]);
-        }
-
-        delete(name: string): void {
-            const key = name.toLowerCase();
-            this.headers.delete(key);
-        }
-
-        get(name: string): string | null {
-            const key = name.toLowerCase();
-            const values = this.headers.get(key);
-            return values ? values.join(", ") : null;
-        }
-
-        has(name: string): boolean {
-            const key = name.toLowerCase();
-            return this.headers.has(key);
-        }
-
-        set(name: string, value: string): void {
-            const key = name.toLowerCase();
-            this.headers.set(key, [value]);
-        }
-
-        forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: unknown): void {
-            const boundCallback = thisArg ? callbackfn.bind(thisArg) : callbackfn;
-            this.headers.forEach((values, key) => boundCallback(values.join(", "), key, this));
-        }
-
-        getSetCookie(): string[] {
-            return this.headers.get("set-cookie") || [];
-        }
-
-        *entries(): HeadersIterator<[string, string]> {
-            for (const [key, values] of this.headers.entries()) {
-                yield [key, values.join(", ")];
-            }
-        }
-
-        *keys(): HeadersIterator<string> {
-            yield* this.headers.keys();
-        }
-
-        *values(): HeadersIterator<string> {
-            for (const values of this.headers.values()) {
-                yield values.join(", ");
-            }
-        }
-
-        [Symbol.iterator](): HeadersIterator<[string, string]> {
-            return this.entries();
-        }
-    };
-}
-
-export { Headers };

package/src/api/service/core/fetcher/HttpResponsePromise.ts

@@ -1,116 +0,0 @@
-import type { WithRawResponse } from "./RawResponse.js";
-
-/**
- * A promise that returns the parsed response and lets you retrieve the raw response too.
- */
-export class HttpResponsePromise<T> extends Promise<T> {
-    private innerPromise: Promise<WithRawResponse<T>>;
-    private unwrappedPromise: Promise<T> | undefined;
-
-    private constructor(promise: Promise<WithRawResponse<T>>) {
-        // Initialize with a no-op to avoid premature parsing
-        super((resolve) => {
-            resolve(undefined as unknown as T);
-        });
-        this.innerPromise = promise;
-    }
-
-    /**
-     * Creates an `HttpResponsePromise` from a function that returns a promise.
-     *
-     * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
-     * @param args - Arguments to pass to the function.
-     * @returns An `HttpResponsePromise` instance.
-     */
-    public static fromFunction<F extends (...args: never[]) => Promise<WithRawResponse<T>>, T>(
-        fn: F,
-        ...args: Parameters<F>
-    ): HttpResponsePromise<T> {
-        return new HttpResponsePromise<T>(fn(...args));
-    }
-
-    /**
-     * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise.
-     *
-     * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
-     * @returns A function that returns an `HttpResponsePromise` instance.
-     */
-    public static interceptFunction<
-        F extends (...args: never[]) => Promise<WithRawResponse<T>>,
-        T = Awaited<ReturnType<F>>["data"],
-    >(fn: F): (...args: Parameters<F>) => HttpResponsePromise<T> {
-        return (...args: Parameters<F>): HttpResponsePromise<T> => {
-            return HttpResponsePromise.fromPromise<T>(fn(...args));
-        };
-    }
-
-    /**
-     * Creates an `HttpResponsePromise` from an existing promise.
-     *
-     * @param promise - A promise resolving to a `WithRawResponse` object.
-     * @returns An `HttpResponsePromise` instance.
-     */
-    public static fromPromise<T>(promise: Promise<WithRawResponse<T>>): HttpResponsePromise<T> {
-        return new HttpResponsePromise<T>(promise);
-    }
-
-    /**
-     * Creates an `HttpResponsePromise` from an executor function.
-     *
-     * @param executor - A function that takes resolve and reject callbacks to create a promise.
-     * @returns An `HttpResponsePromise` instance.
-     */
-    public static fromExecutor<T>(
-        executor: (resolve: (value: WithRawResponse<T>) => void, reject: (reason?: unknown) => void) => void,
-    ): HttpResponsePromise<T> {
-        const promise = new Promise<WithRawResponse<T>>(executor);
-        return new HttpResponsePromise<T>(promise);
-    }
-
-    /**
-     * Creates an `HttpResponsePromise` from a resolved result.
-     *
-     * @param result - A `WithRawResponse` object to resolve immediately.
-     * @returns An `HttpResponsePromise` instance.
-     */
-    public static fromResult<T>(result: WithRawResponse<T>): HttpResponsePromise<T> {
-        const promise = Promise.resolve(result);
-        return new HttpResponsePromise<T>(promise);
-    }
-
-    private unwrap(): Promise<T> {
-        if (!this.unwrappedPromise) {
-            this.unwrappedPromise = this.innerPromise.then(({ data }) => data);
-        }
-        return this.unwrappedPromise;
-    }
-
-    /** @inheritdoc */
-    public override then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-        onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
-    ): Promise<TResult1 | TResult2> {
-        return this.unwrap().then(onfulfilled, onrejected);
-    }
-
-    /** @inheritdoc */
-    public override catch<TResult = never>(
-        onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
-    ): Promise<T | TResult> {
-        return this.unwrap().catch(onrejected);
-    }
-
-    /** @inheritdoc */
-    public override finally(onfinally?: (() => void) | null): Promise<T> {
-        return this.unwrap().finally(onfinally);
-    }
-
-    /**
-     * Retrieves the data and raw response.
-     *
-     * @returns A promise resolving to a `WithRawResponse` object.
-     */
-    public async withRawResponse(): Promise<WithRawResponse<T>> {
-        return await this.innerPromise;
-    }
-}

package/src/api/service/core/fetcher/Supplier.ts

@@ -1,11 +0,0 @@
-export type Supplier<T> = T | Promise<T> | (() => T | Promise<T>);
-
-export const Supplier = {
-    get: async <T>(supplier: Supplier<T>): Promise<T> => {
-        if (typeof supplier === "function") {
-            return (supplier as () => T)();
-        } else {
-            return supplier;
-        }
-    },
-};

package/src/api/service/core/fetcher/createRequestUrl.ts

@@ -1,6 +0,0 @@
-import { toQueryString } from "../url/qs.js";
-
-export function createRequestUrl(baseUrl: string, queryParameters?: Record<string, unknown>): string {
-    const queryString = toQueryString(queryParameters, { arrayFormat: "repeat" });
-    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
-}

package/src/api/service/core/fetcher/getFetchFn.ts

@@ -1,3 +0,0 @@
-export async function getFetchFn(): Promise<typeof fetch> {
-    return fetch;
-}

package/src/api/service/core/fetcher/getHeader.ts

@@ -1,8 +0,0 @@
-export function getHeader(headers: Record<string, any>, header: string): string | undefined {
-    for (const [headerKey, headerValue] of Object.entries(headers)) {
-        if (headerKey.toLowerCase() === header.toLowerCase()) {
-            return headerValue;
-        }
-    }
-    return undefined;
-}

package/src/api/service/core/fetcher/getRequestBody.ts

@@ -1,20 +0,0 @@
-import { toJson } from "../json.js";
-import { toQueryString } from "../url/qs.js";
-
-export declare namespace GetRequestBody {
-    interface Args {
-        body: unknown;
-        type: "json" | "file" | "bytes" | "form" | "other";
-    }
-}
-
-export async function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined> {
-    if (type === "form") {
-        return toQueryString(body, { arrayFormat: "repeat", encode: true });
-    }
-    if (type.includes("json")) {
-        return toJson(body);
-    } else {
-        return body as BodyInit;
-    }
-}

package/src/api/service/core/fetcher/getResponseBody.ts

@@ -1,58 +0,0 @@
-import { fromJson } from "../json.js";
-import { getBinaryResponse } from "./BinaryResponse.js";
-
-export async function getResponseBody(response: Response, responseType?: string): Promise<unknown> {
-    switch (responseType) {
-        case "binary-response":
-            return getBinaryResponse(response);
-        case "blob":
-            return await response.blob();
-        case "arrayBuffer":
-            return await response.arrayBuffer();
-        case "sse":
-            if (response.body == null) {
-                return {
-                    ok: false,
-                    error: {
-                        reason: "body-is-null",
-                        statusCode: response.status,
-                    },
-                };
-            }
-            return response.body;
-        case "streaming":
-            if (response.body == null) {
-                return {
-                    ok: false,
-                    error: {
-                        reason: "body-is-null",
-                        statusCode: response.status,
-                    },
-                };
-            }
-
-            return response.body;
-
-        case "text":
-            return await response.text();
-    }
-
-    // if responseType is "json" or not specified, try to parse as JSON
-    const text = await response.text();
-    if (text.length > 0) {
-        try {
-            const responseBody = fromJson(text);
-            return responseBody;
-        } catch (_err) {
-            return {
-                ok: false,
-                error: {
-                    reason: "non-json",
-                    statusCode: response.status,
-                    rawBody: text,
-                },
-            };
-        }
-    }
-    return undefined;
-}

package/src/api/service/core/fetcher/requestWithRetries.ts

@@ -1,64 +0,0 @@
-const INITIAL_RETRY_DELAY = 1000; // in milliseconds
-const MAX_RETRY_DELAY = 60000; // in milliseconds
-const DEFAULT_MAX_RETRIES = 2;
-const JITTER_FACTOR = 0.2; // 20% random jitter
-
-function addPositiveJitter(delay: number): number {
-    const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
-    return delay * jitterMultiplier;
-}
-
-function addSymmetricJitter(delay: number): number {
-    const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
-    return delay * jitterMultiplier;
-}
-
-function getRetryDelayFromHeaders(response: Response, retryAttempt: number): number {
-    const retryAfter = response.headers.get("Retry-After");
-    if (retryAfter) {
-        const retryAfterSeconds = parseInt(retryAfter, 10);
-        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
-            return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
-        }
-
-        const retryAfterDate = new Date(retryAfter);
-        if (!Number.isNaN(retryAfterDate.getTime())) {
-            const delay = retryAfterDate.getTime() - Date.now();
-            if (delay > 0) {
-                return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
-            }
-        }
-    }
-
-    const rateLimitReset = response.headers.get("X-RateLimit-Reset");
-    if (rateLimitReset) {
-        const resetTime = parseInt(rateLimitReset, 10);
-        if (!Number.isNaN(resetTime)) {
-            const delay = resetTime * 1000 - Date.now();
-            if (delay > 0) {
-                return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
-            }
-        }
-    }
-
-    return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * 2 ** retryAttempt, MAX_RETRY_DELAY));
-}
-
-export async function requestWithRetries(
-    requestFn: () => Promise<Response>,
-    maxRetries: number = DEFAULT_MAX_RETRIES,
-): Promise<Response> {
-    let response: Response = await requestFn();
-
-    for (let i = 0; i < maxRetries; ++i) {
-        if ([408, 429].includes(response.status) || response.status >= 500) {
-            const delay = getRetryDelayFromHeaders(response, i);
-
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            response = await requestFn();
-        } else {
-            break;
-        }
-    }
-    return response!;
-}

package/src/api/service/core/fetcher/signals.ts

@@ -1,26 +0,0 @@
-const TIMEOUT = "timeout";
-
-export function getTimeoutSignal(timeoutMs: number): { signal: AbortSignal; abortId: ReturnType<typeof setTimeout> } {
-    const controller = new AbortController();
-    const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
-    return { signal: controller.signal, abortId };
-}
-
-export function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal {
-    const signals = (args.length === 1 && Array.isArray(args[0]) ? args[0] : args) as AbortSignal[];
-
-    const controller = new AbortController();
-
-    for (const signal of signals) {
-        if (signal.aborted) {
-            controller.abort((signal as any)?.reason);
-            break;
-        }
-
-        signal.addEventListener("abort", () => controller.abort((signal as any)?.reason), {
-            signal: controller.signal,
-        });
-    }
-
-    return controller.signal;
-}

package/src/api/service/core/headers.ts

@@ -1,33 +0,0 @@
-export function mergeHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-
-    for (const [key, value] of headersArray
-        .filter((headers) => headers != null)
-        .flatMap((headers) => Object.entries(headers))) {
-        const insensitiveKey = key.toLowerCase();
-        if (value != null) {
-            result[insensitiveKey] = value;
-        } else if (insensitiveKey in result) {
-            delete result[insensitiveKey];
-        }
-    }
-
-    return result;
-}
-
-export function mergeOnlyDefinedHeaders(
-    ...headersArray: (Record<string, unknown> | null | undefined)[]
-): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-
-    for (const [key, value] of headersArray
-        .filter((headers) => headers != null)
-        .flatMap((headers) => Object.entries(headers))) {
-        const insensitiveKey = key.toLowerCase();
-        if (value != null) {
-            result[insensitiveKey] = value;
-        }
-    }
-
-    return result;
-}

package/src/api/service/core/logging/exports.ts

@@ -1,19 +0,0 @@
-import * as logger from "./logger.js";
-
-export namespace logging {
-    /**
-     * Configuration for logger instances.
-     */
-    export type LogConfig = logger.LogConfig;
-    export type LogLevel = logger.LogLevel;
-    export const LogLevel: typeof logger.LogLevel = logger.LogLevel;
-    export type ILogger = logger.ILogger;
-    /**
-     * Console logger implementation that outputs to the console.
-     */
-    export type ConsoleLogger = logger.ConsoleLogger;
-    /**
-     * Console logger implementation that outputs to the console.
-     */
-    export const ConsoleLogger: typeof logger.ConsoleLogger = logger.ConsoleLogger;
-}

package/src/api/service/core/logging/index.ts

@@ -1 +0,0 @@
-export * from "./logger.js";

package/src/api/service/core/url/qs.ts

@@ -1,74 +0,0 @@
-interface QueryStringOptions {
-    arrayFormat?: "indices" | "repeat";
-    encode?: boolean;
-}
-
-const defaultQsOptions: Required<QueryStringOptions> = {
-    arrayFormat: "indices",
-    encode: true,
-} as const;
-
-function encodeValue(value: unknown, shouldEncode: boolean): string {
-    if (value === undefined) {
-        return "";
-    }
-    if (value === null) {
-        return "";
-    }
-    const stringValue = String(value);
-    return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
-}
-
-function stringifyObject(obj: Record<string, unknown>, prefix = "", options: Required<QueryStringOptions>): string[] {
-    const parts: string[] = [];
-
-    for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}[${key}]` : key;
-
-        if (value === undefined) {
-            continue;
-        }
-
-        if (Array.isArray(value)) {
-            if (value.length === 0) {
-                continue;
-            }
-            for (let i = 0; i < value.length; i++) {
-                const item = value[i];
-                if (item === undefined) {
-                    continue;
-                }
-                if (typeof item === "object" && !Array.isArray(item) && item !== null) {
-                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
-                    parts.push(...stringifyObject(item as Record<string, unknown>, arrayKey, options));
-                } else {
-                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
-                    const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
-                    parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
-                }
-            }
-        } else if (typeof value === "object" && value !== null) {
-            if (Object.keys(value as Record<string, unknown>).length === 0) {
-                continue;
-            }
-            parts.push(...stringifyObject(value as Record<string, unknown>, fullKey, options));
-        } else {
-            const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
-            parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
-        }
-    }
-
-    return parts;
-}
-
-export function toQueryString(obj: unknown, options?: QueryStringOptions): string {
-    if (obj == null || typeof obj !== "object") {
-        return "";
-    }
-
-    const parts = stringifyObject(obj as Record<string, unknown>, "", {
-        ...defaultQsOptions,
-        ...options,
-    });
-    return parts.join("&");
-}

package/src/api/service/environments.ts

@@ -1,7 +0,0 @@
-// This file was auto-generated by Fern from our API Definition.
-
-export const HubServiceEnvironment = {
-    Default: "https://gateway.hub.kipu-quantum.com/<context>/<service>/<version>",
-} as const;
-
-export type HubServiceEnvironment = typeof HubServiceEnvironment.Default;