@stemy/backend 5.2.1 → 6.0.0

package/esm2022/utilities/mongoose.mjs

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

package/esm2022/utilities/tree.mjs

@@ -0,0 +1,119 @@
+import { isString } from "../utils";
+export class Tree {
+    container;
+    exists;
+    path;
+    map;
+    get parentTree() {
+        return this.container.parent.tree;
+    }
+    constructor(container, exists, path) {
+        this.container = container;
+        this.exists = exists;
+        this.path = path;
+        this.map = new Map();
+    }
+    resolveService() {
+        return !this.exists ? null : this.container.resolve(this.path);
+    }
+    resolveLeaves() {
+        let map;
+        try {
+            const parentTree = this.parentTree.resolvePath(this.path);
+            map = parentTree.resolveLeaves();
+        }
+        catch (e) {
+            map = new Map();
+        }
+        const visitor = (treeMap, path) => {
+            treeMap.forEach((tree, key) => {
+                const subKey = !path ? key : `${path}.${key}`;
+                if (tree.map.size == 0) {
+                    map.set(subKey, tree);
+                    return;
+                }
+                visitor(tree.map, subKey);
+            });
+        };
+        visitor(this.map, "");
+        return map;
+    }
+    resolveServices() {
+        const map = new Map();
+        this.resolveLeaves().forEach((leaf, key) => {
+            map.set(key, leaf.resolveService());
+        });
+        return map;
+    }
+    resolveAncestor(path) {
+        if (!isString(path) || path.length == 0) {
+            return this;
+        }
+        let parentTree;
+        try {
+            parentTree = this.parentTree.resolvePath(this.path);
+            parentTree = parentTree.resolveAncestor(path);
+        }
+        catch (e) {
+            parentTree = new Tree(this.container, false, "");
+        }
+        const pathParts = path.split(".");
+        let tree = this;
+        let previousTree = this;
+        for (let part of pathParts) {
+            tree = tree.map.get(part);
+            if (!tree) {
+                if (previousTree == this) {
+                    if (parentTree.path.length > 0) {
+                        return parentTree;
+                    }
+                    throw new Error(`Ancestor '${path}' not found in current tree: '${this.path}'`);
+                }
+                return previousTree;
+            }
+            previousTree = tree;
+        }
+        return parentTree.path.length > previousTree.path.length
+            ? parentTree : previousTree;
+    }
+    resolvePath(path, throwError = true) {
+        const absolutePath = !this.path ? path : `${this.path}.${path}`;
+        let tree = new Tree(this.container, false, absolutePath);
+        try {
+            tree = this.resolveAncestor(path);
+        }
+        catch (e) {
+            if (throwError) {
+                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);
+            }
+            return tree;
+        }
+        if (tree.path !== absolutePath) {
+            if (throwError) {
+                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);
+            }
+            return tree;
+        }
+        return tree;
+    }
+    addPath(path) {
+        if (!isString(path) || path.length == 0) {
+            return this;
+        }
+        const pathParts = path.split(".");
+        const maxIx = pathParts.length - 1;
+        let tree = this;
+        path = this.path;
+        for (let ix = 0; ix <= maxIx; ix++) {
+            const part = pathParts[ix];
+            if (!tree.map.has(part)) {
+                tree.map.set(part, new Tree(this.container, false, !path ? part : `${path}.${part}`));
+            }
+            tree = tree.map.get(part);
+            tree.exists = tree.exists || ix == maxIx;
+            path = tree.path;
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../src/utilities/tree.ts"],"names":[],"mappings":"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","sourcesContent":["import {IDependencyContainer, ITree} from \"../common-types\";\r\nimport {isString} from \"../utils\";\r\n\r\nexport class Tree implements ITree {\r\n\r\n    protected map: Map<string, Tree>;\r\n\r\n    protected get parentTree(): ITree {\r\n        return this.container.parent.tree;\r\n    }\r\n\r\n    constructor(protected container: IDependencyContainer, protected exists: boolean, readonly path: string) {\r\n        this.map = new Map<string, Tree>();\r\n    }\r\n\r\n    resolveService(): any {\r\n        return !this.exists ? null : this.container.resolve(this.path);\r\n    }\r\n\r\n    resolveLeaves(): Map<string, ITree> {\r\n        let map: Map<string, ITree>;\r\n        try {\r\n            const parentTree = this.parentTree.resolvePath(this.path);\r\n            map = parentTree.resolveLeaves();\r\n        } catch (e) {\r\n            map = new Map<string, ITree>();\r\n        }\r\n        const visitor = (treeMap: Map<string, Tree>, path: string) => {\r\n            treeMap.forEach((tree, key) => {\r\n                const subKey = !path ? key : `${path}.${key}`;\r\n                if (tree.map.size == 0) {\r\n                    map.set(subKey, tree);\r\n                    return;\r\n                }\r\n                visitor(tree.map, subKey);\r\n            });\r\n        };\r\n        visitor(this.map, \"\");\r\n        return map;\r\n    }\r\n\r\n    resolveServices(): Map<string, any> {\r\n        const map = new Map<string, any>();\r\n        this.resolveLeaves().forEach((leaf, key) => {\r\n            map.set(key, leaf.resolveService());\r\n        });\r\n        return map;\r\n    }\r\n\r\n    resolveAncestor(path: string): ITree {\r\n        if (!isString(path) || path.length == 0) {\r\n            return this;\r\n        }\r\n        let parentTree: ITree;\r\n        try {\r\n            parentTree = this.parentTree.resolvePath(this.path);\r\n            parentTree = parentTree.resolveAncestor(path);\r\n        } catch (e) {\r\n            parentTree = new Tree(this.container, false, \"\");\r\n        }\r\n        const pathParts = path.split(\".\");\r\n        let tree: Tree = this;\r\n        let previousTree: Tree = this;\r\n        for (let part of pathParts) {\r\n            tree = tree.map.get(part);\r\n            if (!tree) {\r\n                if (previousTree == this) {\r\n                    if (parentTree.path.length > 0) {\r\n                        return parentTree;\r\n                    }\r\n                    throw new Error(`Ancestor '${path}' not found in current tree: '${this.path}'`);\r\n                }\r\n                return previousTree;\r\n            }\r\n            previousTree = tree;\r\n        }\r\n        return parentTree.path.length > previousTree.path.length\r\n            ? parentTree : previousTree;\r\n    }\r\n\r\n    resolvePath(path: string, throwError: boolean = true): ITree {\r\n        const absolutePath = !this.path ? path : `${this.path}.${path}`;\r\n        let tree: ITree = new Tree(this.container, false, absolutePath);\r\n        try {\r\n            tree = this.resolveAncestor(path);\r\n        } catch (e) {\r\n            if (throwError) {\r\n                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);\r\n            }\r\n            return tree;\r\n        }\r\n        if (tree.path !== absolutePath) {\r\n            if (throwError) {\r\n                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);\r\n            }\r\n            return tree;\r\n        }\r\n        return tree;\r\n    }\r\n\r\n    addPath(path: string): this {\r\n        if (!isString(path) || path.length == 0) {\r\n            return this;\r\n        }\r\n        const pathParts = path.split(\".\");\r\n        const maxIx = pathParts.length - 1;\r\n        let tree: Tree = this;\r\n        path = this.path;\r\n        for (let ix = 0; ix <= maxIx; ix++) {\r\n            const part = pathParts[ix];\r\n            if (!tree.map.has(part)) {\r\n                tree.map.set(part, new Tree(this.container, false, !path ? part : `${path}.${part}`))\r\n            }\r\n            tree = tree.map.get(part);\r\n            tree.exists = tree.exists || ix == maxIx;\r\n            path = tree.path;\r\n        }\r\n        return this;\r\n    }\r\n}\r\n"]}