@speedkit/cli 2.4.1

package/dist/services/bundler/bundle-service.d.ts

@@ -0,0 +1,25 @@
+import { PluginBuild, LogLevel } from 'esbuild';
+export type BundleEntryPoints = {
+    [entryPoint: string]: string;
+};
+export type BundleBasePaths = {
+    [basePath: string]: string;
+};
+export declare class BundleService {
+    bundle({ entryPoints, basePaths, define, target, minify, logLevel }: {
+        entryPoints: BundleEntryPoints;
+        basePaths: BundleBasePaths;
+        target?: string | string[];
+        minify?: boolean;
+        define?: {
+            [key: string]: string;
+        };
+        logLevel?: LogLevel;
+        platform?: string;
+    }): Promise<string>;
+    private entryPointsPlugin;
+    baqendPlugin(basePaths: BundleBasePaths): {
+        name: string;
+        setup(build: PluginBuild): void;
+    };
+}

package/dist/services/bundler/bundle-service.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleService = void 0;
+const tslib_1 = require("tslib");
+const esbuild_1 = require("esbuild");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const node_url_1 = require("node:url");
+const importCache = {};
+class BundleService {
+    async bundle({ entryPoints, basePaths, define, target = 'es5', minify = true, logLevel = 'silent' }) {
+        const result = await (0, esbuild_1.build)({
+            plugins: [this.baqendPlugin(basePaths), this.entryPointsPlugin(entryPoints)],
+            bundle: true,
+            target,
+            define,
+            write: false,
+            minify,
+            outdir: 'out',
+            entryPoints: Object.keys(entryPoints),
+            logLevel,
+        });
+        return result.outputFiles.map(e => e.text).join('').trim();
+    }
+    entryPointsPlugin(entryPoints) {
+        return {
+            name: 'entryPoints',
+            setup(build) {
+                build.onResolve({ filter: /.*/ }, args => {
+                    if (!entryPoints[args.path]) {
+                        throw new Error('Could not resolve ' + args.path);
+                    }
+                    return ({
+                        path: args.path,
+                        namespace: 'entryPoint',
+                    });
+                });
+                build.onLoad({ filter: /.*/, namespace: 'entryPoint' }, (args) => {
+                    return {
+                        contents: entryPoints[args.path],
+                        loader: 'js',
+                    };
+                });
+            },
+        };
+    }
+    baqendPlugin(basePaths) {
+        const filter = new RegExp(`^(${Object.keys(basePaths).join('|')})/`);
+        return {
+            name: 'baqend',
+            setup(build) {
+                build.onResolve({ filter }, args => {
+                    const [base, path] = args.path.split('/', 2);
+                    const url = new node_url_1.URL(path, basePaths[base]).toString();
+                    if (!url.startsWith(basePaths[base])) {
+                        throw new Error(`Importing ${path} failed. Can't resolve the path`);
+                    }
+                    return ({
+                        path: url,
+                        namespace: 'baqend-url',
+                    });
+                });
+                build.onResolve({ filter: /.*/, namespace: 'baqend-url' }, args => ({
+                    path: new node_url_1.URL(args.path, args.importer).toString(),
+                    namespace: args.namespace,
+                }));
+                build.onLoad({ filter: /.*/, namespace: 'baqend-url' }, async (args) => {
+                    const url = args.path + (!args.path.endsWith('.js') ? '.js' : '');
+                    if (importCache[url]) {
+                        return { contents: importCache[url] };
+                    }
+                    const fetched = await (0, node_fetch_1.default)(url);
+                    if (!fetched.ok) {
+                        throw new Error(`Importing ${url} failed with error ${fetched.status}`);
+                    }
+                    let text = await fetched.text();
+                    text = text.replace('window.SpeedKit=window.SpeedKit||{},window.SpeedKit.plugins=window.SpeedKit.plugins||{},window.SpeedKit.plugins.', 'export var ');
+                    importCache[url] = text;
+                    return { contents: text };
+                });
+            },
+        };
+    }
+}
+exports.BundleService = BundleService;

package/dist/services/bundler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bundle-service-factory';
+export * from './bundle-service';

package/dist/services/bundler/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bundle-service-factory"), exports);
+tslib_1.__exportStar(require("./bundle-service"), exports);

package/dist/services/cli/cli-service-factory.d.ts

@@ -0,0 +1,5 @@
+import { CliService } from "./cli-service";
+export declare class CliServiceFactory {
+    service?: CliService;
+    getService(): CliService;
+}

package/dist/services/cli/cli-service-factory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliServiceFactory = void 0;
+const cli_service_1 = require("./cli-service");
+class CliServiceFactory {
+    service = undefined;
+    getService() {
+        if (!(this.service instanceof cli_service_1.CliService)) {
+            this.service = new cli_service_1.CliService();
+        }
+        return this.service;
+    }
+}
+exports.CliServiceFactory = CliServiceFactory;

package/dist/services/cli/cli-service-model.d.ts

@@ -0,0 +1,27 @@
+import { table } from "@oclif/core/lib/cli-ux/styled/table";
+export declare enum CliActionStatus {
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+export interface CliServiceInterface {
+    codeStyle(code: string): string;
+    write(message: string, buffered?: boolean): void;
+    spacer(): void;
+    writeSuccess(message: string, buffered?: boolean): void;
+    writeWarning(message: string, buffered?: boolean): void;
+    writeError(message: string, buffered?: boolean): void;
+    comment(message: string, buffered?: boolean): void;
+    code(code: string, buffered?: boolean): void;
+    prompt(message: string, options?: {
+        validator?: any;
+        defaultAnswer?: any;
+    }): Promise<string>;
+    confirm(message: string, defaultAnswer: boolean): Promise<boolean>;
+    select(message: string, choices: any): Promise<string>;
+    startAction(message: string): void;
+    endAction(status?: CliActionStatus): void;
+    writeBuffer(): void;
+    table<T extends Record<string, unknown>>(data: T[], columns: table.Columns<T>, options?: table.Options): void;
+    exit(code: number): void;
+}

package/dist/services/cli/cli-service-model.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliActionStatus = void 0;
+var CliActionStatus;
+(function (CliActionStatus) {
+    CliActionStatus["COMPLETED"] = "completed";
+    CliActionStatus["FAILED"] = "failed";
+    CliActionStatus["SKIPPED"] = "skipped";
+})(CliActionStatus || (exports.CliActionStatus = CliActionStatus = {}));

package/dist/services/cli/cli-service.d.ts

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { CliActionStatus, CliServiceInterface } from "./cli-service-model";
+import { table } from "@oclif/core/lib/cli-ux/styled/table";
+export declare class CliService implements CliServiceInterface {
+    private buffer;
+    style: chalk.Chalk & chalk.ChalkFunction & {
+        supportsColor: false | chalk.ColorSupport;
+        Level: chalk.Level;
+        Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
+        ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+        Modifiers: "hidden" | "bold" | "reset" | "dim" | "italic" | "underline" | "inverse" | "strikethrough" | "visible";
+        stderr: chalk.Chalk & {
+            supportsColor: false | chalk.ColorSupport;
+        };
+    };
+    codeStyle(code: string): string;
+    write(message: string, buffered?: boolean): void;
+    spacer(): void;
+    writeSuccess(message: string, buffered?: boolean): void;
+    writeWarning(message: string, buffered?: boolean): void;
+    writeError(message: string, buffered?: boolean): void;
+    comment(message: string, buffered?: boolean): void;
+    code(code: string, buffered?: boolean): void;
+    prompt(message: string, options?: {
+        validator?: any;
+        defaultAnswer?: any;
+    }): Promise<string>;
+    confirm(message: string, defaultAnswer?: boolean): Promise<boolean>;
+    select(message: string, choices: any): Promise<string>;
+    startAction(message: string): void;
+    endAction(status?: CliActionStatus): void;
+    writeBuffer(): void;
+    table<T extends Record<string, unknown>>(data: T[], columns: table.Columns<T>, options?: table.Options): void;
+    exit(code?: number): void;
+    private getFormattedMessage;
+}

package/dist/services/cli/cli-service.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliService = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts"); // interactive prompts
+const core_1 = require("@oclif/core");
+const cli_service_model_1 = require("./cli-service-model");
+class CliService {
+    buffer = [];
+    style = chalk_1.default;
+    codeStyle(code) {
+        const padding = ' ';
+        return this.style.bgGray.rgb(230, 126, 0)(`${padding}${code}${padding}`);
+    }
+    write(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.white(message));
+            return;
+        }
+        core_1.ux.info(message);
+    }
+    spacer() {
+        core_1.ux.info('');
+    }
+    writeSuccess(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.green(message));
+            return;
+        }
+        this.write(this.style.green(message));
+    }
+    writeWarning(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.yellow(message));
+            return;
+        }
+        this.write(this.style.yellow(message));
+    }
+    writeError(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.red(message));
+            return;
+        }
+        this.write(this.style.red(message));
+    }
+    comment(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.grey.italic(message));
+            return;
+        }
+        this.write(this.style.grey.italic(message));
+    }
+    code(code, buffered = false) {
+        code = `  ${code}  `;
+        if (buffered) {
+            this.buffer.push(this.style.bgBlack.white(code));
+            return;
+        }
+        core_1.ux.log(this.style.bgBlack.white(code));
+    }
+    async prompt(message, options) {
+        const { validator, defaultAnswer } = options;
+        return (0, prompts_1.input)({
+            message: this.getFormattedMessage(message),
+            default: defaultAnswer,
+            validate: input => {
+                if (typeof validator !== 'function')
+                    return true;
+                const errorMessage = validator(input);
+                if (!errorMessage) {
+                    return true;
+                }
+                return this.style.red(`${errorMessage}. Please try again.`);
+            },
+        });
+    }
+    async confirm(message, defaultAnswer = true) {
+        return (0, prompts_1.confirm)({
+            message: this.getFormattedMessage(message),
+            default: defaultAnswer,
+        });
+    }
+    async select(message, choices) {
+        return (0, prompts_1.select)({
+            message: this.getFormattedMessage(message),
+            choices
+        });
+    }
+    startAction(message) {
+        core_1.ux.action.start(message);
+    }
+    endAction(status) {
+        switch (status) {
+            case cli_service_model_1.CliActionStatus.COMPLETED:
+                core_1.ux.action.stop(this.style.green(cli_service_model_1.CliActionStatus.COMPLETED));
+                break;
+            case cli_service_model_1.CliActionStatus.FAILED:
+                core_1.ux.action.stop(this.style.red(cli_service_model_1.CliActionStatus.FAILED));
+                break;
+            case cli_service_model_1.CliActionStatus.SKIPPED:
+                core_1.ux.action.stop(this.style.yellow(cli_service_model_1.CliActionStatus.SKIPPED));
+                break;
+            default:
+                core_1.ux.action.stop();
+        }
+    }
+    writeBuffer() {
+        core_1.ux.log(this.buffer.join(`\n`));
+        core_1.ux.log();
+        this.buffer = [];
+    }
+    table(data, columns, options) {
+        core_1.ux.table(data, columns, options);
+    }
+    exit(code = 0) {
+        core_1.ux.exit(code);
+    }
+    getFormattedMessage(questionText) {
+        return `${this.style.bold(questionText)}`;
+    }
+}
+exports.CliService = CliService;

package/dist/services/cli/error/cli-type-error.d.ts

@@ -0,0 +1,3 @@
+import ApplicationError from "../../error-handling/error/application-error";
+export default class CliTypeError extends ApplicationError {
+}

package/dist/services/cli/error/cli-type-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const application_error_1 = tslib_1.__importDefault(require("../../error-handling/error/application-error"));
+class CliTypeError extends application_error_1.default {
+}
+exports.default = CliTypeError;

package/dist/services/cli/hooks.d.ts

@@ -0,0 +1,11 @@
+import { CliService } from "./cli-service";
+export default abstract class Hooks {
+    readonly preHook?: string;
+    readonly postHook?: string;
+    protected cli: CliService;
+    protected constructor(cli: CliService, preHook?: string, postHook?: string);
+    run(): Promise<any>;
+    runPreHook(): Promise<void>;
+    runPostHook(): Promise<void>;
+    abstract _run(): Promise<any>;
+}

package/dist/services/cli/hooks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+class Hooks {
+    preHook;
+    postHook;
+    cli;
+    constructor(cli, preHook, postHook) {
+        this.cli = cli;
+        this.preHook = preHook;
+        this.postHook = postHook;
+    }
+    async run() {
+        await this.runPreHook();
+        await this._run();
+        await this.runPostHook();
+    }
+    async runPreHook() {
+        if (!this.preHook) {
+            return;
+        }
+        this.cli.writeSuccess(this.preHook);
+        this.cli.write((0, child_process_1.execSync)(this.preHook) + '');
+    }
+    async runPostHook() {
+        if (!this.postHook) {
+            return;
+        }
+        this.cli.writeSuccess(this.postHook);
+        this.cli.write((0, child_process_1.execSync)(this.postHook) + '');
+    }
+}
+exports.default = Hooks;

package/dist/services/cli/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cli-service';
+export * from './cli-service-model';
+export * from './cli-service-factory';

package/dist/services/cli/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./cli-service"), exports);
+tslib_1.__exportStar(require("./cli-service-model"), exports);
+tslib_1.__exportStar(require("./cli-service-factory"), exports);

package/dist/services/config-api/client.d.ts

@@ -0,0 +1,16 @@
+import RequestExtensionInterface from "./interface/request-extension-interface";
+import EntityManagerFactory from "./factory/entity-manager-factory";
+export default class Client {
+    private readonly entityManagerFactory;
+    private readonly app;
+    private readonly agent;
+    constructor(app: string, entityManagerFactory: EntityManagerFactory);
+    send(url: string, requestExtension?: RequestExtensionInterface): Promise<any>;
+    getModule(moduleName: string): Promise<string>;
+    setModule(moduleName: string, moduleCode: string): Promise<string>;
+    /**
+     * @param requestExtension
+     */
+    createRequest(requestExtension: RequestExtensionInterface): Promise<{}>;
+    private getEntityManager;
+}

package/dist/services/config-api/client.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const https_1 = require("https");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
+const race_1 = require("../../helpers/race");
+const REQUEST_TIMEOUT = 10000;
+const CONTENT_TYPE = 'application/json;charset=UTF-8';
+class Client {
+    entityManagerFactory;
+    app;
+    agent;
+    constructor(app, entityManagerFactory) {
+        this.app = app;
+        this.entityManagerFactory = entityManagerFactory;
+        this.agent = new https_1.Agent({ rejectUnauthorized: false, keepAlive: true });
+    }
+    async send(url, requestExtension = {}) {
+        const res = await (0, node_fetch_1.default)(url, await this.createRequest(requestExtension));
+        if (res.status !== 200) {
+            throw new Error((await res.json()).message);
+        }
+        return await res.json();
+    }
+    async getModule(moduleName) {
+        const entityManager = await this.getEntityManager();
+        return await entityManager.code.loadCode(moduleName, 'module');
+    }
+    async setModule(moduleName, moduleCode) {
+        const entityManager = await this.getEntityManager();
+        return await entityManager.code.saveCode(moduleName, 'module', moduleCode);
+    }
+    /**
+     * @param requestExtension
+     */
+    async createRequest(requestExtension) {
+        const entityManager = await this.getEntityManager();
+        let baseRequest = {
+            method: 'GET',
+            headers: {
+                Host: `${this.app}.app.baqend.com`,
+                authorization: `BAT ${entityManager.token}`,
+                'Content-Type': CONTENT_TYPE,
+            },
+            timeout: REQUEST_TIMEOUT,
+        };
+        return Object.assign({}, (0, deepmerge_1.default)(baseRequest, requestExtension), { agent: this.agent });
+    }
+    async getEntityManager() {
+        return await (0, race_1.race)(this.entityManagerFactory.getEntityManager(this.app));
+    }
+}
+exports.default = Client;

package/dist/services/config-api/config-api-service.d.ts

@@ -0,0 +1,16 @@
+import Client from "./client";
+import Install from "../deploy/interface/install";
+export default class ConfigApiService {
+    client: Client;
+    private readonly app;
+    constructor(app: string, client: Client);
+    getActiveInstall(configName: string): Promise<Install | null>;
+    addInstall(configName: string, origins: string[]): Promise<Install>;
+    setInstall(install: Install): Promise<Install | null>;
+    cloneInstall(install: Install): Promise<Install>;
+    activateInstall(install: Install): Promise<Install>;
+    getModule(moduleName: string): Promise<string>;
+    setModule(moduleCode: string, moduleName: string): Promise<string>;
+    getServerConfig(): Promise<string>;
+    setServerConfig(localServerConfig: string, configurationVersion: string): Promise<void>;
+}

package/dist/services/config-api/config-api-service.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConfigApiService {
+    client;
+    app;
+    constructor(app, client) {
+        this.client = client;
+        this.app = app;
+    }
+    async getActiveInstall(configName) {
+        const urlPath = `https://${this.app}.app.baqend.com/v1/speedkit/installation?domain=${configName}&status=active`;
+        const body = await this.client.send(urlPath);
+        return body[0];
+    }
+    async addInstall(configName, origins) {
+        const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${configName}`;
+        const body = await this.client.send(updateUrl, { body: `{origins: ${JSON.stringify(origins)}}`, method: 'POST' });
+        return body;
+    }
+    async setInstall(install) {
+        const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}`;
+        return (await this.client.send(updateUrl, { body: JSON.stringify(install), method: 'PUT' }));
+    }
+    async cloneInstall(install) {
+        const cloneUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/clone`;
+        const body = await this.client.send(cloneUrl, { body: '{}', method: 'POST' });
+        return body;
+    }
+    async activateInstall(install) {
+        const activateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/activate`;
+        return (await this.client.send(activateUrl, { body: '{}', method: 'POST' }));
+    }
+    async getModule(moduleName) {
+        return await this.client.getModule(moduleName);
+    }
+    async setModule(moduleCode, moduleName) {
+        return await this.client.setModule(moduleName, moduleCode);
+    }
+    async getServerConfig() {
+        const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
+        const body = await this.client.send(urlPath);
+        return JSON.stringify(body, null, '\t');
+    }
+    async setServerConfig(localServerConfig, configurationVersion) {
+        const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
+        await this.client.send(urlPath, {
+            body: localServerConfig,
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                'If-Match': configurationVersion,
+            },
+        });
+    }
+}
+exports.default = ConfigApiService;

package/dist/services/config-api/context/config-api-context.d.ts

@@ -0,0 +1,5 @@
+import ContextInterface from "../../context/interface/context-interface";
+export default class ConfigApiContext implements ContextInterface {
+    readonly app: string;
+    constructor(app: string);
+}

package/dist/services/config-api/context/config-api-context.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConfigApiContext {
+    app = undefined;
+    constructor(app) {
+        this.app = app;
+    }
+}
+exports.default = ConfigApiContext;

package/dist/services/config-api/error/json-response-error.d.ts

@@ -0,0 +1,2 @@
+export default class JsonResponseError extends Error {
+}

package/dist/services/config-api/error/json-response-error.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class JsonResponseError extends Error {
+}
+exports.default = JsonResponseError;

package/dist/services/config-api/error/login-error.d.ts

@@ -0,0 +1,5 @@
+import DeployAppError from "../../deploy/error/deploy-app-error";
+export default class LoginError extends DeployAppError {
+    app: string;
+    constructor(app: string);
+}

package/dist/services/config-api/error/login-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deploy_app_error_1 = tslib_1.__importDefault(require("../../deploy/error/deploy-app-error"));
+class LoginError extends deploy_app_error_1.default {
+    app;
+    constructor(app) {
+        super(`Could not login to app ${app}`);
+        this.app = app;
+    }
+}
+exports.default = LoginError;

package/dist/services/config-api/factory/config-api-service-factory.d.ts

@@ -0,0 +1,10 @@
+import ConfigApiService from "../config-api-service";
+import ConfigApiContextInterface from "../interface/config-api-context-interface";
+export default class ConfigApiServiceFactory {
+    context: ConfigApiContextInterface;
+    service: ConfigApiService;
+    constructor(context: ConfigApiContextInterface);
+    getService(): ConfigApiService;
+    buildService(): void;
+    createLoginTokenFileIfNotExists(): void;
+}