@stemy/backend 5.0.7 → 5.0.8

package/fesm2015/stemy-backend.mjs

@@ -1,6 +1,5 @@
 import { __awaiter, __decorate, __param, __metadata } from 'tslib';
 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';
@@ -1298,18 +1298,6 @@ class LazyAsset extends BaseEntity {
             });
         });
     }
-    load() {
-        const _super = Object.create(null, {
-            load: { get: () => super.load }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.load.call(this);
-            if (this.deleted)
-                return this;
-            this.data.jobParams = JSON.parse(yield gunzipPromised(this.data.jobParams));
-            return this;
-        });
-    }
     loadAsset() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.load();
@@ -1338,7 +1326,8 @@ class LazyAsset extends BaseEntity {
             this.data.progressId = (yield this.progresses.create()).id;
             this.data.assetId = null;
             yield this.save();
-            yield this.progresses.jobMan.enqueueWithName(this.data.jobName, Object.assign(Object.assign({}, this.data.jobParams), { lazyId: this.id, fromLoad }));
+            const jobParams = JSON.parse(yield gunzipPromised(this.data.jobParams));
+            yield this.progresses.jobMan.enqueueWithName(this.data.jobName, Object.assign(Object.assign({}, jobParams), { lazyId: this.id, fromLoad }));
         });
     }
 }
@@ -1384,7 +1373,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) {
@@ -1437,23 +1426,16 @@ let JobManager = class JobManager {
             });
         });
     }
-    startProcessing() {
+    initProcessing() {
         return __awaiter(this, void 0, void 0, function* () {
-            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;
-            }
             const host = this.config.resolve("zmqRemoteHost");
             const pushHost = `${host}:${this.config.resolve("zmqBackPort")}`;
             this.workerPush = socket("push");
-            yield 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");
-            yield this.workerPull.connect(pullHost);
+            this.workerPull.connect(pullHost);
             this.logger.log("job-manager", `Worker consumer connected to: ${pullHost}`);
             this.workerPull.on("message", (name, args, uniqId) => __awaiter(this, void 0, void 0, function* () {
                 try {
@@ -1477,6 +1459,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]) {
@@ -1535,16 +1521,14 @@ let JobManager = class JobManager {
     }
     sendToWorkers(jobName, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const publisher = yield this.apiPush;
             const uniqueId = new ObjectId$1().toHexString();
-            yield 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,
@@ -1935,12 +1919,187 @@ 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;
+    }
+    schemaToExample(src, req) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+                yield Promise.all(Object.keys(schema.properties).map((key) => __awaiter(this, void 0, void 0, function* () {
+                    result[key] = yield this.schemaToExample(schema.properties[key], req);
+                })));
+                return result;
+            }
+            if (schema.type === "array") {
+                return [yield 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 (_a = schema.default) !== null && _a !== void 0 ? _a : 0;
+            }
+            else if (schema.type === "boolean") {
+                return (_b = schema.default) !== null && _b !== void 0 ? _b : false;
+            }
+            else {
+                return (_c = schema.default) !== null && _c !== void 0 ? _c : 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;
+    }
+    load(output) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.fixtures)
+                return;
+            output = output || {
+                write: console.log,
+                writeln: t => console.log(t + "\n")
+            };
+            for (let fixture of this.fixtures) {
+                yield 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, {
@@ -1955,10 +2114,50 @@ 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;
+    }
+    quickStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = this.config.resolve("appPort");
+            const isWorker = this.config.resolve("isWorker");
+            if (isWorker || this.config.resolve("startWorker")) {
+                yield this.container.resolve(JobManager).startProcessing();
+                if (isWorker) {
+                    return;
+                }
+            }
+            if (this.config.resolve("fixtures")) {
+                const fixtures = this.container.resolve(Fixtures);
+                yield 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 {
@@ -2060,31 +2259,6 @@ EndpointProvider = __decorate([
     scoped(Lifecycle.ContainerScoped)
 ], EndpointProvider);
 
-let Fixtures = class Fixtures {
-    constructor(fixtures) {
-        this.fixtures = fixtures;
-    }
-    load(output) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.fixtures)
-                return;
-            output = output || {
-                write: console.log,
-                writeln: t => console.log(t + "\n")
-            };
-            for (let fixture of this.fixtures) {
-                yield 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;
@@ -2552,157 +2726,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;
-    }
-    schemaToExample(src, req) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = {};
-                yield Promise.all(Object.keys(schema.properties).map((key) => __awaiter(this, void 0, void 0, function* () {
-                    result[key] = yield this.schemaToExample(schema.properties[key], req);
-                })));
-                return result;
-            }
-            if (schema.type === "array") {
-                return [yield 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 (_a = schema.default) !== null && _a !== void 0 ? _a : 0;
-            }
-            else if (schema.type === "boolean") {
-                return (_b = schema.default) !== null && _b !== void 0 ? _b : false;
-            }
-            else {
-                return (_c = schema.default) !== null && _c !== void 0 ? _c : 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;
@@ -4360,6 +4383,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", "-"),
@@ -4559,25 +4584,14 @@ 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(Object.assign({ io: bp.io }, socketOptions))
             });
         }
-        diContainer.register(SOCKET_CONTROLLERS, {
-            useValue: new SocketControllers(Object.assign({ io: bp.io }, socketOptions))
-        });
         // Connect to mongo if necessary
         if (configuration.hasParam("mongoUri") && configuration.resolve("mongoUri")) {
             console.log("Connecting to MongoDB...");