@speedkit/cli 2.4.1

package/dist/services/document-handler-runtime/templates/orestes-mock.d.ts

@@ -0,0 +1,9 @@
+import AbstractTemplate from "./abstract-template";
+import TemplateContextInterface from "../interface/template-context-interface";
+export default class OrestesMock extends AbstractTemplate {
+    buildContext(): TemplateContextInterface;
+    /**
+     * @template javascript
+     */
+    getTemplate(): string;
+}

package/dist/services/document-handler-runtime/templates/orestes-mock.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_template_1 = tslib_1.__importDefault(require("./abstract-template"));
+class OrestesMock extends abstract_template_1.default {
+    buildContext() {
+        return {};
+    }
+    /**
+     * @template javascript
+     */
+    getTemplate() {
+        return `
+const debug = true;
+const headers = {};
+const port = 3001
+const host = '127.0.0.1'
+const serverUrl = \`http://\${host}:\${port}/\`
+
+const inMemoryCache = new Set();
+
+const http = require("http");
+const fs = require('fs');
+const {resolve} = require("path");
+
+const documentHandler = require("./testDocumentHandler.js");
+const database = require("./database-mock.js");
+const NS_PER_SEC = 1e9;
+const MS_PER_NS = 1e-6;
+const SERVER_TIMEOUT = 10_000;
+
+const server = http.createServer(async function (request, response) {
+  if (request.method !== 'GET') {
+    response.writeHead(
+      502,
+      {
+        'Content-Type': 'text/html; charset=utf-8',
+        'x-render-error': 'URL and selector required.',
+      })
+    return;
+  }
+
+  if (!request.url.startsWith('/v1/asset')) {
+    response.writeHead(404);
+    return;
+  }
+  let time = []
+
+  if(debug){
+    time = process.hrtime();
+  }
+  const UrlObject = new URL(serverUrl + request.url)
+  const url = getAssetUrl(request.url)
+  const originUrlObject = new URL(url)
+
+  try{
+    let output = ''
+    let isCacheHit = false
+    let cacheType = 'stream'
+    let contentType = ''
+    let contentLength = 0
+
+    const fileName = getLocalFileName(url)
+    if(fileName in inMemoryCache) {
+      isCacheHit = true
+      output = inMemoryCache[fileName].body
+      contentType = inMemoryCache[fileName].contentType
+      contentLength = inMemoryCache[fileName].contentLength
+      cacheType = 'edge'
+    // }
+    // else if(doesCachedFileExists(fileName)){
+    //   output = getLocalFile(fileName)
+    //   inMemoryCache[fileName] = output
+    //   isCacheHit = true
+    //   cacheType = 'storage'
+    }else{
+      const response = await fetch(url,{headers:headers})
+      const body = await response.text()
+      const contentType = response.headers.get('Content-Type') || response.headers.get('content-type')
+      const contentLength = response.headers.get('Content-Length') || response.headers.get('content-length')
+      let query = {
+        variation: UrlObject.searchParams.has('bqvariation')?UrlObject.searchParams.get('bqvariation'):'DEFAULT',
+        headers: '',
+        url: url,
+      }
+      let req = {query, body}
+      const output =  await documentHandler.transform(database,req)
+      inMemoryCache[fileName] = {body: output, contentType: contentType, contentLength: contentLength}
+
+      // fs.writeFileSync(resolve(__dirname,\`../tmp/server/\${fileName}\`), output)
+    }
+
+    const responseHeaders = {
+      'last-modified': new Date().toUTCString(),
+      'Access-Control-Allow-Credentials': 'true',
+      'Origin': originUrlObject.origin,
+      'Access-Control-Expose-Headers': 'Location, ETag, Baqend-Authorization-Token, Baqend-Acl, Baqend-Size, Baqend-SW-Control, Baqend-Created-At, Date, Age, Baqend-Speed-Kit, Baqend-Custom-Headers, X-Served-By, X-Cache, X-Timer, Access-Control-Allow-Origin, Fastly-Io-Info, Server-Timing',
+      'server-timing': 'desc=LOCAL,pop:none,proto',
+      'strict-transport-security': 'max-age=31536000; includeSubDomains',
+      'timing-allow-origin': originUrlObject.origin,
+      'via': 'local',
+      'x-cache': \`\${cacheType}, \${isCacheHit ? 'HIT' : 'MISS'}\`,
+      'x-cache-hits': isCacheHit?'1':'0',
+      'x-frame-options': 'SAMEORIGIN',
+      'x-served-by': 'cache-local',
+    }
+    if(contentType){
+      responseHeaders['Content-Type'] = contentType
+    }
+     if(contentLength){
+      responseHeaders['Content-Length'] = contentLength
+    }
+  }catch (error){
+    response.writeHead(
+      503,
+      {
+        'Content-Type': 'text/html; charset=utf-8',
+        'x-render-error': 'Error transforming document' + error.message,
+      })
+    database.log.error(error.message);
+    response.end(error.message)
+  }finally {
+    if(debug){
+      benchmark(time);
+    }
+  }
+})
+
+function getAssetUrl(requestUrl){
+  let matches =  requestUrl.match(/\\/asset\\/(.*)(?:\\?bqcv|&bqcv)/);
+  if(matches?.length > 1){
+    return matches[1]
+  }
+
+  matches =  requestUrl.match(/\\/asset\\/(.*)/);
+  if(matches?.length > 1){
+    return matches[1]
+  }
+}
+
+function doesCachedFileExists(fileName){
+  return fs.existsSync(resolve(__dirname,\`../tmp/server/\${fileName}\`))
+}
+
+function getLocalFileName(url){
+  return url.replace('https://','').replace(/\\//g,'__');
+}
+
+function getLocalFile(fileName){
+  return fs.readFileSync(resolve(__dirname,\`../tmp/server/\${fileName}\`));
+}
+
+function benchmark(time) {
+  const used = process.memoryUsage();
+  for (let key in used) {
+    console.log(\`\${key} \${Math.round(used[key] / 1024 / 1024 * 100) / 100} MB\`);
+  }
+  const diff = process.hrtime(time);
+  console.log(\`Benchmark took \${(diff[0] * NS_PER_SEC + diff[1]) * MS_PER_NS} milliseconds\`);
+}
+
+
+console.log(\`listen to \${serverUrl}\`)
+server.listen(port, host)
+    `;
+    }
+}
+exports.default = OrestesMock;

package/dist/services/document-handler-runtime/templates/package-json.d.ts

@@ -0,0 +1,8 @@
+import AbstractTemplate from "./abstract-template";
+import TemplateContextInterface from "../interface/template-context-interface";
+export default class PackageJson extends AbstractTemplate {
+    buildContext(dependencies: {
+        [key: string]: string;
+    }): TemplateContextInterface;
+    protected getTemplate(): Handlebars.Template;
+}

package/dist/services/document-handler-runtime/templates/package-json.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_template_1 = tslib_1.__importDefault(require("./abstract-template"));
+class PackageJson extends abstract_template_1.default {
+    buildContext(dependencies) {
+        return { dependency: dependencies };
+    }
+    getTemplate() {
+        return `{
+  "name": "DocumentHandlerDependencies",
+  "version": "1.0.0",
+  "dependencies": {
+  {{#each dependency}}
+    "{{@key}}": "{{this}}"{{#unless @last}},{{/unless}}
+  {{/each}}
+  }
+}`;
+    }
+}
+exports.default = PackageJson;

package/dist/services/document-handler-runtime/templates/test.d.ts

@@ -0,0 +1,6 @@
+import AbstractTemplate from "./abstract-template";
+import TemplateContextInterface from "../interface/template-context-interface";
+export default class Test extends AbstractTemplate {
+    buildContext(domain: string, name: string, timeout?: number): TemplateContextInterface;
+    getTemplate(): string;
+}

package/dist/services/document-handler-runtime/templates/test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_template_1 = tslib_1.__importDefault(require("./abstract-template"));
+class Test extends abstract_template_1.default {
+    buildContext(domain, name, timeout = 2000) {
+        return { domain, name, timeout };
+    }
+    getTemplate() {
+        return `const expect = require('chai').expect;
+const database = require('./src/database-mock');
+const documentHandler = require('./src/testDocumentHandler');
+const fs = require('fs');
+const {resolve} = require("path");
+global.Abort = Error;
+
+const url = '{{domain}}';
+const file = '{{name}}';
+const timeout = {{timeout}};
+const DEFAULT_HEADERS = {'User-Agent':'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'}
+
+describe(\`documentHandler run on \${file}\`, function () {
+  it('should be able to transform page', async function () {
+    this.timeout(timeout);
+    const body = await (await fetch(url,{headers:DEFAULT_HEADERS})).text()
+
+    let query = {
+        variation: 'DEFAULT',
+        headers: JSON.stringify(DEFAULT_HEADERS),
+        url: url,
+    }
+
+    let req = {query, body}
+    expect((await documentHandler.transform(database, req)).includes('speed-kit-loading')).to.be.true
+
+  })
+})
+
+describe(\`create files to diff for \${file}\`,function (){
+  it('download/process file and save to ./tmp/', async function () {
+    this.timeout(timeout);
+
+    const body = await (await fetch(url,{headers:DEFAULT_HEADERS})).text()
+    let query = {
+      variation: 'DEFAULT',
+      headers: JSON.stringify(DEFAULT_HEADERS),
+      url: url,
+    }
+
+    let req = {query, body}
+    const processedBody = await documentHandler.transform(database, req)
+
+    fs.writeFileSync(resolve(__dirname,\`./tmp/\${file}.html\`), body)
+    fs.writeFileSync(resolve(__dirname,\`./tmp/\${file}-processed.html\`), processedBody)
+
+    expect(fs.existsSync(resolve(__dirname,\`./tmp/\${file}.html\`))).to.be.true
+    expect(fs.existsSync(resolve(__dirname,\`./tmp/\${file}-processed.html\`))).to.be.true
+  })
+})
+`;
+    }
+}
+exports.default = Test;

package/dist/services/error-handling/abstract/abstract-async-error-handling-factory.d.ts

@@ -0,0 +1,6 @@
+import { AsyncErrorHandlingFactory } from "../interface/error-handling-factory-interface";
+export default abstract class AbstractAsyncErrorHandlingFactory implements AsyncErrorHandlingFactory {
+    buildService(): Promise<any>;
+    abstract _buildService(): Promise<any>;
+    private getErrorHandler;
+}

package/dist/services/error-handling/abstract/abstract-async-error-handling-factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const error_handling_factory_1 = tslib_1.__importDefault(require("../factory/error-handling-factory"));
+class AbstractAsyncErrorHandlingFactory {
+    async buildService() {
+        const errorHandler = this.getErrorHandler();
+        try {
+            return await this._buildService();
+        }
+        catch (error) {
+            errorHandler.handle(error);
+        }
+    }
+    getErrorHandler() {
+        return (new error_handling_factory_1.default()).buildService();
+    }
+}
+exports.default = AbstractAsyncErrorHandlingFactory;

package/dist/services/error-handling/abstract/abstract-async-error-handling-service.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandlingServiceInterface } from "../interface/error-handling-service-interface";
+export default abstract class AbstractAsyncErrorHandlingService implements ErrorHandlingServiceInterface {
+    run(): Promise<any>;
+    abstract _run(): Promise<any>;
+    private getErrorHandler;
+}

package/dist/services/error-handling/abstract/abstract-async-error-handling-service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const error_handling_factory_1 = tslib_1.__importDefault(require("../factory/error-handling-factory"));
+class AbstractAsyncErrorHandlingService {
+    async run() {
+        try {
+            return await this._run();
+        }
+        catch (error) {
+            this.getErrorHandler().handle(error);
+        }
+    }
+    getErrorHandler() {
+        return (new error_handling_factory_1.default()).buildService();
+    }
+}
+exports.default = AbstractAsyncErrorHandlingService;

package/dist/services/error-handling/abstract/abstract-error-handling-factory.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandlingFactoryInterface } from "../interface/error-handling-factory-interface";
+export default abstract class AbstractErrorHandlingFactory implements ErrorHandlingFactoryInterface {
+    buildService(): any;
+    abstract _buildService(): any;
+    private getErrorHandler;
+}

package/dist/services/error-handling/abstract/abstract-error-handling-factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const error_handling_factory_1 = tslib_1.__importDefault(require("../factory/error-handling-factory"));
+class AbstractErrorHandlingFactory {
+    buildService() {
+        const errorHandler = this.getErrorHandler();
+        try {
+            return this._buildService();
+        }
+        catch (error) {
+            errorHandler.handle(error);
+        }
+    }
+    getErrorHandler() {
+        return (new error_handling_factory_1.default()).buildService();
+    }
+}
+exports.default = AbstractErrorHandlingFactory;

package/dist/services/error-handling/abstract/abstract-error-handling-service.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandlingServiceInterface } from "../interface/error-handling-service-interface";
+export default abstract class AbstractErrorHandlingService implements ErrorHandlingServiceInterface {
+    run(): any;
+    abstract _run(): any;
+    private getErrorHandler;
+}

package/dist/services/error-handling/abstract/abstract-error-handling-service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const error_handling_factory_1 = tslib_1.__importDefault(require("../factory/error-handling-factory"));
+class AbstractErrorHandlingService {
+    run() {
+        const errorHandler = this.getErrorHandler();
+        try {
+            return this._run();
+        }
+        catch (error) {
+            errorHandler.handle(error);
+        }
+    }
+    getErrorHandler() {
+        return (new error_handling_factory_1.default()).buildService();
+    }
+}
+exports.default = AbstractErrorHandlingService;

package/dist/services/error-handling/error/application-error.d.ts

@@ -0,0 +1,5 @@
+import ErrorContextInterface from "../interface/error-context-interface";
+export default class ApplicationError extends Error {
+    readonly context: ErrorContextInterface;
+    constructor(context?: ErrorContextInterface);
+}

package/dist/services/error-handling/error/application-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ApplicationError extends Error {
+    context;
+    constructor(context = {}) {
+        const { message } = context;
+        super(message);
+        this.context = context;
+    }
+}
+exports.default = ApplicationError;

package/dist/services/error-handling/error/handler/default-error-handler.d.ts

@@ -0,0 +1,5 @@
+import ErrorHandlerInterface from "../../interface/error-handler-interface";
+export default class DefaultErrorHandler implements ErrorHandlerInterface {
+    canHandle(error: Error): boolean;
+    handle(error: Error): Promise<any>;
+}

package/dist/services/error-handling/error/handler/default-error-handler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+class DefaultErrorHandler {
+    canHandle(error) {
+        return true;
+    }
+    async handle(error) {
+        console.log(error);
+        core_1.ux.exit(1);
+    }
+}
+exports.default = DefaultErrorHandler;

package/dist/services/error-handling/error-handling-service.d.ts

@@ -0,0 +1,7 @@
+import ErrorHandlerInterface from "./interface/error-handler-interface";
+import ApplicationError from "./error/application-error";
+export default class ErrorHandlingService {
+    handlers: ErrorHandlerInterface[];
+    constructor(handlers: ErrorHandlerInterface[]);
+    handle(error: ApplicationError | any): void;
+}

package/dist/services/error-handling/error-handling-service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+class ErrorHandlingService {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    handle(error) {
+        core_1.ux.log(`   ===========================`);
+        core_1.ux.log(`   === An error appeared =====`);
+        core_1.ux.log(`   ===========================\n`);
+        for (let iterator = 0; iterator < this.handlers.length; iterator++) {
+            let handler = this.handlers[iterator];
+            if (handler.canHandle(error)) {
+                handler.handle(error);
+                core_1.ux.exit(1);
+                return;
+            }
+        }
+        core_1.ux.warn('unhandled error:');
+        core_1.ux.info(`type of error: ${typeof error}`);
+        core_1.ux.log(error);
+        core_1.ux.exit(1);
+    }
+}
+exports.default = ErrorHandlingService;

package/dist/services/error-handling/factory/error-handling-factory.d.ts

@@ -0,0 +1,8 @@
+import ErrorHandlingService from "../error-handling-service";
+import CustomerConfigLegacyHandler from "../../integration-api/error/handler/customer-config-legacy-handler";
+import OriginHandler from "../../integration-api/error/handler/origin-handler";
+import { CustomerConfigHandler } from "../../integration-api/error/handler/customer-config-handler";
+export default class ErrorHandlingFactory {
+    buildService(): ErrorHandlingService;
+    importHandlers(): (CustomerConfigLegacyHandler | OriginHandler | CustomerConfigHandler)[];
+}

package/dist/services/error-handling/factory/error-handling-factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const error_handling_service_1 = tslib_1.__importDefault(require("../error-handling-service"));
+const customer_config_legacy_handler_1 = tslib_1.__importDefault(require("../../integration-api/error/handler/customer-config-legacy-handler"));
+const origin_handler_1 = tslib_1.__importDefault(require("../../integration-api/error/handler/origin-handler"));
+const document_handler_runtime_service_factory_1 = tslib_1.__importDefault(require("../../document-handler-runtime/factory/document-handler-runtime-service-factory"));
+const customer_config_handler_1 = require("../../integration-api/error/handler/customer-config-handler");
+class ErrorHandlingFactory {
+    buildService() {
+        return new error_handling_service_1.default(this.importHandlers());
+    }
+    importHandlers() {
+        return [
+            new customer_config_legacy_handler_1.default(),
+            new origin_handler_1.default(),
+            new customer_config_handler_1.CustomerConfigHandler(),
+        ].concat(document_handler_runtime_service_factory_1.default.getErrorHandlers());
+    }
+}
+exports.default = ErrorHandlingFactory;

package/dist/services/error-handling/interface/error-context-interface.d.ts

@@ -0,0 +1,6 @@
+export default interface ErrorContextInterface {
+    app?: string;
+    configName?: string;
+    path?: string;
+    message?: string;
+}

package/dist/services/error-handling/interface/error-context-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/error-handling/interface/error-handler-interface.d.ts

@@ -0,0 +1,5 @@
+import ApplicationError from "../error/application-error";
+export default interface ErrorHandlerInterface {
+    canHandle(error: Error | ApplicationError | any): boolean;
+    handle(error: Error | ApplicationError | any): any;
+}

package/dist/services/error-handling/interface/error-handler-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/error-handling/interface/error-handling-factory-interface.d.ts

@@ -0,0 +1,8 @@
+export interface ErrorHandlingFactoryInterface {
+    buildService(): any;
+    _buildService(): any;
+}
+export interface AsyncErrorHandlingFactory {
+    buildService(): Promise<any>;
+    _buildService(): Promise<any>;
+}

package/dist/services/error-handling/interface/error-handling-factory-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/error-handling/interface/error-handling-service-interface.d.ts

@@ -0,0 +1,8 @@
+export interface ErrorHandlingServiceInterface {
+    run(): any;
+    _run(): any;
+}
+export interface AsyncErrorHandlingService {
+    run(): Promise<any>;
+    _run(): Promise<any>;
+}

package/dist/services/error-handling/interface/error-handling-service-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,9 @@
+import { IntegrationApiContextInterface } from "../integration-api-model";
+export declare const DEFAULT_BLOCKED_FOLDERS: string[];
+export default class IntegrationApiContext implements IntegrationApiContextInterface {
+    readonly basePath: string;
+    readonly configName: string;
+    readonly whiteList: string[];
+    readonly blockedFolders: string[];
+    constructor(basePath: string, configName: string, whitelist: string[], blockedFolders?: string[]);
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BLOCKED_FOLDERS = void 0;
+const tslib_1 = require("tslib");
+const dotenv = tslib_1.__importStar(require("dotenv"));
+dotenv.config();
+exports.DEFAULT_BLOCKED_FOLDERS = ['test', '.local', '.git', '.idea'];
+class IntegrationApiContext {
+    basePath;
+    configName;
+    whiteList;
+    blockedFolders;
+    constructor(basePath, configName, whitelist, blockedFolders) {
+        this.basePath = basePath;
+        this.configName = configName;
+        this.whiteList = whitelist;
+        this.blockedFolders = blockedFolders || exports.DEFAULT_BLOCKED_FOLDERS;
+    }
+}
+exports.default = IntegrationApiContext;

package/dist/services/integration-api/error/customer-config-error.d.ts

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

package/dist/services/integration-api/error/customer-config-error.js

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

package/dist/services/integration-api/error/customer-config-legacy-error.d.ts

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

package/dist/services/integration-api/error/customer-config-legacy-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 CustomerConfigLegacyError extends application_error_1.default {
+}
+exports.default = CustomerConfigLegacyError;

package/dist/services/integration-api/error/handler/customer-config-handler.d.ts

@@ -0,0 +1,5 @@
+import ErrorHandlerInterface from "../../../error-handling/interface/error-handler-interface";
+export declare class CustomerConfigHandler implements ErrorHandlerInterface {
+    canHandle(error: any): boolean;
+    handle(error: any): any;
+}

package/dist/services/integration-api/error/handler/customer-config-handler.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerConfigHandler = void 0;
+const tslib_1 = require("tslib");
+const customer_config_error_1 = tslib_1.__importDefault(require("../customer-config-error"));
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class CustomerConfigHandler {
+    canHandle(error) {
+        return error instanceof customer_config_error_1.default;
+    }
+    handle(error) {
+        core_1.ux.log();
+        core_1.ux.log(chalk_1.default.red(error.message));
+        core_1.ux.log();
+        core_1.ux.exit(1);
+    }
+}
+exports.CustomerConfigHandler = CustomerConfigHandler;

package/dist/services/integration-api/error/handler/customer-config-legacy-handler.d.ts

@@ -0,0 +1,6 @@
+import CustomerConfigLegacyError from "../customer-config-legacy-error";
+import ErrorHandlerInterface from "../../../error-handling/interface/error-handler-interface";
+export default class CustomerConfigLegacyHandler implements ErrorHandlerInterface {
+    canHandle(error: Error): boolean;
+    handle(error: CustomerConfigLegacyError): void;
+}