@quantum-hub/qhubctl 1.0.0

package/dist/commands/services/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tty_table_1 = __importDefault(require("tty-table"));
+const command_1 = require("../../model/command");
+const quantum_hub_service_1 = __importDefault(require("../../service/quantum-hub-service"));
+class Services extends command_1.AuthenticatedCommand {
+    static description = 'List all services of the current context.';
+    static examples = [
+        '$ qhubctl services',
+        '$ qhubctl services --json',
+        '$ qhubctl services --name "my-service"',
+        '$ qhubctl services --name "my-service" --json',
+        '$ qhubctl services --json --all',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({
+            description: 'output in JSON format',
+            default: false,
+        }),
+        name: core_1.Flags.string({
+            description: 'filter services by name (case-insensitive full match)',
+            required: false,
+        }),
+        all: core_1.Flags.boolean({
+            description: 'display all service properties (only available with --json)',
+            default: false,
+        }),
+    };
+    quantumHubService;
+    async init() {
+        const { flags } = await this.parse(Services);
+        await super.init(!flags.json);
+        this.quantumHubService = new quantum_hub_service_1.default(this, this.config, this.userConfig);
+    }
+    async run() {
+        const { flags } = await this.parse(Services);
+        // Validate flag combinations
+        if (flags.all && !flags.json) {
+            core_1.ux.warn('The --all flag can only be used with --json output. Continuing without --all.');
+        }
+        core_1.ux.action.start('Loading services');
+        let services = await this.quantumHubService.getServices();
+        core_1.ux.action.stop('Done');
+        // Filter by name if provided
+        if (flags.name) {
+            const nameFilter = flags.name.toLowerCase();
+            services = services.filter(service => service.name?.toLowerCase() === nameFilter);
+        }
+        const tableData = services
+            .map(service => ({ id: service.id, name: service.name }));
+        if (flags.json) {
+            core_1.ux.stdout(JSON.stringify(flags.all ? services : tableData, null, 2));
+            return;
+        }
+        const header = [
+            { value: "id", alias: "ID", align: "left" },
+            { value: "name", alias: "Name", align: "left" },
+        ];
+        const t = (0, tty_table_1.default)(header, tableData);
+        const contextName = this.userConfig.context?.displayName;
+        const filterInfo = flags.name ? ` (filtered by name: "${flags.name}")` : '';
+        core_1.ux.stdout(`Available services for ${contextName}${filterInfo}:`);
+        core_1.ux.stdout(t.render());
+        core_1.ux.stdout();
+    }
+}
+exports.default = Services;

package/dist/commands/set-context/index.d.ts

@@ -0,0 +1,17 @@
+import Account from '../../model/account';
+import { AuthenticatedCommand } from '../../model/command';
+import QuantumHubService from '../../service/quantum-hub-service';
+export default class SetContext extends AuthenticatedCommand {
+    static args: {
+        contextId: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    quantumHubService: QuantumHubService;
+    getPromptOptions(accounts: Account[]): {
+        name: string;
+        value: Account;
+    }[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/set-context/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+const command_1 = require("../../model/command");
+const quantum_hub_service_1 = __importDefault(require("../../service/quantum-hub-service"));
+const user_config_service_1 = require("../../service/user-config-service");
+class SetContext extends command_1.AuthenticatedCommand {
+    static args = {
+        contextId: core_1.Args.string(),
+    };
+    static description = 'Set the current context, i.e., the personal or organization account you are currently working with.';
+    static examples = [
+        '$ qhubctl set-context',
+        '$ qhubctl set-context <context-id>',
+    ];
+    quantumHubService;
+    getPromptOptions(accounts) {
+        const options = [];
+        for (const account of accounts) {
+            options.push({
+                name: account.isOrganization ? `${account.displayName} (Organization)` : account.displayName,
+                value: account,
+            });
+        }
+        return options;
+    }
+    async init() {
+        await super.init();
+        this.quantumHubService = new quantum_hub_service_1.default(this, this.config, this.userConfig);
+    }
+    async run() {
+        const { args } = await this.parse(SetContext);
+        const { contextId } = args;
+        let selectedContext;
+        if (!contextId) {
+            core_1.ux.action.start('Loading available contexts');
+        }
+        const accounts = await this.quantumHubService.getAccounts();
+        if (!contextId) {
+            core_1.ux.action.stop('Done');
+        }
+        if (contextId) {
+            selectedContext = accounts.find(account => account.id === contextId);
+        }
+        else {
+            const response = await inquirer_1.default.prompt({
+                choices: this.getPromptOptions(accounts),
+                message: 'Choose a context',
+                name: 'context',
+                type: 'list',
+            });
+            selectedContext = response.context;
+        }
+        if (!selectedContext) {
+            this.error(`Context with id "${contextId}" not found.`);
+        }
+        const userConfig = {
+            ...this.userConfig,
+            context: selectedContext,
+        };
+        (0, user_config_service_1.writeUserConfig)(this.config.configDir, userConfig);
+        core_1.ux.stdout(`Switched to context "${selectedContext?.displayName}".`);
+    }
+}
+exports.default = SetContext;

package/dist/commands/up/index.d.ts

@@ -0,0 +1,19 @@
+import { AuthenticatedCommand } from '../../model/command';
+import QuantumHubService from '../../service/quantum-hub-service';
+export default class Up extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-save-id': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    qhubService: QuantumHubService;
+    getOpenapi(): Promise<Blob | undefined>;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    private buildServiceJob;
+    private checkIfServiceExistsInPlatform;
+    private createService;
+    private updateService;
+}

package/dist/commands/up/index.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@inquirer/prompts");
+const core_1 = require("@oclif/core");
+const async_wait_until_1 = require("async-wait-until");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const kqh_1 = require("../../client/kqh");
+const stream_to_blob_1 = require("../../lib/stream-to-blob");
+const get_description_1 = require("../../lib/up/get-description");
+const zip_1 = require("../../lib/up/zip");
+const command_1 = require("../../model/command");
+const quantum_hub_service_1 = __importDefault(require("../../service/quantum-hub-service"));
+const service_config_service_1 = require("../../service/service-config-service");
+class Up extends command_1.AuthenticatedCommand {
+    static description = 'Creates or updates a service';
+    static examples = [
+        '$ qhubctl up',
+        '$ qhubctl up --no-save-id',
+        '$ qhubctl up --name "my-custom-service-name"',
+        '$ qhubctl up --name "test-service" --no-save-id',
+    ];
+    static flags = {
+        silent: core_1.Flags.boolean({
+            description: 'Suppresses all outputs, helpful when executed in a CI/CD pipeline.',
+            required: false,
+        }),
+        'no-save-id': core_1.Flags.boolean({
+            description: 'Prevents storing the created service ID in qhub.json file.',
+            required: false,
+        }),
+        name: core_1.Flags.string({
+            description: 'Override the service name from qhub.json with a custom name.',
+            required: false,
+        }),
+    };
+    qhubService;
+    async getOpenapi() {
+        const openapiYamlPath = node_path_1.default.join(process.cwd(), 'openapi.yaml');
+        const openapiYmlPath = node_path_1.default.join(process.cwd(), 'openapi.yml');
+        let openapi = undefined;
+        if (node_fs_1.default.existsSync(openapiYamlPath)) {
+            openapi = node_fs_1.default.createReadStream(openapiYamlPath, 'utf8');
+        }
+        else if (node_fs_1.default.existsSync(openapiYmlPath)) {
+            openapi = node_fs_1.default.createReadStream(openapiYmlPath, 'utf8');
+        }
+        if (openapi) {
+            return (0, stream_to_blob_1.streamToBlob)(openapi);
+        }
+        return undefined;
+    }
+    async init() {
+        await super.init();
+        this.qhubService = new quantum_hub_service_1.default(this, this.config, this.userConfig);
+    }
+    async run() {
+        const { flags } = await this.parse(Up);
+        const serviceConfig = (0, service_config_service_1.readServiceConfig)(process.cwd());
+        let createNewService = true;
+        const silentMode = flags.silent;
+        if (!('descriptionFile' in serviceConfig)) {
+            core_1.ux.stdout('Warning: Since version 2.14.0, the "description" property in qhub.json has changed to "descriptionFile".\nFor more information, visit: https://docs.hub.kipu-quantum.com/qhub-json-reference.html\n');
+        }
+        const deprecatedOpenapiFile = node_path_1.default.join(process.cwd(), 'openapi-spec.yml');
+        if (node_fs_1.default.existsSync(deprecatedOpenapiFile)) {
+            core_1.ux.warn('You are having the deprecated file "openapi-spec.yml" in your project. Please consider renaming it to "openapi.yaml".');
+        }
+        // if service already exists we update it
+        const serviceExistsInPlatform = await this.checkIfServiceExistsInPlatform(serviceConfig);
+        if (serviceConfig.serviceId && !serviceExistsInPlatform) {
+            core_1.ux.stdout(`We could not find a service with id '${serviceConfig.serviceId}' in the current context!`);
+            createNewService = await (0, prompts_1.confirm)({ message: 'Do you want to create a new service?' });
+            if (!createNewService) {
+                this.exit();
+            }
+        }
+        const serviceFiles = {
+            openapi: await this.getOpenapi(),
+            descriptionText: await (0, get_description_1.getDescriptionText)(process.cwd()),
+            sourceCode: await (0, zip_1.zipProjectFolder)('./'),
+        };
+        const service = serviceExistsInPlatform ?
+            await this.updateService(serviceConfig, serviceFiles, silentMode) :
+            await this.createService(serviceConfig, serviceFiles, silentMode, flags['no-save-id'], flags.name);
+        const serviceDefinition = service && service.serviceDefinitions && service.serviceDefinitions[0];
+        if (!serviceDefinition) {
+            this.error('Service definition not found');
+        }
+        const buildJob = await this.buildServiceJob(service, serviceDefinition, silentMode);
+        if (buildJob && buildJob.status === kqh_1.BuildJobDtoStatusEnum.Success) {
+            const msg = `Service ${serviceExistsInPlatform ? 'updated' : 'created'} \u{1F680}`;
+            if (silentMode) {
+                core_1.ux.stdout(msg);
+            }
+            else {
+                core_1.ux.action.stop(msg);
+            }
+        }
+        else if (buildJob && buildJob.status === kqh_1.BuildJobDtoStatusEnum.Failure) {
+            const { validationResult } = buildJob;
+            let reason = 'Failed creating service';
+            if (validationResult?.state === kqh_1.ValidationResultStateEnum.Error && validationResult.summary) {
+                reason = `${reason}: ${validationResult.summary}`;
+            }
+            if (silentMode) {
+                core_1.ux.stdout(reason);
+            }
+            else {
+                core_1.ux.action.stop(reason);
+            }
+        }
+        else {
+            const msg = 'Still pending, please check the platform UI to determine the status';
+            if (silentMode) {
+                core_1.ux.stdout(msg);
+            }
+            else {
+                core_1.ux.action.stop(msg);
+            }
+        }
+        this.exit();
+    }
+    async buildServiceJob(service, serviceDefinition, silentMode) {
+        let buildJob;
+        try {
+            await (0, async_wait_until_1.waitUntil)(async () => {
+                buildJob = await this.qhubService.getBuildJob(service, serviceDefinition);
+                if (!silentMode) {
+                    if (buildJob.step === kqh_1.BuildJobDtoStepEnum.BuildImage) {
+                        core_1.ux.action.start('Building Image (1/2)');
+                    }
+                    else if (buildJob.step === kqh_1.BuildJobDtoStepEnum.PushImage) {
+                        core_1.ux.action.start('Pushing Image (2/2)');
+                    }
+                }
+                return buildJob.status === kqh_1.BuildJobDtoStatusEnum.Success || buildJob.status === kqh_1.BuildJobDtoStatusEnum.Failure;
+            }, {
+                intervalBetweenAttempts: 5000, // every 5 seconds
+                timeout: silentMode ? 60 * 60 * 1000 : 20 * 60 * 1000, // silent mode: 60 minutes, normal: 20 minutes
+            });
+        }
+        catch (error) {
+            this.error('Error while waiting for the build job to finish: ' + error);
+        }
+        return buildJob;
+    }
+    async checkIfServiceExistsInPlatform(serviceConfig) {
+        if (serviceConfig.serviceId) {
+            try {
+                await this.qhubService.getService(serviceConfig.serviceId);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    async createService(serviceConfig, files, silentMode, noSaveId = false, customName) {
+        if (!silentMode) {
+            core_1.ux.action.start('Creating service');
+        }
+        // Override the service name if custom name is provided
+        const configToUse = { ...serviceConfig };
+        if (customName) {
+            configToUse.name = customName;
+        }
+        const service = await this.qhubService.createService(configToUse, files.sourceCode, files.openapi);
+        // Always set the service ID temporarily for subsequent operations
+        serviceConfig.serviceId = service?.id;
+        // Only persist to file if not using no-save-id flag
+        if (!noSaveId) {
+            (0, service_config_service_1.writeServiceConfig)(process.cwd(), serviceConfig);
+        }
+        // update description separately when creating a new service
+        if (files.descriptionText) {
+            await this.qhubService.updateDescription(serviceConfig, files.descriptionText);
+        }
+        // make sure we update the OpenAPI description if it exists
+        if (files.openapi) {
+            await this.qhubService.updateOpenapi(serviceConfig, files.openapi);
+        }
+        return service;
+    }
+    async updateService(serviceConfig, files, silentMode) {
+        if (!silentMode) {
+            core_1.ux.action.start('Updating service');
+        }
+        return this.qhubService.updateService(serviceConfig, files.descriptionText, files.sourceCode, files.openapi);
+    }
+}
+exports.default = Up;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/lib/command.d.ts

@@ -0,0 +1,6 @@
+import { StdioOptions } from "node:child_process";
+export declare const executeAsyncCommand: (command: string) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export declare const executeCommand: (command: string, stdioOption?: StdioOptions) => void;

package/dist/lib/command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = exports.executeAsyncCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+const executeAsyncCommand = async (command) => {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve({ stderr, stdout });
+            }
+        });
+    });
+};
+exports.executeAsyncCommand = executeAsyncCommand;
+const executeCommand = (command, stdioOption) => {
+    (0, node_child_process_1.execSync)(`${command}`, { stdio: stdioOption ?? 'inherit' });
+};
+exports.executeCommand = executeCommand;

package/dist/lib/debug.d.ts

@@ -0,0 +1 @@
+export declare const debugEnabled: () => boolean;

package/dist/lib/debug.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugEnabled = void 0;
+const debugEnabled = () => Boolean(process.env.DEBUG && process.env.DEBUG !== '');
+exports.debugEnabled = debugEnabled;

package/dist/lib/entrypoint-resolver.d.ts

@@ -0,0 +1,52 @@
+export interface EntrypointOptions {
+    entrypoint?: string;
+    package?: string;
+    method?: string;
+}
+export declare class EntrypointResolver {
+    /**
+     * Resolves the entrypoint string from various flag combinations.
+     * Defaults to "src.program:run" if no flags are provided.
+     *
+     * @param entryPoint - The CLI flags containing entrypoint options
+     * @returns The resolved entrypoint string in format "package.module:function"
+     */
+    static resolveEntrypoint(entryPoint: EntrypointOptions): string;
+    /**
+     * Validates an entrypoint string to ensure it follows the Python entry point specification.
+     * Supports formats:
+     * - `importable.module:function` (simple function)
+     * - `importable.module:Class.method` (class method)
+     *
+     * @param entrypoint - The entrypoint string to validate
+     * @throws Error if the entrypoint format is invalid
+     */
+    static validateEntrypoint(entrypoint: string): void;
+    /**
+     * Validates a Python module path according to Python identifier rules.
+     */
+    private static validateModulePath;
+    /**
+     * Validates a Python object path (function or Class.method).
+     */
+    private static validateObjectPath;
+    /**
+     * Checks if a string is a valid Python identifier.
+     * Python identifiers must start with letter or underscore, and contain only letters, numbers, underscores.
+     */
+    private static isValidPythonIdentifier;
+    /**
+     * Extracts the package path from an entrypoint string.
+     *
+     * @param entrypoint - The entrypoint string
+     * @returns The package path portion
+     */
+    static extractPackagePath(entrypoint: string): string;
+    /**
+     * Extracts the method name from an entrypoint string.
+     *
+     * @param entrypoint - The entrypoint string
+     * @returns The method name portion
+     */
+    static extractMethod(entrypoint: string): string;
+}

package/dist/lib/entrypoint-resolver.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntrypointResolver = void 0;
+const core_1 = require("@oclif/core");
+class EntrypointResolver {
+    /**
+     * Resolves the entrypoint string from various flag combinations.
+     * Defaults to "src.program:run" if no flags are provided.
+     *
+     * @param entryPoint - The CLI flags containing entrypoint options
+     * @returns The resolved entrypoint string in format "package.module:function"
+     */
+    static resolveEntrypoint(entryPoint) {
+        // If entrypoint flag is provided, use it directly (format: "package.module:function")
+        if (entryPoint.entrypoint) {
+            this.validateEntrypoint(entryPoint.entrypoint);
+            return entryPoint.entrypoint;
+        }
+        // If package and/or method flags are provided, construct the entrypoint
+        const packagePath = entryPoint.package || 'src.program';
+        const method = entryPoint.method || 'run';
+        const entrypoint = `${packagePath}:${method}`;
+        this.validateEntrypoint(entrypoint);
+        return entrypoint;
+    }
+    /**
+     * Validates an entrypoint string to ensure it follows the Python entry point specification.
+     * Supports formats:
+     * - `importable.module:function` (simple function)
+     * - `importable.module:Class.method` (class method)
+     *
+     * @param entrypoint - The entrypoint string to validate
+     * @throws Error if the entrypoint format is invalid
+     */
+    static validateEntrypoint(entrypoint) {
+        if (!entrypoint) {
+            throw new Error('Entrypoint cannot be empty');
+        }
+        const parts = entrypoint.split(':');
+        if (parts.length !== 2) {
+            throw new Error(`Invalid entrypoint format: "${entrypoint}". ` +
+                'Must contain exactly one colon separating module and object reference');
+        }
+        const [modulePath, objectPath] = parts;
+        // Check for empty parts first
+        if (!modulePath || !objectPath) {
+            throw new Error(`Invalid entrypoint format: "${entrypoint}". ` +
+                'Expected format: "package.module:function" or "package.module:Class.method"');
+        }
+        // Validate module path (importable.module)
+        this.validateModulePath(modulePath, entrypoint);
+        // Validate object path (function or Class.method)
+        this.validateObjectPath(objectPath, entrypoint);
+        // Warn if object path starts with underscore (private methods/classes)
+        if (objectPath.startsWith('_')) {
+            core_1.ux.warn(`Object "${objectPath}" starts with underscore. Make sure this is intended for a private object.`);
+        }
+    }
+    /**
+     * Validates a Python module path according to Python identifier rules.
+     */
+    static validateModulePath(modulePath, fullEntrypoint) {
+        // Check for leading/trailing dots or consecutive dots
+        if (modulePath.startsWith('.') || modulePath.endsWith('.')) {
+            throw new Error(`Invalid module path in entrypoint: "${modulePath}". ` +
+                'Module path should not start or end with dots.');
+        }
+        if (modulePath.includes('..')) {
+            throw new Error(`Invalid module path in entrypoint: "${modulePath}". ` +
+                'Module path should not contain consecutive dots.');
+        }
+        // Split by dots and validate each identifier
+        const moduleIdentifiers = modulePath.split('.');
+        for (const identifier of moduleIdentifiers) {
+            if (!this.isValidPythonIdentifier(identifier)) {
+                throw new Error(`Invalid entrypoint format: "${fullEntrypoint}". ` +
+                    `"${identifier}" is not a valid Python identifier in module path.`);
+            }
+        }
+    }
+    /**
+     * Validates a Python object path (function or Class.method).
+     */
+    static validateObjectPath(objectPath, fullEntrypoint) {
+        // Split by dots and validate each identifier
+        const objectIdentifiers = objectPath.split('.');
+        for (const identifier of objectIdentifiers) {
+            if (!this.isValidPythonIdentifier(identifier)) {
+                throw new Error(`Invalid entrypoint format: "${fullEntrypoint}". ` +
+                    `"${identifier}" is not a valid Python identifier in object path.`);
+            }
+        }
+    }
+    /**
+     * Checks if a string is a valid Python identifier.
+     * Python identifiers must start with letter or underscore, and contain only letters, numbers, underscores.
+     */
+    static isValidPythonIdentifier(identifier) {
+        if (!identifier)
+            return false;
+        // [a-zA-Z0-9_] == \w
+        return /^[a-zA-Z_]\w*$/.test(identifier);
+    }
+    /**
+     * Extracts the package path from an entrypoint string.
+     *
+     * @param entrypoint - The entrypoint string
+     * @returns The package path portion
+     */
+    static extractPackagePath(entrypoint) {
+        this.validateEntrypoint(entrypoint);
+        return entrypoint.split(':')[0];
+    }
+    /**
+     * Extracts the method name from an entrypoint string.
+     *
+     * @param entrypoint - The entrypoint string
+     * @returns The method name portion
+     */
+    static extractMethod(entrypoint) {
+        this.validateEntrypoint(entrypoint);
+        return entrypoint.split(':')[1];
+    }
+}
+exports.EntrypointResolver = EntrypointResolver;

package/dist/lib/error.d.ts

@@ -0,0 +1 @@
+export declare const handleError: (error: unknown) => Promise<string>;

package/dist/lib/error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = void 0;
+const kqh_1 = require("../client/kqh");
+const debug_1 = require("./debug");
+const fetch_1 = require("./fetch");
+const handleError = async (error) => {
+    if (error instanceof kqh_1.ResponseError) {
+        return (0, fetch_1.getErrorMessage)(error.response);
+    }
+    if (error instanceof kqh_1.FetchError) {
+        const errorMessage = error.cause ? error.cause.message : error.message;
+        return `Internal error occurred, please try again later (${errorMessage})`;
+    }
+    if ((0, debug_1.debugEnabled)()) {
+        console.error(JSON.stringify(error));
+    }
+    return 'Internal error occurred, please contact your KQH administrator';
+};
+exports.handleError = handleError;

package/dist/lib/fetch.d.ts

@@ -0,0 +1,7 @@
+export declare class PlatformError extends Error {
+    response: Response;
+    constructor(response: Response);
+    getErrorMessage(): Promise<string>;
+}
+export declare const fetchOrThrow: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare const getErrorMessage: (response: Response) => Promise<string>;