@stemy/backend 3.6.0 → 4.0.0

package/esm2020/socket-controllers/terminal.mjs

@@ -0,0 +1,85 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { first, map, timeout } from "rxjs/operators";
+import { fileTypeFromBuffer } from "../utils";
+export class Terminal {
+    constructor(client) {
+        this.client = client;
+        this.addons = [];
+        this.files$ = new BehaviorSubject([]);
+        this.input$ = new Subject();
+    }
+    onData(cb) {
+        const sub = this.input$.pipe(map(v => {
+            if (v === "\b") {
+                return "\x7f";
+            }
+            return v;
+        })).subscribe(cb);
+        return {
+            dispose: () => sub.unsubscribe()
+        };
+    }
+    write(data) {
+        this.client.emit("terminal-data", data);
+    }
+    writeln(data) {
+        this.write(data + "\n");
+    }
+    loadAddon(addon) {
+        addon.activate(this);
+        this.addons.push(addon);
+    }
+    dispose() {
+        this.input$.complete();
+        this.client = null;
+        this.addons.forEach(a => a.dispose());
+    }
+    async suggestFiles(accept) {
+        const rand = Math.round(Math.random() * 1000);
+        const id = `${Date.now()}-${rand}`;
+        const files = this.files$.value;
+        return files.filter(f => f.accept === accept).concat([
+            {
+                id,
+                label: "...",
+                onAccept: async () => {
+                    this.client.emit("terminal-upload", {
+                        id,
+                        accept
+                    });
+                    const file = await this.files$
+                        .pipe(first(v => v.some(f => f.id === id)))
+                        .pipe(timeout(120000))
+                        .pipe(map(v => v.find(f => f.id === id)))
+                        .toPromise();
+                    if (file.error) {
+                        this.files$.next(this.files$.value.filter(f => f.id !== id));
+                        throw new Error(file.error);
+                    }
+                    return file;
+                },
+                showAlways: true,
+                accept: accept,
+            }
+        ]);
+    }
+    async downloadFile(filename, buffer) {
+        const type = await fileTypeFromBuffer(buffer);
+        const data = buffer.toString("base64");
+        const content = `data:${type.mime};base64,${data}`;
+        this.client.emit("terminal-download", {
+            filename,
+            content
+        });
+    }
+    addFile(upload) {
+        if (upload.content) {
+            upload.buffer = Buffer.from(upload.content, "base64");
+        }
+        this.files$.next(this.files$.value.concat(upload));
+    }
+    input(data) {
+        this.input$.next(data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal.js","sourceRoot":"","sources":["../../../src/socket-controllers/terminal.ts"],"names":[],"mappings":"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","sourcesContent":["import {BehaviorSubject, Subject} from \"rxjs\";\r\nimport {first, map, timeout} from \"rxjs/operators\";\r\nimport {IDisposable, ISuggestion, ITerminalAddon} from \"@stemy/terminal-commands-addon\";\r\nimport {IClientSocket, ITerminal, ITerminalFile} from \"../common-types\";\r\nimport {fileTypeFromBuffer} from \"../utils\";\r\n\r\nexport class Terminal implements ITerminal {\r\n    protected addons: ITerminalAddon[];\r\n    protected files$: BehaviorSubject<ITerminalFile[]>;\r\n    protected input$: Subject<string>;\r\n\r\n    constructor(protected client: IClientSocket) {\r\n        this.addons = [];\r\n        this.files$ = new BehaviorSubject([]);\r\n        this.input$ = new Subject();\r\n    }\r\n\r\n    onData(cb: (data: string) => any): IDisposable {\r\n        const sub = this.input$.pipe(map(v => {\r\n            if (v === \"\\b\") {\r\n                return \"\\x7f\";\r\n            }\r\n            return v;\r\n        })).subscribe(cb);\r\n        return {\r\n            dispose: () => sub.unsubscribe()\r\n        };\r\n    }\r\n\r\n    write(data: string): void {\r\n        this.client.emit(\"terminal-data\", data);\r\n    }\r\n\r\n    writeln(data: string): void {\r\n        this.write(data + \"\\n\");\r\n    }\r\n\r\n    loadAddon(addon: ITerminalAddon) {\r\n        addon.activate(this);\r\n        this.addons.push(addon);\r\n    }\r\n\r\n    dispose() {\r\n        this.input$.complete();\r\n        this.client = null;\r\n        this.addons.forEach(a => a.dispose());\r\n    }\r\n\r\n    async suggestFiles(accept: string): Promise<ITerminalFile[]> {\r\n        const rand = Math.round(Math.random() * 1000);\r\n        const id = `${Date.now()}-${rand}`;\r\n        const files = this.files$.value as ISuggestion[];\r\n        return files.filter(f => f.accept === accept).concat([\r\n            {\r\n                id,\r\n                label: \"...\",\r\n                onAccept: async () => {\r\n                    this.client.emit(\"terminal-upload\", {\r\n                        id,\r\n                        accept\r\n                    });\r\n                    const file = await this.files$\r\n                        .pipe(first(v => v.some(f => f.id === id)))\r\n                        .pipe(timeout(120000))\r\n                        .pipe(map(v => v.find(f => f.id === id)))\r\n                        .toPromise();\r\n                    if (file.error) {\r\n                        this.files$.next(this.files$.value.filter(f => f.id !== id));\r\n                        throw new Error(file.error);\r\n                    }\r\n                    return file;\r\n                },\r\n                showAlways: true,\r\n                accept: accept,\r\n            }\r\n        ]);\r\n    }\r\n\r\n    async downloadFile(filename: string, buffer: Buffer): Promise<void> {\r\n        const type = await fileTypeFromBuffer(buffer);\r\n        const data = buffer.toString(\"base64\");\r\n        const content = `data:${type.mime};base64,${data}`;\r\n        this.client.emit(\"terminal-download\", {\r\n            filename,\r\n            content\r\n        });\r\n    }\r\n\r\n    addFile(upload: ITerminalFile) {\r\n        if (upload.content) {\r\n            upload.buffer = Buffer.from(upload.content, \"base64\");\r\n        }\r\n        this.files$.next(this.files$.value.concat(upload));\r\n    }\r\n\r\n    input(data: string) {\r\n        this.input$.next(data);\r\n    }\r\n}\r\n"]}

package/esm2020/socket-middlewares/compression.middleware.mjs

@@ -0,0 +1,14 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "socket-controllers";
+let CompressionMiddleware = class CompressionMiddleware {
+    use(socket, next) {
+        next();
+    }
+};
+CompressionMiddleware = __decorate([
+    injectable(),
+    Middleware()
+], CompressionMiddleware);
+export { CompressionMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHJlc3Npb24ubWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zb2NrZXQtbWlkZGxld2FyZXMvY29tcHJlc3Npb24ubWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUNwQyxPQUFPLEVBQUMsVUFBVSxFQUFzQixNQUFNLG9CQUFvQixDQUFDO0FBSTVELElBQU0scUJBQXFCLEdBQTNCLE1BQU0scUJBQXFCO0lBRTlCLEdBQUcsQ0FBQyxNQUFXLEVBQUUsSUFBd0I7UUFDckMsSUFBSSxFQUFFLENBQUM7SUFDWCxDQUFDO0NBQ0osQ0FBQTtBQUxZLHFCQUFxQjtJQUZqQyxVQUFVLEVBQUU7SUFDWixVQUFVLEVBQUU7R0FDQSxxQkFBcUIsQ0FLakM7U0FMWSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge01pZGRsZXdhcmUsIE1pZGRsZXdhcmVJbnRlcmZhY2V9IGZyb20gXCJzb2NrZXQtY29udHJvbGxlcnNcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQE1pZGRsZXdhcmUoKVxyXG5leHBvcnQgY2xhc3MgQ29tcHJlc3Npb25NaWRkbGV3YXJlIGltcGxlbWVudHMgTWlkZGxld2FyZUludGVyZmFjZSB7XHJcblxyXG4gICAgdXNlKHNvY2tldDogYW55LCBuZXh0OiAoZXJyPzogYW55KSA9PiBhbnkpIHtcclxuICAgICAgICBuZXh0KCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/static.mjs

@@ -0,0 +1,23 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { static as serveStatic } from "express";
+import { EXPRESS } from "./common-types";
+import { EndpointProvider } from "./services/endpoint-provider";
+import { getDirName } from "./utils";
+export async function setupStatic(rootFolder, container) {
+    const browserFolder = resolve(rootFolder || getDirName(), `public_html`);
+    const app = container.get(EXPRESS);
+    const ep = container.get(EndpointProvider);
+    console.log(browserFolder, existsSync(browserFolder));
+    if (existsSync(browserFolder)) {
+        console.log(`public_html exists. setting up static files serving...`);
+        app.use(serveStatic(browserFolder, {
+            maxAge: "1y"
+        }));
+    }
+    else {
+        console.log(`public_html does not exist on path: "${browserFolder}"`);
+    }
+    await ep.configure(app);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utilities/decorators.mjs

@@ -0,0 +1,52 @@
+import { getStatusCode, OpenAPI } from "routing-controllers-openapi";
+export function IsDocumented(summary = null, paramDescriptions = {}) {
+    return OpenAPI(op => {
+        op.summary = summary || op.summary;
+        op.tags = ["Documented"].concat(op.tags || []);
+        op.parameters?.forEach(p => {
+            if (p.$ref)
+                return;
+            const schema = p;
+            schema.description = paramDescriptions[schema.name]
+                || schema.description
+                || `param.${op.operationId}.${schema.name}`.toLowerCase();
+        });
+        return op;
+    });
+}
+export function JsonResponse(description = "Success", statusCode = null) {
+    return OpenAPI((op, route) => {
+        const status = statusCode ?? getStatusCode(route) + "";
+        op.responses = op.responses || {};
+        op.responses[status] = {
+            description,
+            content: {
+                "application/json": {}
+            }
+        };
+        return op;
+    });
+}
+export function ResponseType(type, options = {}) {
+    return OpenAPI((op, route) => {
+        const contentType = "application/json";
+        const statusCode = options?.statusCode ?? getStatusCode(route) + "";
+        const reference = {
+            $ref: `#/components/schemas/${type.name}`,
+        };
+        const schema = options.isArray
+            ? { items: reference, type: "array" }
+            : reference;
+        op.responses = op.responses || {};
+        op.responses[statusCode] = {
+            description: options.description || "Success",
+            content: {
+                [contentType]: {
+                    schema
+                }
+            }
+        };
+        return op;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utilities/di-container.mjs

@@ -0,0 +1,83 @@
+import { isFactoryProvider } from "tsyringe";
+import { Tree } from "./tree";
+import { isString } from "../utils";
+export class DiContainer {
+    constructor(container, parent = null) {
+        this.container = container;
+        this.parent = parent;
+        container["wrapperContainer"] = this;
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.root = new Tree(this, false, "");
+    }
+    get registeredTokens() {
+        return (this.parent?.registeredTokens || []).concat(this.tokens);
+    }
+    get tree() {
+        return this.root;
+    }
+    beforeResolution(token, callback, options) {
+        this.container.beforeResolution(token, callback, options);
+    }
+    afterResolution(token, callback, options) {
+        this.container.afterResolution(token, callback, options);
+    }
+    clearInstances() {
+        this.container.clearInstances();
+    }
+    createChildContainer() {
+        return new DiContainer(this.container.createChildContainer(), this);
+    }
+    isRegistered(token, recursive) {
+        return this.container.isRegistered(token, recursive);
+    }
+    register(token, provider, options) {
+        if (isFactoryProvider(provider)) {
+            this.container.register(token, {
+                useFactory: dc => {
+                    return provider.useFactory(dc["wrapperContainer"]);
+                }
+            });
+            return this.addToken(token);
+        }
+        this.container.register(token, provider);
+        return this.addToken(token);
+    }
+    registerInstance(token, instance) {
+        this.container.registerInstance(token, instance);
+        return this.addToken(token);
+    }
+    registerSingleton(from, to) {
+        this.container.registerSingleton(from, to);
+        return this.addToken(from);
+    }
+    registerType(from, to) {
+        this.container.registerType(from, to);
+        return this.addToken(from);
+    }
+    reset() {
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.container.reset();
+    }
+    resolve(token) {
+        return this.container.resolve(token);
+    }
+    resolveAll(token) {
+        return this.container.resolveAll(token);
+    }
+    get(token) {
+        return this.container.resolve(token);
+    }
+    addToken(token) {
+        if (this.tokenSet.has(token))
+            return this;
+        this.tokenSet.add(token);
+        this.tokens.push(token);
+        if (isString(token)) {
+            this.root.addPath(token);
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di-container.js","sourceRoot":"","sources":["../../../src/utilities/di-container.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ClassProvider,\r\n    DependencyContainer,\r\n    Frequency,\r\n    InjectionToken,\r\n    isFactoryProvider,\r\n    RegistrationOptions,\r\n    TokenProvider,\r\n    ValueProvider\r\n} from \"tsyringe\";\r\nimport {FactoryProvider, IDependencyContainer, ITree, Type} from \"../common-types\";\r\nimport {Tree} from \"./tree\";\r\nimport {isString} from \"../utils\";\r\n\r\ninterface PreResolutionInterceptorCallback<T = any> {\r\n    (token: InjectionToken<T>, resolutionType: \"Single\" | \"All\"): void;\r\n}\r\n\r\ninterface PostResolutionInterceptorCallback<T = any> {\r\n    (token: InjectionToken<T>, result: T | T[], resolutionType: \"Single\" | \"All\"): void;\r\n}\r\n\r\nexport class DiContainer implements IDependencyContainer {\r\n\r\n    get registeredTokens(): ReadonlyArray<InjectionToken> {\r\n        return (this.parent?.registeredTokens || []).concat(this.tokens);\r\n    }\r\n\r\n    get tree(): ITree {\r\n        return this.root;\r\n    }\r\n\r\n    protected tokens: Array<InjectionToken>;\r\n    protected tokenSet: Set<InjectionToken>;\r\n    protected root: Tree;\r\n\r\n    constructor(protected container: DependencyContainer, readonly parent: IDependencyContainer = null) {\r\n        container[\"wrapperContainer\"] = this;\r\n        this.tokens = [];\r\n        this.tokenSet = new Set<InjectionToken>();\r\n        this.root = new Tree(this, false, \"\");\r\n    }\r\n\r\n    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: { frequency: Frequency }): void {\r\n        this.container.beforeResolution(token, callback, options);\r\n    }\r\n\r\n    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: { frequency: Frequency }): void {\r\n        this.container.afterResolution(token, callback, options);\r\n    }\r\n\r\n    clearInstances(): void {\r\n        this.container.clearInstances();\r\n    }\r\n\r\n    createChildContainer(): IDependencyContainer {\r\n        return new DiContainer(this.container.createChildContainer(), this);\r\n    }\r\n\r\n    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean {\r\n        return this.container.isRegistered(token, recursive);\r\n    }\r\n\r\n    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register(token, provider, options?: RegistrationOptions): IDependencyContainer {\r\n        if (isFactoryProvider(provider)) {\r\n            this.container.register(token, {\r\n                useFactory: dc => {\r\n                    return provider.useFactory(dc[\"wrapperContainer\"]);\r\n                }\r\n            });\r\n            return this.addToken(token);\r\n        }\r\n        this.container.register(token, provider);\r\n        return this.addToken(token);\r\n    }\r\n\r\n    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer {\r\n        this.container.registerInstance(token, instance);\r\n        return this.addToken(token);\r\n    }\r\n\r\n    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\r\n    registerSingleton<T>(token: Type<T>): IDependencyContainer;\r\n    registerSingleton(from, to?): IDependencyContainer {\r\n        this.container.registerSingleton(from, to);\r\n        return this.addToken(from);\r\n    }\r\n\r\n    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer {\r\n        this.container.registerType(from, to);\r\n        return this.addToken(from);\r\n    }\r\n\r\n    reset(): void {\r\n        this.tokens = [];\r\n        this.tokenSet = new Set<InjectionToken>();\r\n        this.container.reset();\r\n    }\r\n\r\n    resolve<T>(token: InjectionToken<T>): T {\r\n        return this.container.resolve(token);\r\n    }\r\n\r\n    resolveAll<T>(token: InjectionToken<T>): T[] {\r\n        return this.container.resolveAll(token);\r\n    }\r\n\r\n    get<T>(token: InjectionToken<T>): T {\r\n        return this.container.resolve(token);\r\n    }\r\n\r\n    protected addToken<T>(token: InjectionToken<T>): this {\r\n        if (this.tokenSet.has(token)) return this;\r\n        this.tokenSet.add(token);\r\n        this.tokens.push(token);\r\n        if (isString(token)) {\r\n            this.root.addPath(token);\r\n        }\r\n        return this;\r\n    }\r\n}\r\n"]}

package/esm2020/utilities/empty-job.mjs

@@ -0,0 +1,13 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+let EmptyJob = class EmptyJob {
+    async process() {
+        return null;
+    }
+};
+EmptyJob = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EmptyJob);
+export { EmptyJob };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktam9iLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxpdGllcy9lbXB0eS1qb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUtoRCxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVE7SUFFakIsS0FBSyxDQUFDLE9BQU87UUFDVCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0NBQ0osQ0FBQTtBQUxZLFFBQVE7SUFGcEIsVUFBVSxFQUFFO0lBQ1osTUFBTSxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUM7R0FDckIsUUFBUSxDQUtwQjtTQUxZLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGUsIExpZmVjeWNsZSwgc2NvcGVkfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtJSm9ifSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcblxyXG5AaW5qZWN0YWJsZSgpXHJcbkBzY29wZWQoTGlmZWN5Y2xlLkNvbnRhaW5lclNjb3BlZClcclxuZXhwb3J0IGNsYXNzIEVtcHR5Sm9iIGltcGxlbWVudHMgSUpvYiB7XHJcblxyXG4gICAgYXN5bmMgcHJvY2VzcygpOiBQcm9taXNlPGFueT4ge1xyXG4gICAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/utilities/lazy-asset-generator.mjs

@@ -0,0 +1,35 @@
+export class LazyAssetGenerator {
+    constructor(assetResolver, progresses, lazyId) {
+        this.assetResolver = assetResolver;
+        this.progresses = progresses;
+        this.lazyId = lazyId;
+    }
+    get assets() {
+        return this.assetResolver.assets;
+    }
+    get lazyAssets() {
+        return this.assetResolver.lazyAssets;
+    }
+    async process(messaging) {
+        const lazyAsset = await this.lazyAssets.read(this.lazyId);
+        let progress = await this.progresses.get(lazyAsset.progressId);
+        if (!progress || progress.canceled)
+            return null;
+        progress.setMessageBridge(messaging);
+        try {
+            const asset = await this.generate(progress, messaging);
+            progress = await progress.load();
+            if (!progress || progress.canceled)
+                return null;
+            await lazyAsset.writeAsset(asset);
+        }
+        catch (e) {
+            await progress.setError(e.message || e);
+            throw e;
+        }
+        if (progress.remaining > 0) {
+            await progress.advance(progress.remaining);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utilities/mongoose.mjs

@@ -0,0 +1,216 @@
+import { model, Types } from "mongoose";
+import { getValue as getMongoValue, setValue as setMongoValue } from "mongoose/lib/utils";
+import { BadRequestError, createParamDecorator, HttpError } from "routing-controllers";
+import { diContainers, isArray, isFunction, isObject, isString, valueToPromise } from "../utils";
+const pluginsKey = "typegoose:plugins";
+/**
+ * A mongoose/typegoose plugin to inject services from the main di container to a schema as virtuals
+ * @param schema
+ * @param services
+ */
+export function injectServices(schema, services) {
+    const serviceMap = {};
+    if (!isObject(services)) {
+        throw new Error(`services object should be defined to inject services to schema!`);
+    }
+    Object.keys(services).forEach(prop => {
+        schema
+            .virtual(prop)
+            .get(() => {
+            const diContainer = diContainers.appContainer;
+            serviceMap[prop] = serviceMap[prop] || (!diContainer ? {} : diContainer.resolve(services[prop]));
+            return serviceMap[prop];
+        });
+    });
+}
+/**
+ * Decorates a property to inject a service with the help of the injectServices mongoose/typegoose plugin
+ * @param token optional InjectionToken to use
+ * @return PropertyDecorator
+ */
+export function service(token) {
+    return (target, propertyKey) => {
+        const propertyType = Reflect.getOwnMetadata("design:type", target, propertyKey);
+        const plugins = Array.from(Reflect.getMetadata(pluginsKey, target.constructor) ?? []);
+        let plugin = plugins.find(t => t.mongoosePlugin === injectServices);
+        if (!plugin) {
+            plugin = { mongoosePlugin: injectServices, options: {} };
+            plugins.push(plugin);
+        }
+        plugin.options = Object.assign(plugin.options || {}, { [propertyKey]: token ?? propertyType });
+        Reflect.defineMetadata(pluginsKey, plugins, target.constructor);
+    };
+}
+/**
+ * Paginate using a typegoose model using a simple where query and pagination params
+ * @param model Typegoose model
+ * @param where Simple query to filter the results
+ * @param params Pagination params
+ */
+export function paginate(model, where, params) {
+    return model.countDocuments(where).then(count => {
+        let query = model.find(where);
+        if (isString(params.sort)) {
+            query = query.sort(params.sort);
+        }
+        if (isArray(params.populate)) {
+            params.populate.forEach(field => {
+                query = query.populate(field);
+            });
+        }
+        return (params.limit > 0 ? query.skip(params.page * params.limit).limit(params.limit) : query).then(items => {
+            const meta = { total: count };
+            return { count, items, meta };
+        });
+    });
+}
+export function lookupStages(from, localField, as = null, foreignField = "_id", shouldUnwind = true) {
+    as = as || localField.replace("Id", "");
+    const stages = [
+        {
+            $lookup: {
+                from,
+                localField,
+                foreignField,
+                as
+            }
+        },
+        {
+            $unwind: {
+                path: `$${as}`,
+                preserveNullAndEmptyArrays: true
+            }
+        }
+    ];
+    if (!shouldUnwind) {
+        stages.splice(1, 1);
+    }
+    return stages;
+}
+export function letsLookupStage(from, pipeline, as = null, letFields = null) {
+    as = as || from;
+    letFields = letFields || { id: "$_id" };
+    return {
+        $lookup: {
+            from,
+            let: letFields,
+            pipeline,
+            as
+        }
+    };
+}
+export function matchStage(match) {
+    return { $match: match };
+}
+export function matchField(field, filter, when) {
+    return { field, filter, when };
+}
+export function matchFieldStages(...fields) {
+    const match = {};
+    fields.forEach(field => {
+        if (field.when) {
+            match[field.field] = field.filter;
+        }
+    });
+    return Object.keys(match).length > 0 ? [matchStage(match)] : [];
+}
+export function projectStage(fields) {
+    return { $project: fields };
+}
+export function unwindStage(fieldOrOpts) {
+    return { $unwind: fieldOrOpts };
+}
+export function hydratePopulated(modelType, json) {
+    let object = modelType.hydrate(json);
+    for (const [path, obj] of Object.entries(modelType.schema.obj)) {
+        let { ref, type } = obj;
+        if (Array.isArray(type) && type.length > 0) {
+            ref = type[0].ref;
+        }
+        if (!ref)
+            continue;
+        const value = getMongoValue(path, json);
+        const hydrateVal = val => {
+            if (val == null || val instanceof Types.ObjectId)
+                return val;
+            return hydratePopulated(model(ref), val);
+        };
+        if (Array.isArray(value)) {
+            setMongoValue(path, value.map(hydrateVal), object);
+            continue;
+        }
+        setMongoValue(path, hydrateVal(value), object);
+    }
+    return object;
+}
+export async function paginateAggregations(model, aggregations, params, metaProjection = {}) {
+    const sortField = !isString(params.sort) || !params.sort ? null : (params.sort.startsWith("-") ? params.sort.substr(1) : params.sort);
+    const sortAggregation = !sortField ? [] : [{
+            $sort: { [sortField]: sortField == params.sort ? 1 : -1 }
+        }];
+    const result = await model.aggregate([
+        ...aggregations,
+        ...sortAggregation,
+        {
+            $group: {
+                _id: "results",
+                result: { $push: "$$CURRENT" }
+            }
+        },
+        {
+            $project: {
+                _id: 0,
+                items: params.limit > 0 ? { $slice: ["$result", params.page * params.limit, params.limit] } : "$result",
+                count: { $size: "$result" },
+                meta: {
+                    total: { $size: "$result" },
+                    ...metaProjection
+                }
+            }
+        }
+    ]);
+    const pagination = result[0];
+    if (!pagination) {
+        return { items: [], count: 0, meta: { total: 0 } };
+    }
+    pagination.items = pagination.items.map(i => hydratePopulated(model, i));
+    return pagination;
+}
+export function ResolveEntity(model, extraCheck) {
+    const modelName = model.modelName;
+    const paramName = modelName.toLowerCase();
+    return createParamDecorator({
+        required: false,
+        value: async (action) => {
+            const req = action.request;
+            const token = req.header(`x-${paramName}-token`);
+            const id = req.params[`${paramName}Id`];
+            if (!id && !token) {
+                throw new BadRequestError(`${modelName} id or token should be defined!`);
+            }
+            const query = !token
+                ? model.findById(id)
+                : model.findOne({ token });
+            let doc = null;
+            if (isFunction(extraCheck)) {
+                try {
+                    doc = await valueToPromise(extraCheck(query, action));
+                }
+                catch (e) {
+                    throw new BadRequestError(`${modelName} check error: ${e.message || e}`);
+                }
+            }
+            else {
+                doc = await query;
+            }
+            if (!doc) {
+                throw new HttpError(404, !token
+                    ? `${modelName} could not be found with id: ${id}`
+                    : `${modelName} could not be found with token: ${token}`);
+            }
+            action.request[paramName] = doc;
+            return doc;
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongoose.js","sourceRoot":"","sources":["../../../src/utilities/mongoose.ts"],"names":[],"mappings":"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","sourcesContent":["import {Document, FilterQuery, model, Model, PipelineStage, Query, Schema, Types} from \"mongoose\";\r\nimport {getValue as getMongoValue, setValue as setMongoValue} from \"mongoose/lib/utils\";\r\nimport {DocumentType, ReturnModelType} from \"@typegoose/typegoose\";\r\nimport {Action, BadRequestError, createParamDecorator, HttpError} from \"routing-controllers\";\r\nimport {InjectionToken} from \"tsyringe\";\r\nimport {\r\n    IMatchField,\r\n    InferGeneric,\r\n    IPaginationBase,\r\n    IPaginationParams,\r\n    IProjectOptions,\r\n    IRequest,\r\n    IUnwindOptions,\r\n    Type\r\n} from \"../common-types\";\r\nimport {diContainers, isArray, isFunction, isObject, isString, valueToPromise} from \"../utils\";\r\n\r\nconst pluginsKey = \"typegoose:plugins\";\r\n\r\ninterface IPluginWithOptions {\r\n    mongoosePlugin: Function;\r\n    options: any;\r\n}\r\n\r\n/**\r\n * A mongoose/typegoose plugin to inject services from the main di container to a schema as virtuals\r\n * @param schema\r\n * @param services\r\n */\r\nexport function injectServices(schema: Schema<any>, services?: { [prop: string]: InjectionToken<any> }): void {\r\n    const serviceMap: { [prop: string]: any } = {};\r\n    if (!isObject(services)) {\r\n        throw new Error(`services object should be defined to inject services to schema!`)\r\n    }\r\n    Object.keys(services).forEach(prop => {\r\n        schema\r\n            .virtual(prop)\r\n            .get(() => {\r\n                const diContainer = diContainers.appContainer;\r\n                serviceMap[prop] = serviceMap[prop] || (!diContainer ? {} : diContainer.resolve(services[prop]));\r\n                return serviceMap[prop];\r\n            });\r\n    });\r\n}\r\n\r\n/**\r\n * Decorates a property to inject a service with the help of the injectServices mongoose/typegoose plugin\r\n * @param token optional InjectionToken to use\r\n * @return PropertyDecorator\r\n */\r\nexport function service(token?: InjectionToken<any>): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        const propertyType = Reflect.getOwnMetadata(\"design:type\", target, propertyKey);\r\n        const plugins = Array.from(Reflect.getMetadata(pluginsKey, target.constructor) ?? []) as IPluginWithOptions[];\r\n        let plugin = plugins.find(t => t.mongoosePlugin === injectServices);\r\n        if (!plugin) {\r\n            plugin = { mongoosePlugin: injectServices, options: {} };\r\n            plugins.push(plugin);\r\n        }\r\n        plugin.options = Object.assign(plugin.options || {}, {[propertyKey]: token ?? propertyType});\r\n        Reflect.defineMetadata(pluginsKey, plugins, target.constructor);\r\n    };\r\n}\r\n\r\n/**\r\n * Paginate using a typegoose model using a simple where query and pagination params\r\n * @param model Typegoose model\r\n * @param where Simple query to filter the results\r\n * @param params Pagination params\r\n */\r\nexport function paginate<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, where: FilterQuery<DocumentType<U>>, params: IPaginationParams): Promise<IPaginationBase<DocumentType<U>>> {\r\n    return model.countDocuments(where).then(count => {\r\n        let query: Query<any, any> = model.find(where);\r\n        if (isString(params.sort)) {\r\n            query = query.sort(params.sort);\r\n        }\r\n        if (isArray(params.populate)) {\r\n            params.populate.forEach(field => {\r\n                query = query.populate(field);\r\n            });\r\n        }\r\n        return (params.limit > 0 ? query.skip(params.page * params.limit).limit(params.limit) : query).then(items => {\r\n            const meta = {total: count};\r\n            return {count, items, meta};\r\n        });\r\n    });\r\n}\r\n\r\nexport function lookupStages(from: string, localField: string, as: string = null, foreignField: string = \"_id\", shouldUnwind: boolean = true): [PipelineStage.Lookup, PipelineStage.Unwind] {\r\n    as = as || localField.replace(\"Id\", \"\");\r\n    const stages: [PipelineStage.Lookup, PipelineStage.Unwind] = [\r\n        {\r\n            $lookup: {\r\n                from,\r\n                localField,\r\n                foreignField,\r\n                as\r\n            }\r\n        },\r\n        {\r\n            $unwind: {\r\n                path: `$${as}`,\r\n                preserveNullAndEmptyArrays: true\r\n            }\r\n        }\r\n    ];\r\n    if (!shouldUnwind) {\r\n        stages.splice(1, 1);\r\n    }\r\n    return stages;\r\n}\r\n\r\nexport function letsLookupStage(from: string, pipeline: Exclude<PipelineStage, PipelineStage.Merge | PipelineStage.Out | PipelineStage.Search>[], as: string = null, letFields: any = null): PipelineStage.Lookup {\r\n    as = as || from;\r\n    letFields = letFields || {id: \"$_id\"};\r\n    return {\r\n        $lookup: {\r\n            from,\r\n            let: letFields,\r\n            pipeline,\r\n            as\r\n        }\r\n    };\r\n}\r\n\r\nexport function matchStage(match: FilterQuery<any>): PipelineStage.Match {\r\n    return {$match: match};\r\n}\r\n\r\nexport function matchField(field: string, filter: any, when: boolean): IMatchField {\r\n    return {field, filter, when};\r\n}\r\n\r\nexport function matchFieldStages(...fields: IMatchField[]): ReadonlyArray<PipelineStage.Match> {\r\n    const match = {};\r\n    fields.forEach(field => {\r\n        if (field.when) {\r\n            match[field.field] = field.filter;\r\n        }\r\n    });\r\n    return Object.keys(match).length > 0 ? [matchStage(match)] : [];\r\n}\r\n\r\nexport function projectStage(fields: IProjectOptions): PipelineStage.Project {\r\n    return {$project: fields};\r\n}\r\n\r\nexport function unwindStage(fieldOrOpts: string | IUnwindOptions): PipelineStage.Unwind {\r\n    return {$unwind: fieldOrOpts};\r\n}\r\n\r\nexport function hydratePopulated<T extends Document>(modelType: Model<T>, json: any): T {\r\n    let object = modelType.hydrate(json);\r\n\r\n    for (const [path, obj] of Object.entries(modelType.schema.obj)) {\r\n        let {ref, type} = obj as any;\r\n        if (Array.isArray(type) && type.length > 0) {\r\n            ref = type[0].ref;\r\n        }\r\n        if (!ref) continue;\r\n        const value = getMongoValue(path, json);\r\n        const hydrateVal = val => {\r\n            if (val == null || val instanceof Types.ObjectId) return val;\r\n            return hydratePopulated(model(ref) as any, val);\r\n        };\r\n        if (Array.isArray(value)) {\r\n            setMongoValue(path, value.map(hydrateVal), object);\r\n            continue;\r\n        }\r\n        setMongoValue(path, hydrateVal(value), object);\r\n    }\r\n\r\n    return object;\r\n\r\n}\r\n\r\nexport async function paginateAggregations<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, aggregations: PipelineStage[], params: IPaginationParams, metaProjection: any = {}): Promise<IPaginationBase<DocumentType<U>>> {\r\n    const sortField = !isString(params.sort) || !params.sort ? null : (params.sort.startsWith(\"-\") ? params.sort.substr(1) : params.sort);\r\n    const sortAggregation: PipelineStage.Sort[] = !sortField ? [] : [{\r\n        $sort: {[sortField]: sortField == params.sort ? 1 : -1}\r\n    }];\r\n    const result = await model.aggregate([\r\n        ...aggregations,\r\n        ...sortAggregation,\r\n        {\r\n            $group: {\r\n                _id: \"results\",\r\n                result: {$push: \"$$CURRENT\"}\r\n            }\r\n        },\r\n        {\r\n            $project: {\r\n                _id: 0,\r\n                items: params.limit > 0 ? {$slice: [\"$result\", params.page * params.limit, params.limit]} : \"$result\",\r\n                count: {$size: \"$result\"},\r\n                meta: {\r\n                    total: {$size: \"$result\"},\r\n                    ...metaProjection\r\n                }\r\n            }\r\n        }\r\n    ]);\r\n    const pagination = result[0] as IPaginationBase<DocumentType<U>>;\r\n    if (!pagination) {\r\n        return {items: [], count: 0, meta: {total: 0}};\r\n    }\r\n    pagination.items = pagination.items.map(i => hydratePopulated(model, i) as any);\r\n    return pagination;\r\n}\r\n\r\nexport function ResolveEntity<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, extraCheck?: (query: Query<DocumentType<U>, any>, action: Action) => Promise<DocumentType<U>>): ParameterDecorator {\r\n    const modelName = model.modelName;\r\n    const paramName = modelName.toLowerCase();\r\n    return createParamDecorator({\r\n        required: false,\r\n        value: async action => {\r\n            const req = action.request as IRequest;\r\n            const token = req.header(`x-${paramName}-token`);\r\n            const id = req.params[`${paramName}Id`] as string;\r\n            if (!id && !token) {\r\n                throw new BadRequestError(`${modelName} id or token should be defined!`);\r\n            }\r\n            const query = !token\r\n                ? model.findById(id)\r\n                : model.findOne({token} as any);\r\n            let doc: Document = null;\r\n            if (isFunction(extraCheck)) {\r\n                try {\r\n                    doc = await valueToPromise(extraCheck(query, action));\r\n                } catch (e) {\r\n                    throw new BadRequestError(`${modelName} check error: ${e.message || e}`);\r\n                }\r\n            } else {\r\n                doc = await query;\r\n            }\r\n            if (!doc) {\r\n                throw new HttpError(404, !token\r\n                    ? `${modelName} could not be found with id: ${id}`\r\n                    : `${modelName} could not be found with token: ${token}`);\r\n            }\r\n            action.request[paramName] = doc;\r\n            return doc;\r\n        }\r\n    });\r\n}\r\n"]}