@stemy/backend 5.0.7 → 5.0.8

package/fesm2020/stemy-backend.mjs

@@ -1,5 +1,4 @@
 import { dirname, basename, join, resolve } from 'path';
-import bodyParser from 'body-parser';
 import webToken from 'jsonwebtoken';
 import { injectable, scoped, Lifecycle, singleton, injectAll, inject, isFactoryProvider, container } from 'tsyringe';
 import { HttpError, getMetadataArgsStorage, Authorized, Post, UploadedFile, Body, Get, Param, QueryParam, Res, QueryParams, Controller, UnauthorizedError, CurrentUser, Header, BadRequestError, Middleware, createParamDecorator, useContainer, useExpressServer } from 'routing-controllers';
@@ -25,15 +24,16 @@ import cron from 'node-cron';
 import { socket } from 'zeromq';
 import { filter as filter$1, map, first, timeout } from 'rxjs/operators';
 import { createServer } from 'http';
-import express_ from 'express';
 import { Server } from 'socket.io';
-import { v4 } from 'uuid';
-import { createTransport } from 'nodemailer';
-import * as Handlebars from 'handlebars';
+import express_ from 'express';
+import bodyParser from 'body-parser';
 import { routingControllersToSpec, OpenAPI, getStatusCode } from 'routing-controllers-openapi';
 import { defaultMetadataStorage } from 'class-transformer/cjs/storage';
 import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
 import { ValidatorConstraint, ValidationTypes, Min, Max, IsOptional, IsBoolean } from 'class-validator';
+import { v4 } from 'uuid';
+import { createTransport } from 'nodemailer';
+import * as Handlebars from 'handlebars';
 import { CommandsAddon, AnsiCodes } from '@stemy/terminal-commands-addon';
 import { compare } from 'bcrypt';
 import moment from 'moment';
@@ -1237,13 +1237,6 @@ class LazyAsset extends BaseEntity {
             });
         });
     }
-    async load() {
-        await super.load();
-        if (this.deleted)
-            return this;
-        this.data.jobParams = JSON.parse(await gunzipPromised(this.data.jobParams));
-        return this;
-    }
     async loadAsset() {
         await this.load();
         if (this.deleted)
@@ -1267,7 +1260,8 @@ class LazyAsset extends BaseEntity {
         this.data.progressId = (await this.progresses.create()).id;
         this.data.assetId = null;
         await this.save();
-        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...this.data.jobParams, lazyId: this.id, fromLoad });
+        const jobParams = JSON.parse(await gunzipPromised(this.data.jobParams));
+        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...jobParams, lazyId: this.id, fromLoad });
     }
 }
 
@@ -1312,7 +1306,7 @@ let JobManager = class JobManager {
             return res;
         }, {});
         this.messages = new Subject();
-        this.processing = false;
+        this.processing = null;
         this.maxTimeout = this.config.resolve("jobTimeout");
     }
     on(message, cb) {
@@ -1359,22 +1353,15 @@ let JobManager = class JobManager {
             });
         });
     }
-    async startProcessing() {
-        if (this.processing)
-            return null;
-        this.processing = true;
-        if (!this.config.resolve("isWorker")) {
-            this.logger.log("job-manager", colorize(`Processing can not be started because this is NOT a worker process!`, ConsoleColor.FgRed));
-            return null;
-        }
+    async initProcessing() {
         const host = this.config.resolve("zmqRemoteHost");
         const pushHost = `${host}:${this.config.resolve("zmqBackPort")}`;
         this.workerPush = socket("push");
-        await this.workerPush.connect(pushHost);
+        this.workerPush.connect(pushHost);
         this.logger.log("job-manager", `Worker producer connected to: ${pushHost}`);
         const pullHost = `${host}:${this.config.resolve("zmqPort")}`;
         this.workerPull = socket("pull");
-        await this.workerPull.connect(pullHost);
+        this.workerPull.connect(pullHost);
         this.logger.log("job-manager", `Worker consumer connected to: ${pullHost}`);
         this.workerPull.on("message", async (name, args, uniqId) => {
             try {
@@ -1397,6 +1384,10 @@ let JobManager = class JobManager {
             }
         });
     }
+    startProcessing() {
+        this.processing = this.processing || this.initProcessing();
+        return this.processing;
+    }
     tryResolve(jobType, params) {
         const jobName = getConstructorName(jobType);
         if (!this.jobs[jobName]) {
@@ -1454,15 +1445,13 @@ let JobManager = class JobManager {
         return container.resolve(jobType);
     }
     async sendToWorkers(jobName, params) {
-        const publisher = await this.apiPush;
         const uniqueId = new ObjectId$1().toHexString();
-        await publisher.send([jobName, JSON.stringify(params), uniqueId]);
+        this.apiPush.send([jobName, JSON.stringify(params), uniqueId]);
         return uniqueId;
     }
 };
 JobManager = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped),
+    singleton(),
     __param(2, inject(DI_CONTAINER)),
     __param(3, injectAll(JOB)),
     __metadata("design:paramtypes", [Configuration,
@@ -1803,12 +1792,182 @@ AssetResolver = __decorate([
     __metadata("design:paramtypes", [Assets, LazyAssets])
 ], AssetResolver);
 
+function checkValue(multi, value) {
+    if (multi) {
+        return Array.isArray(value) && value.every(v => {
+            try {
+                const id = new ObjectId$1(v);
+                return id instanceof ObjectId$1;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+    if (null === value)
+        return true;
+    try {
+        const id = new ObjectId$1(value);
+        return id instanceof ObjectId$1;
+    }
+    catch (e) {
+        return false;
+    }
+}
+let IsFile = class IsFile {
+    validate(value, validationArguments) {
+        const [multi] = (validationArguments.constraints || []);
+        return checkValue(multi, value);
+    }
+};
+IsFile = __decorate([
+    ValidatorConstraint()
+], IsFile);
+let IsObjectId = class IsObjectId {
+    validate(value, validationArguments) {
+        const [_, multi] = (validationArguments.constraints || []);
+        return checkValue(multi, value);
+    }
+};
+IsObjectId = __decorate([
+    ValidatorConstraint()
+], IsObjectId);
+
+let OpenApi = class OpenApi {
+    constructor(container, customValidation) {
+        this.container = container;
+        this.customValidation = customValidation;
+        this.docs = null;
+    }
+    get apiDocs() {
+        if (!this.docs)
+            this.docs = this.createApiDocs();
+        return this.docs;
+    }
+    get apiDocsStr() {
+        if (!this.docsStr)
+            this.docsStr = JSON.stringify(this.apiDocs);
+        return this.docsStr;
+    }
+    async schemaToExample(src, req) {
+        const maybeRef = src;
+        if (maybeRef.$ref) {
+            const schemas = this.apiDocs.components.schemas;
+            const schema = maybeRef.$ref
+                .replace("#/components/schemas/", "")
+                .replace("#/definitions/", "");
+            return this.schemaToExample(schemas[schema], req);
+        }
+        let schema = src;
+        if (schema.oneOf) {
+            schema = Object.assign({}, schema, schema.oneOf[0]);
+        }
+        if (schema.type === "object") {
+            const result = {};
+            await Promise.all(Object.keys(schema.properties).map(async (key) => {
+                result[key] = await this.schemaToExample(schema.properties[key], req);
+            }));
+            return result;
+        }
+        if (schema.type === "array") {
+            return [await this.schemaToExample(schema.items, req)];
+        }
+        if (schema.type === "string") {
+            if (isDefined(schema.default)) {
+                if (isFunction(schema.default)) {
+                    return schema.default(this.container);
+                }
+                return schema.default;
+            }
+            if (schema.format == "date") {
+                return new Date().toISOString().substr(0, 10);
+            }
+            if (schema.format == "date-time") {
+                return new Date().toISOString();
+            }
+            if (schema.enum) {
+                return schema.enum[0];
+            }
+            return "string";
+        }
+        if (schema.type === "number") {
+            return schema.default ?? 0;
+        }
+        else if (schema.type === "boolean") {
+            return schema.default ?? false;
+        }
+        else {
+            return schema.default ?? null;
+        }
+    }
+    createApiDocs() {
+        const storage = getMetadataArgsStorage();
+        const docs = routingControllersToSpec(storage);
+        docs.basePath = "/api/";
+        docs.definitions = validationMetadatasToSchemas({
+            classTransformerMetadataStorage: defaultMetadataStorage,
+            additionalConverters: {
+                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
+                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;
+                    if (isObject(res))
+                        return res;
+                    const constraints = meta.constraints || [];
+                    if (meta.constraintCls === IsFile) {
+                        return {
+                            multi: constraints[0] || false,
+                            type: "file"
+                        };
+                    }
+                    if (meta.constraintCls === IsObjectId) {
+                        return {
+                            endpoint: constraints[0] || false,
+                            multi: constraints[1] || false,
+                            type: "list"
+                        };
+                    }
+                    return null;
+                }
+            }
+        });
+        docs.components.schemas = docs.definitions;
+        return docs;
+    }
+};
+OpenApi = __decorate([
+    singleton(),
+    __param(0, inject(DI_CONTAINER)),
+    __param(1, inject(OPENAPI_VALIDATION)),
+    __metadata("design:paramtypes", [Object, Object])
+], OpenApi);
+
+let Fixtures = class Fixtures {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+    async load(output) {
+        if (!this.fixtures)
+            return;
+        output = output || {
+            write: console.log,
+            writeln: t => console.log(t + "\n")
+        };
+        for (let fixture of this.fixtures) {
+            await fixture.load(output);
+        }
+    }
+};
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, injectAll(FIXTURE)),
+    __metadata("design:paramtypes", [Array])
+], Fixtures);
+
 const express = express_;
 let BackendProvider = class BackendProvider {
-    constructor() {
-        this.express = express();
-        this.express.set("trust proxy", true);
-        this.server = createServer(this.express);
+    constructor(config, container) {
+        this.config = config;
+        this.container = container;
     }
     get io() {
         this.ioServer = this.ioServer || new Server(this.server, {
@@ -1823,10 +1982,48 @@ let BackendProvider = class BackendProvider {
         });
         return this.ioServer;
     }
+    get express() {
+        if (!this.expressApp) {
+            this.expressApp = express();
+            this.expressApp.set("trust proxy", true);
+            this.expressApp.use(bodyParser.json({
+                limit: this.config.resolve("jsonLimit")
+            }));
+            this.expressApp.get("/api-docs", (req, res) => {
+                this.openApi = this.openApi || this.container.get(OpenApi);
+                res.header("Content-Type", "application/json")
+                    .status(200)
+                    .end(this.openApi.apiDocsStr);
+            });
+        }
+        return this.expressApp;
+    }
+    get server() {
+        this.httpServer = this.httpServer || createServer(this.express);
+        return this.httpServer;
+    }
+    async quickStart() {
+        const port = this.config.resolve("appPort");
+        const isWorker = this.config.resolve("isWorker");
+        if (isWorker || this.config.resolve("startWorker")) {
+            await this.container.resolve(JobManager).startProcessing();
+            if (isWorker) {
+                return;
+            }
+        }
+        if (this.config.resolve("fixtures")) {
+            const fixtures = this.container.resolve(Fixtures);
+            await fixtures.load();
+        }
+        return new Promise(resolve => {
+            this.server.listen(port, () => resolve(`Service listening on port ${port}!`));
+        });
+    }
 };
 BackendProvider = __decorate([
     singleton(),
-    __metadata("design:paramtypes", [])
+    __param(1, inject(DI_CONTAINER)),
+    __metadata("design:paramtypes", [Configuration, Object])
 ], BackendProvider);
 
 let CacheProcessor = class CacheProcessor {
@@ -1912,29 +2109,6 @@ EndpointProvider = __decorate([
     scoped(Lifecycle.ContainerScoped)
 ], EndpointProvider);
 
-let Fixtures = class Fixtures {
-    constructor(fixtures) {
-        this.fixtures = fixtures;
-    }
-    async load(output) {
-        if (!this.fixtures)
-            return;
-        output = output || {
-            write: console.log,
-            writeln: t => console.log(t + "\n")
-        };
-        for (let fixture of this.fixtures) {
-            await fixture.load(output);
-        }
-    }
-};
-Fixtures = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped),
-    __param(0, injectAll(FIXTURE)),
-    __metadata("design:paramtypes", [Array])
-], Fixtures);
-
 const sharp$1 = sharp_;
 const bigSize = 1500;
 const thumbSize = 250;
@@ -2380,154 +2554,6 @@ MemoryCache = __decorate([
     __metadata("design:paramtypes", [Cache])
 ], MemoryCache);
 
-function checkValue(multi, value) {
-    if (multi) {
-        return Array.isArray(value) && value.every(v => {
-            try {
-                const id = new ObjectId$1(v);
-                return id instanceof ObjectId$1;
-            }
-            catch (e) {
-                return false;
-            }
-        });
-    }
-    if (null === value)
-        return true;
-    try {
-        const id = new ObjectId$1(value);
-        return id instanceof ObjectId$1;
-    }
-    catch (e) {
-        return false;
-    }
-}
-let IsFile = class IsFile {
-    validate(value, validationArguments) {
-        const [multi] = (validationArguments.constraints || []);
-        return checkValue(multi, value);
-    }
-};
-IsFile = __decorate([
-    ValidatorConstraint()
-], IsFile);
-let IsObjectId = class IsObjectId {
-    validate(value, validationArguments) {
-        const [_, multi] = (validationArguments.constraints || []);
-        return checkValue(multi, value);
-    }
-};
-IsObjectId = __decorate([
-    ValidatorConstraint()
-], IsObjectId);
-
-let OpenApi = class OpenApi {
-    constructor(container, customValidation) {
-        this.container = container;
-        this.customValidation = customValidation;
-        this.docs = null;
-    }
-    get apiDocs() {
-        if (!this.docs)
-            this.docs = this.createApiDocs();
-        return this.docs;
-    }
-    get apiDocsStr() {
-        if (!this.docsStr)
-            this.docsStr = JSON.stringify(this.apiDocs);
-        return this.docsStr;
-    }
-    async schemaToExample(src, req) {
-        const maybeRef = src;
-        if (maybeRef.$ref) {
-            const schemas = this.apiDocs.components.schemas;
-            const schema = maybeRef.$ref
-                .replace("#/components/schemas/", "")
-                .replace("#/definitions/", "");
-            return this.schemaToExample(schemas[schema], req);
-        }
-        let schema = src;
-        if (schema.oneOf) {
-            schema = Object.assign({}, schema, schema.oneOf[0]);
-        }
-        if (schema.type === "object") {
-            const result = {};
-            await Promise.all(Object.keys(schema.properties).map(async (key) => {
-                result[key] = await this.schemaToExample(schema.properties[key], req);
-            }));
-            return result;
-        }
-        if (schema.type === "array") {
-            return [await this.schemaToExample(schema.items, req)];
-        }
-        if (schema.type === "string") {
-            if (isDefined(schema.default)) {
-                if (isFunction(schema.default)) {
-                    return schema.default(this.container);
-                }
-                return schema.default;
-            }
-            if (schema.format == "date") {
-                return new Date().toISOString().substr(0, 10);
-            }
-            if (schema.format == "date-time") {
-                return new Date().toISOString();
-            }
-            if (schema.enum) {
-                return schema.enum[0];
-            }
-            return "string";
-        }
-        if (schema.type === "number") {
-            return schema.default ?? 0;
-        }
-        else if (schema.type === "boolean") {
-            return schema.default ?? false;
-        }
-        else {
-            return schema.default ?? null;
-        }
-    }
-    createApiDocs() {
-        const storage = getMetadataArgsStorage();
-        const docs = routingControllersToSpec(storage);
-        docs.basePath = "/api/";
-        docs.definitions = validationMetadatasToSchemas({
-            classTransformerMetadataStorage: defaultMetadataStorage,
-            additionalConverters: {
-                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
-                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;
-                    if (isObject(res))
-                        return res;
-                    const constraints = meta.constraints || [];
-                    if (meta.constraintCls === IsFile) {
-                        return {
-                            multi: constraints[0] || false,
-                            type: "file"
-                        };
-                    }
-                    if (meta.constraintCls === IsObjectId) {
-                        return {
-                            endpoint: constraints[0] || false,
-                            multi: constraints[1] || false,
-                            type: "list"
-                        };
-                    }
-                    return null;
-                }
-            }
-        });
-        docs.components.schemas = docs.definitions;
-        return docs;
-    }
-};
-OpenApi = __decorate([
-    singleton(),
-    __param(0, inject(DI_CONTAINER)),
-    __param(1, inject(OPENAPI_VALIDATION)),
-    __metadata("design:paramtypes", [Object, Object])
-], OpenApi);
-
 let TerminalManager = class TerminalManager {
     constructor(logger, config, commands) {
         this.logger = logger;
@@ -4125,6 +4151,8 @@ function createServices() {
         new Parameter("zmqBackPort", 3100),
         new Parameter("zmqRemoteHost", "tcp://127.0.0.1"),
         new Parameter("isWorker", false),
+        new Parameter("startWorker", false),
+        new Parameter("fixtures", true),
         new Parameter("mainEndpoint", ""),
         new Parameter("idChars", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
         new Parameter("idSeparator", "-"),
@@ -4330,28 +4358,17 @@ async function setupBackend(config, providers, parent) {
     const configuration = diContainer.resolve(Configuration);
     const bp = diContainer.resolve(BackendProvider);
     if (config.restOptions) {
-        bp.express.use(bodyParser.json({
-            limit: configuration.hasParam("jsonLimit")
-                ? configuration.resolve("jsonLimit")
-                : "250mb"
-        }));
         useContainer(diContainer);
         useExpressServer(bp.express, restOptions);
-        // Setup rest ai docs
-        let openApi = null;
-        bp.express.get("/api-docs", (req, res) => {
-            openApi = openApi || diContainer.get(OpenApi);
-            res.header("Content-Type", "application/json")
-                .status(200)
-                .end(openApi.apiDocsStr);
+    }
+    if (config.socketOptions) {
+        diContainer.register(SOCKET_CONTROLLERS, {
+            useValue: new SocketControllers({
+                io: bp.io,
+                ...socketOptions,
+            })
         });
     }
-    diContainer.register(SOCKET_CONTROLLERS, {
-        useValue: new SocketControllers({
-            io: bp.io,
-            ...socketOptions,
-        })
-    });
     // Connect to mongo if necessary
     if (configuration.hasParam("mongoUri") && configuration.resolve("mongoUri")) {
         console.log("Connecting to MongoDB...");