@speedkit/cli 2.4.1

package/dist/services/document-handler-runtime/document-handler-server.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentHandlerServer = void 0;
+const tslib_1 = require("tslib");
+const document_handler_runtime_context_1 = require("./context/document-handler-runtime-context");
+const required_file_not_found_error_1 = tslib_1.__importDefault(require("./error/required-file-not-found-error"));
+const database_mock_1 = tslib_1.__importDefault(require("./templates/database-mock"));
+const vm = tslib_1.__importStar(require("vm"));
+const vm_error_1 = require("../onboarding/error/vm-error");
+// documentHandlerDependencies
+var parse5 = require('parse5');
+var parse5Htmlparser2TreeAdapter = require('parse5-htmlparser2-tree-adapter');
+var domSerializer = require('dom-serializer');
+var domhandler = require('domhandler');
+var domelementtype = require('domelementtype');
+var domutils = require('domutils');
+var cssSelect = require('css-select');
+var fetch = require('node-fetch');
+class DocumentHandlerServer {
+    customerConfig;
+    files;
+    bundler;
+    cli;
+    verboseLevel;
+    documentHandlerCode;
+    database;
+    constructor(customerConfig, files, bundler, cli, verboseLevel = false) {
+        this.customerConfig = customerConfig;
+        this.files = files;
+        this.bundler = bundler;
+        this.cli = cli;
+        this.verboseLevel = verboseLevel;
+    }
+    async transform(html, variation, url, headers) {
+        if (!this.documentHandlerCode) {
+            await this.buildDocumentHandler();
+        }
+        const skInternalRequest = {
+            query: { variation, headers: JSON.stringify(headers), url }, body: html
+        };
+        const vmContext = {
+            db: await this.createDataBaseMock(),
+            skInternalRequest,
+            skInternalHtml: "",
+            skInternalError: {},
+            'Abort': Error,
+            'APP': this.customerConfig.app,
+            'DYNAMIC_FETCHER': await this.getDynamicFetcher(),
+            'DYNAMIC_FETCHER_CONFIG': await this.getDynamicFetcherConfig(),
+            'CUSTOM_STYLES': this.getStyles(),
+            ...this.createNodeVmContext(),
+        };
+        const script = new vm.Script(this.documentHandlerCode + this.getTransformFunctionWrapper());
+        try {
+            return await (async () => {
+                return await new Promise((resolve, reject) => {
+                    // @ts-ignore
+                    vmContext.resolve = resolve;
+                    // @ts-ignore
+                    vmContext.reject = reject;
+                    const context = vm.createContext(vmContext);
+                    script.runInContext(context);
+                });
+            })();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new vm_error_1.VmError(error.message);
+            }
+            throw new vm_error_1.VmError(String(error) + JSON.stringify(error));
+        }
+    }
+    getTransformFunctionWrapper() {
+        return `\n\ndocumentHandler.transform(db, skInternalRequest).then(result => {resolve(result);}).catch((err)=>{reject(err);});`;
+    }
+    async buildDocumentHandler() {
+        this.documentHandlerCode = await this.createDocumentHandlerFile();
+        this.cli.writeSuccess('rebuild documentHandler');
+    }
+    async createDocumentHandlerFile() {
+        const docHandler = await this.getDocumentHandler();
+        const docHandlerConfig = this.getDocumentHandlerConfig()
+            .replace('export const post', 'const post');
+        return `${this.getContextVars()} ${docHandler} ${docHandlerConfig}`;
+    }
+    async getDocumentHandler() {
+        // todo use fetchRemoteFile from integration api
+        if (!this.files.hasFile(document_handler_runtime_context_1.LOCAL_DOCUMENT_HANDLER)) {
+            const response = await fetch(document_handler_runtime_context_1.LATEST_DOCUMENT_HANDLER_URL);
+            return await response.text();
+        }
+        return this.files.getByName(document_handler_runtime_context_1.LOCAL_DOCUMENT_HANDLER).getContent();
+    }
+    async getDynamicFetcher() {
+        // todo use fetchRemoteFile from integration api
+        if (!this.files.hasFile(document_handler_runtime_context_1.LOCAL_DYNAMIC_FETCHER)) {
+            const response = await fetch(document_handler_runtime_context_1.LATEST_DYNAMIC_FETCHER_URL);
+            return await this.bundleDynamicFetcher({ 'dynamic-fetcher': 'https://www.baqend.com/speed-kit/latest/' }, await response.text());
+        }
+        return this.files.getByName(document_handler_runtime_context_1.LOCAL_DYNAMIC_FETCHER).getContent();
+    }
+    async getDynamicFetcherConfig() {
+        return this.files.getByName(document_handler_runtime_context_1.LOCAL_DYNAMIC_FETCHER_CONFIG).getContent();
+    }
+    getStyles() {
+        return this.files.getByName(document_handler_runtime_context_1.LOCAL_STYLES).getContent();
+    }
+    getDocumentHandlerConfig() {
+        const docHandlerFile = this.files.getByName(document_handler_runtime_context_1.LOCAL_DOCUMENT_HANDLER_CONFIG);
+        if (!docHandlerFile) {
+            throw new required_file_not_found_error_1.default({ message: `file ${document_handler_runtime_context_1.LOCAL_DOCUMENT_HANDLER_CONFIG} not found` });
+        }
+        return docHandlerFile.getContent();
+    }
+    getContextVars() {
+        let template = '';
+        for (let key in this.customerConfig) {
+            template += `var ${key.toUpperCase()} = '${this.customerConfig[key]}';\n`;
+        }
+        return template;
+    }
+    async createDataBaseMock() {
+        const vmConsole = {
+            log: (context) => {
+                this.verboseLevel ? this.cli.write(`[documentHandler.dbLog]: ${JSON.stringify(context)}`) : "";
+            },
+            info: (context) => {
+                this.verboseLevel ? this.cli.writeWarning(`[documentHandler.dbLog]: ${JSON.stringify(context)}`) : "";
+            },
+            error: (context) => {
+                this.verboseLevel ? this.cli.writeError(`[documentHandler.dbLog]: ${JSON.stringify(context)}`) : "";
+            },
+        };
+        if (!this.database) {
+            const dataBaseMock = new database_mock_1.default();
+            const dbCode = dataBaseMock.render(dataBaseMock.buildContext(this.customerConfig.origins[0], this.customerConfig.app));
+            const vmContext = { console: vmConsole, module: { exports: {} } };
+            vm.runInNewContext(dbCode, vmContext);
+            this.database = vmContext.module.exports;
+        }
+        return this.database;
+    }
+    createNodeVmContext() {
+        const context = {
+            process: this.createProcessPartial(),
+            require: this.createRequireMock(),
+            'URL': URL,
+            'fetch': fetch,
+            'Buffer': Buffer,
+        };
+        if (this.verboseLevel) {
+            context['console'] = console;
+        }
+        return context;
+    }
+    createRequireMock() {
+        return (module) => {
+            if (module === 'baqend') {
+                return { baqend: { message: { RevalidateAssets: () => true } } };
+            }
+            if (module.includes('fetch')) {
+                return async (url, options) => {
+                    if (this.verboseLevel) {
+                        this.cli.writeWarning(`[documentHandler.fetch]: ${url}`);
+                    }
+                    return fetch(url, options);
+                };
+            }
+            if (module.includes('css-select')) {
+                return cssSelect;
+            }
+            if (module.includes('domutils')) {
+                return domutils;
+            }
+            if (module.includes('domelementtype')) {
+                return domelementtype;
+            }
+            if (module.includes('domhandler')) {
+                return domhandler;
+            }
+            if (module.includes('dom-serializer')) {
+                return domSerializer;
+            }
+            if (module.includes('parse5-htmlparser2-tree-adapter')) {
+                return parse5Htmlparser2TreeAdapter;
+            }
+            if (module.includes('parse5')) {
+                return parse5;
+            }
+            const moduleFileName = module.split('/')?.pop();
+            if (this.files.hasFile(moduleFileName)) {
+                const vmContext = { module: { exports: {} }, exports: {}, ...this.createNodeVmContext() };
+                vm.runInNewContext(this.files.getByName(moduleFileName).getContent(), vmContext);
+                return { ...vmContext.module.exports, ...vmContext.exports };
+            }
+        };
+    }
+    createProcessPartial() {
+        return {
+            hrtime: process.hrtime
+        };
+    }
+    /**
+     * Fetches and returns the latest dynamic fetcher from the code repository. If a new version is available online it is
+     * downloaded and cached, otherwise the fetcher id returned from cache. The resulting module gets minified afterwards.
+     *
+     * @param {Map<string, string>} basePaths tha path mapping to resolve imports from
+     * @param {string} dynamicFetcher the dynamic fetcher to bundle the config with
+     *
+     * @returns {Promise<string>} a Promise which resolves to the latest dynamic fetcher
+     */
+    async bundleDynamicFetcher(basePaths, dynamicFetcher) {
+        const IMPORT_PATHS = {
+            'dynamicFetcher': 'https://www.baqend.com/speed-kit/latest/',
+        };
+        return this.bundler.bundle({
+            basePaths: basePaths,
+            entryPoints: { "dynamicFetcher.js": dynamicFetcher },
+            target: "es6",
+            minify: true,
+            platform: "browser",
+        });
+    }
+}
+exports.DocumentHandlerServer = DocumentHandlerServer;

package/dist/services/document-handler-runtime/error/handler/required-file-not-found-handler.d.ts

@@ -0,0 +1,6 @@
+import ErrorHandlerInterface from "../../../error-handling/interface/error-handler-interface";
+import RequiredFileNotFoundError from "../required-file-not-found-error";
+export default class RequiredFileNotFoundHandler implements ErrorHandlerInterface {
+    canHandle(error: any): boolean;
+    handle(error: RequiredFileNotFoundError): any;
+}

package/dist/services/document-handler-runtime/error/handler/required-file-not-found-handler.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const required_file_not_found_error_1 = tslib_1.__importDefault(require("../required-file-not-found-error"));
+class RequiredFileNotFoundHandler {
+    canHandle(error) {
+        return error instanceof required_file_not_found_error_1.default;
+    }
+    handle(error) {
+        console.error(error.message);
+        console.warn('Did you choose the correct folder?');
+    }
+}
+exports.default = RequiredFileNotFoundHandler;

package/dist/services/document-handler-runtime/error/required-file-not-found-error.d.ts

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

package/dist/services/document-handler-runtime/error/required-file-not-found-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 RequiredFileNotFoundError extends application_error_1.default {
+}
+exports.default = RequiredFileNotFoundError;

package/dist/services/document-handler-runtime/factory/document-handler-runtime-service-factory.d.ts

@@ -0,0 +1,24 @@
+import DocumentHandlerRuntimeContext from "../context/document-handler-runtime-context";
+import DocumentHandlerRuntimeService from "../document-handler-runtime-service";
+import AbstractAsyncErrorHandlingFactory from "../../error-handling/abstract/abstract-async-error-handling-factory";
+import ErrorHandlerInterface from "../../error-handling/interface/error-handler-interface";
+import { DocumentHandlerServer } from "../document-handler-server";
+import { FileListInterface } from "../../integration-api/integration-api-model";
+import { UserCliConfig } from "../../../helpers/cli-config";
+export default class DocumentHandlerRuntimeServiceFactory extends AbstractAsyncErrorHandlingFactory {
+    private readonly context;
+    private cliConfig;
+    private files?;
+    constructor(context: DocumentHandlerRuntimeContext, cliConfig: UserCliConfig, files?: FileListInterface);
+    _buildService(): Promise<DocumentHandlerRuntimeService>;
+    buildDocumentHandlerServer(): Promise<DocumentHandlerServer>;
+    private prepareIntegrationApi;
+    private getIntegrationFiles;
+    private checkRequiredFiles;
+    private createNeededFolderStructure;
+    private prepareLocalDocumentHandler;
+    private preparePackageJson;
+    private prepareTestCases;
+    private getCustomerConfig;
+    static getErrorHandlers(): ErrorHandlerInterface[];
+}

package/dist/services/document-handler-runtime/factory/document-handler-runtime-service-factory.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const integration_api_context_1 = tslib_1.__importDefault(require("../../integration-api/context/integration-api-context"));
+const integration_api_service_factory_1 = tslib_1.__importDefault(require("../../integration-api/factory/integration-api-service-factory"));
+const document_handler_runtime_context_1 = require("../context/document-handler-runtime-context");
+const document_handler_runtime_service_1 = tslib_1.__importDefault(require("../document-handler-runtime-service"));
+const abstract_async_error_handling_factory_1 = tslib_1.__importDefault(require("../../error-handling/abstract/abstract-async-error-handling-factory"));
+const cli_1 = require("../../cli");
+const required_file_not_found_handler_1 = tslib_1.__importDefault(require("../error/handler/required-file-not-found-handler"));
+const required_file_not_found_error_1 = tslib_1.__importDefault(require("../error/required-file-not-found-error"));
+const document_handler_server_1 = require("../document-handler-server");
+const bundler_1 = require("../../bundler");
+class DocumentHandlerRuntimeServiceFactory extends abstract_async_error_handling_factory_1.default {
+    context;
+    cliConfig;
+    files;
+    constructor(context, cliConfig, files) {
+        super();
+        this.context = context;
+        this.cliConfig = cliConfig;
+        this.files = files;
+    }
+    async _buildService() {
+        const integrationApi = this.prepareIntegrationApi();
+        const files = await this.getIntegrationFiles(integrationApi);
+        this.checkRequiredFiles(files);
+        const cliService = (new cli_1.CliServiceFactory()).getService();
+        const customerConfig = this.getCustomerConfig(files);
+        this.preparePackageJson(integrationApi, customerConfig);
+        return new document_handler_runtime_service_1.default(files, customerConfig, cliService, { testNames: this.context.testNames || [] }, customerConfig.skCliPre, customerConfig.skCliPost);
+    }
+    async buildDocumentHandlerServer() {
+        const integrationApiContext = new integration_api_context_1.default(this.context.customerPath, this.context.configName, []);
+        const files = this.files || await new integration_api_service_factory_1.default(integrationApiContext, this.cliConfig).buildService().run();
+        const customerConfig = this.getCustomerConfig(files);
+        const bundler = new bundler_1.BundleServiceFactory().buildService();
+        const cliService = (new cli_1.CliServiceFactory()).getService();
+        return new document_handler_server_1.DocumentHandlerServer(customerConfig, files, bundler, cliService, this.context.verboseLevel);
+    }
+    prepareIntegrationApi() {
+        const integrationApiContext = new integration_api_context_1.default(this.context.customerPath, this.context.configName, this.context.fileDependencies, ['.git', '.idea', 'node_modules']);
+        return new integration_api_service_factory_1.default(integrationApiContext, this.cliConfig).buildService();
+    }
+    async getIntegrationFiles(integrationApi) {
+        this.createNeededFolderStructure(integrationApi);
+        this.prepareLocalDocumentHandler(integrationApi);
+        this.prepareTestCases(integrationApi);
+        return await integrationApi.run();
+    }
+    checkRequiredFiles(files) {
+        this.context.requiredFiles.forEach((requiredFile) => {
+            if (!files.hasFile(requiredFile)) {
+                throw new required_file_not_found_error_1.default({ message: `file ${requiredFile} not found` });
+            }
+        });
+    }
+    createNeededFolderStructure(integrationApi) {
+        integrationApi.createFolder('.local');
+        integrationApi.createFolder('.local/test');
+        integrationApi.createFolder('.local/test/src');
+        integrationApi.createFolder('.local/test/tmp');
+        integrationApi.createFolder('.local/test/tmp/server');
+    }
+    prepareLocalDocumentHandler(integrationApi) {
+        if (!integrationApi.fileExists(`.local/test/src/${document_handler_runtime_context_1.TEST_DOCUMENT_HANDLER_FILE_NAME}`)) {
+            integrationApi.writeFile(`.local/test/src/${document_handler_runtime_context_1.TEST_DOCUMENT_HANDLER_FILE_NAME}`);
+        }
+        if (!integrationApi.fileExists(`.local/test/src/${document_handler_runtime_context_1.TEST_DATABASE_MOCK_FILE_NAME}`)) {
+            integrationApi.writeFile(`.local/test/src/${document_handler_runtime_context_1.TEST_DATABASE_MOCK_FILE_NAME}`);
+        }
+        if (!integrationApi.fileExists(`.local/test/src/${document_handler_runtime_context_1.TEST_ORESTES_MOCK_FILE_NAME}`)) {
+            integrationApi.writeFile(`.local/test/src/${document_handler_runtime_context_1.TEST_ORESTES_MOCK_FILE_NAME}`);
+        }
+        if (!integrationApi.fileExists(`.local/test/src/${document_handler_runtime_context_1.TEST_RUNTIME_FILE_NAME}`)) {
+            integrationApi.writeFile(`.local/test/src/${document_handler_runtime_context_1.TEST_RUNTIME_FILE_NAME}`);
+        }
+        if (!integrationApi.fileExists(`.local/test/src/${document_handler_runtime_context_1.TEST_PACKAGE_JSON}`, "json")) {
+            integrationApi.writeFile(`.local/test/src/${document_handler_runtime_context_1.TEST_PACKAGE_JSON}`, "json");
+        }
+    }
+    preparePackageJson(integrationApi, customerConfig) {
+        if (customerConfig.dependencies && !integrationApi.fileExists(`.local/test/${document_handler_runtime_context_1.TEST_PACKAGE_JSON}`, 'json')) {
+            integrationApi.writeFile(`.local/test/${document_handler_runtime_context_1.TEST_PACKAGE_JSON}`, 'json');
+        }
+    }
+    prepareTestCases(integrationApi) {
+        if (this.context.testNames && this.context.testNames.length > 0) {
+            this.context.testNames.map(async (testName) => {
+                if (!integrationApi.fileExists(`.local/test/${document_handler_runtime_context_1.TEST_FILE_NAME_PREFIX}-${testName}`)) {
+                    integrationApi.writeFile(`.local/test/${document_handler_runtime_context_1.TEST_FILE_NAME_PREFIX}-${testName}`);
+                }
+            });
+        }
+    }
+    getCustomerConfig(files) {
+        const configFile = files.getByName('config_customer');
+        return configFile.config;
+    }
+    static getErrorHandlers() {
+        return [
+            new required_file_not_found_handler_1.default()
+        ];
+    }
+}
+exports.default = DocumentHandlerRuntimeServiceFactory;

package/dist/services/document-handler-runtime/interface/document-handler-runtime-config-interface.d.ts

@@ -0,0 +1,3 @@
+export default class DocumentHandlerRuntimeConfigInterface {
+    readonly testNames?: string[];
+}

package/dist/services/document-handler-runtime/interface/document-handler-runtime-config-interface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DocumentHandlerRuntimeConfigInterface {
+    testNames;
+}
+exports.default = DocumentHandlerRuntimeConfigInterface;

package/dist/services/document-handler-runtime/interface/template-context-interface.d.ts

@@ -0,0 +1,3 @@
+export default interface TemplateContextInterface {
+    [key: string]: string | number | object | boolean;
+}

package/dist/services/document-handler-runtime/interface/template-context-interface.js

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

package/dist/services/document-handler-runtime/interface/template-interface.d.ts

@@ -0,0 +1,6 @@
+import TemplateParam from "./template-param-interface";
+import TemplateContextInterface from "./template-context-interface";
+export default interface TemplateInterface {
+    _buildContext(...params: TemplateParam[]): TemplateContextInterface;
+    render(context: TemplateContextInterface): string;
+}

package/dist/services/document-handler-runtime/interface/template-interface.js

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

package/dist/services/document-handler-runtime/interface/template-param-interface.d.ts

@@ -0,0 +1,4 @@
+export default interface TemplateParam {
+    key: string;
+    value: string | number | object;
+}

package/dist/services/document-handler-runtime/interface/template-param-interface.js

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

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

@@ -0,0 +1,9 @@
+import TemplateInterface from "../interface/template-interface";
+import TemplateParam from "../interface/template-param-interface";
+import TemplateContextInterface from "../interface/template-context-interface";
+import { Template } from 'handlebars';
+export default abstract class AbstractTemplate implements TemplateInterface {
+    _buildContext(...params: TemplateParam[]): TemplateContextInterface;
+    render(context: TemplateContextInterface): string;
+    protected abstract getTemplate(): Template;
+}

package/dist/services/document-handler-runtime/templates/abstract-template.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+class AbstractTemplate {
+    _buildContext(...params) {
+        let context = {};
+        params.forEach(({ key, value }) => {
+            context[key] = value;
+        });
+        return context;
+    }
+    render(context) {
+        const template = handlebars_1.default.compile(this.getTemplate());
+        return template(context);
+    }
+}
+exports.default = AbstractTemplate;

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

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

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_template_1 = tslib_1.__importDefault(require("./abstract-template"));
+class DatabaseMock extends abstract_template_1.default {
+    buildContext(domain, app) {
+        return { domain, app };
+    }
+    getTemplate() {
+        return `
+class dataHandler {
+  data = []
+  constructor(data = []){
+    this.data = data
+  }
+
+  static load() {
+    return this
+  }
+
+  static send() {
+    return this
+  }
+
+  static where(query) {
+    return this
+  }
+
+  static find() {
+    return this
+  }
+
+  static save() {
+    return this
+  }
+
+  static eq() {
+    return this
+  }
+
+  static le() {
+    return this
+  }
+
+  static gt() {
+    return this
+  }
+
+  static limit(number) {
+    return this
+  }
+
+  static equal(number) {
+    return this
+  }
+
+  static count(number) {
+    return this
+  }
+
+  static sort(number) {
+    return this
+  }
+
+  static descending(direction) {
+    return this
+  }
+
+  static singleResult() {
+    return
+  }
+
+  static resultList(callback) {
+    callback()
+  }
+}
+
+class database {
+  static 'jobs.Status' = dataHandler
+  static 'jobs.Definition' = dataHandler
+  static 'speedKit.Release' = dataHandler
+  static 'speedKit.Asset' = dataHandler
+  static 'MasterHash' = dataHandler
+  static 'connection' = {
+    secure:true,
+    host:"{{app}}.app.baqend.com",
+    port:"443"
+    }
+
+  static log = {
+    info: (msg, dump) => {
+      console.log('info: ' + msg, dump)
+    },
+    warn: (msg, dump) => {
+      console.info('warn: ' + msg, dump)
+    },
+    error: (msg, dump) => {
+      console.error('error: '+ msg, dump)
+    },
+    debug: (msg, dump) => {
+      console.log('error: ' + msg, dump)
+    },
+  }
+}
+
+module.exports = database
+
+    `;
+    }
+}
+exports.default = DatabaseMock;

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

@@ -0,0 +1,6 @@
+import AbstractTemplate from "./abstract-template";
+import TemplateContextInterface from "../interface/template-context-interface";
+export default class ExecuteDocumentHandler extends AbstractTemplate {
+    buildContext(domain: string, file: string): TemplateContextInterface;
+    protected getTemplate(): Handlebars.Template;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_template_1 = tslib_1.__importDefault(require("./abstract-template"));
+class ExecuteDocumentHandler extends abstract_template_1.default {
+    buildContext(domain, file) {
+        return { domain, file };
+    }
+    getTemplate() {
+        return `const database = require('./database-mock');
+const documentHandler = require('./testDocumentHandler');
+const fs = require('fs');
+const fetch = require('node-fetch');
+const {resolve} = require("path");
+global.Abort = Error;
+const NS_PER_SEC = 1e9;
+const MS_PER_NS = 1e-6;
+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'}
+const files = [
+     {
+         url: '{{domain}}',
+         file: '{{file}}',
+         variation: 'DEFAULT',
+         headers: JSON.stringify(DEFAULT_HEADERS),
+     },
+]
+
+const testLimit = 1;
+
+async function run(iterator) {
+    const promises = [];
+    for (item of files) {
+        let fileName = item.file;
+        let file = await (await fetch(item.url,{headers: item?.headers ? JSON.parse(item.headers) : DEFAULT_HEADERS})).text()
+        let time = process.hrtime();
+
+        let query = {
+            variation: item.variation || 'DEFAULT',
+            headers: item?.headers ? item.headers : JSON.stringify(DEFAULT_HEADERS),
+            url: item.url,
+        }
+        let req = {
+            query, body: file
+        }
+        for (i = 0; i < testLimit; i++) {
+
+            // promises.push((async () => {
+                const content = await documentHandler.transform(database, req);
+                fs.writeFileSync(resolve(__dirname,'../tmp/' + fileName + i + item.variation + '-processed.html'), content);
+                benchmark(time)
+            // })())
+        }
+    }
+    // Promise.all(promises)
+}
+
+const runTest = async () => {
+    await run()
+}
+
+runTest()
+
+// ===================================================== //
+
+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\`);
+}
+    `;
+    }
+}
+exports.default = ExecuteDocumentHandler;