@nextage/nx-frame-be 1.0.1

package/build/common/base/folded.model.d.ts

@@ -0,0 +1,41 @@
+import { NxContext } from '../interfaces';
+import { BaseModel } from './base.model';
+import { FilterParams, FoldedModelAttrs } from './base.interfaces';
+import { FoldedMongoDoc, BaseMongoModel } from './base.interfaces';
+export declare class FoldedModel<TAttrs extends FoldedModelAttrs, TDoc extends FoldedMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>> extends BaseModel<TAttrs, TDoc, TMongoModel> {
+    childrenAttrs: string[];
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCreate(item: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} item
+     */
+    beforeUpdate(item: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    updateFilters(params: FilterParams, context: NxContext): Promise<FilterParams | null>;
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    foldedList(params: FilterParams, context: NxContext): Promise<TDoc[]>;
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCopy(attrs: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} item
+     * @param {*} param1
+     * @param {*} context
+     */
+    share(items: TDoc[], { users, organizations }: FoldedModelAttrs, context: NxContext): Promise<boolean>;
+}

package/build/common/base/folded.model.js

@@ -0,0 +1,215 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoldedModel = void 0;
+const errors_1 = require("../errors");
+const base_model_1 = require("./base.model");
+const mongo_utils_1 = require("./mongo-utils");
+class FoldedModel extends base_model_1.BaseModel {
+    constructor() {
+        super(...arguments);
+        this.childrenAttrs = [];
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCreate(item, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = context.user) === null || _a === void 0 ? void 0 : _a.id))
+                throw new errors_1.ForbiddenError();
+            item.createdAt = new Date();
+            item.ownerId = context.user.id;
+            item.folder = !!item.folder;
+            if (item.folderId) {
+                const folder = yield this.findOneNative({ _id: (0, mongo_utils_1.toObjectId)(item.folderId) });
+                if ((folder === null || folder === void 0 ? void 0 : folder.ownerId.toString()) !== context.user.id.toString())
+                    delete item.folderId;
+                return item;
+            }
+            return Promise.resolve(item);
+        });
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeUpdate(item, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            item.updatedAt = new Date();
+            delete item.ownerId;
+            return Promise.resolve(item);
+        });
+    }
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    updateFilters(params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = context.user) === null || _a === void 0 ? void 0 : _a.id))
+                return Promise.resolve(null);
+            if (!params)
+                params = {};
+            if (params.folderId)
+                params.folderId = (0, mongo_utils_1.toObjectId)(params.folderId);
+            this.manageFilterArrayParams(params);
+            // if admin no restrictions
+            // if (context.user.isAdmin()) {
+            //   return Promise.resolve(params);
+            // }
+            let matchFilter = {};
+            if (params._id)
+                matchFilter._id = params._id;
+            // params.locked = { $exists: false };
+            params.$or = [
+                // user is owner
+                { ownerId: context.user.id },
+                // element is public
+                { public: true },
+                // element has no owner, good if organization not set or matching,
+                // users share not set or matching
+                {
+                    $and: [
+                        { ownerId: { $exists: false } },
+                        {
+                            $and: [
+                                {
+                                    $or: [
+                                        { users: { $exists: false } },
+                                        { users: { $eq: null } },
+                                        { users: { $eq: [] } },
+                                        { 'users._id': context.user.id.toString() }
+                                    ]
+                                },
+                                {
+                                    $or: [
+                                        { organizations: { $exists: false } },
+                                        { organizations: { $eq: null } },
+                                        { organizations: { $eq: [] } }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                },
+                // user is not the owner but query is shared with him or belonging organization
+                {
+                    $and: [
+                        { ownerId: { $ne: context.user.id } },
+                        { $or: [{ 'users._id': context.user.id.toString() }] }
+                    ]
+                }
+            ];
+            // if no admin check for user organizations
+            return Promise.resolve(params);
+        });
+    }
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    foldedList(params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const filter = yield this.updateFilters(params, context);
+                if (!filter)
+                    return [];
+                let childrenAttrs = { _id: '$_id', name: '$name', title: '$title', locked: '$locked', folder: '$folder', folderId: '$folderId', users: '$users', organizations: '$organizations', ownerId: '$ownerId' };
+                if (this.childrenAttrs)
+                    this.childrenAttrs.forEach(ca => childrenAttrs[ca] = `$${ca}`);
+                let pipeline = [
+                    { $match: filter },
+                    { $sort: { folder: -1, name: 1, title: 1 } },
+                    {
+                        $group: {
+                            _id: '$folderId',
+                            children: { $push: childrenAttrs }
+                        }
+                    }
+                ];
+                const foldedItems = yield this.mgModel.aggregate(pipeline);
+                if (!foldedItems)
+                    return [];
+                let root = foldedItems.find(g => g._id === null);
+                // if user has no items in root (only shared from other folders)
+                if (!root) {
+                    root = { _id: null, children: [] };
+                    foldedItems.push(root);
+                }
+                return foldedItems.filter(folder => {
+                    if (!folder._id)
+                        return true;
+                    // check if element is a child of other folders, if not put its children inside root folder
+                    let hasParent = !!foldedItems.filter(fi => fi !== folder && !!fi.children.find((child) => child._id.toString() === folder._id.toString())).length;
+                    if (!hasParent) {
+                        root.children = root.children.concat(folder.children);
+                        return false;
+                    }
+                    return true;
+                });
+            }
+            catch (e) {
+                return [];
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCopy(attrs, context) {
+        var _a;
+        attrs.ownerId = (_a = context.user) === null || _a === void 0 ? void 0 : _a.id;
+        delete attrs.users;
+        delete attrs.groups;
+        delete attrs.organizations;
+        return super.beforeCopy(attrs, context);
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} param1
+     * @param {*} context
+     */
+    share(items_1, _a, context_1) {
+        return __awaiter(this, arguments, void 0, function* (items, { users, organizations }, context) {
+            let update = {};
+            if (Array.isArray(users))
+                update.users = users;
+            if (Array.isArray(organizations))
+                update.organizations = organizations;
+            if (!Object.keys(update).length)
+                return Promise.resolve(false);
+            // if (!item.folder)
+            //   return this.updateNative({ _id: toObjectId(item._id) }, { $set: update });
+            let pipeline = [
+                { $match: { _id: { $in: items.map(i => (0, mongo_utils_1.toObjectId)(i.id)) } } },
+                { $graphLookup: { from: this.collectionName, startWith: '$_id', connectFromField: '_id', connectToField: 'folderId', as: 'children' } }
+            ];
+            const foundData = yield this.aggregate(pipeline, {}, context);
+            if (!(foundData === null || foundData === void 0 ? void 0 : foundData[0]))
+                return false;
+            const ids = [];
+            foundData.forEach(fi => {
+                ids.push(fi.id);
+                fi.children.forEach((ch) => ids.push(ch._id));
+            });
+            const res = yield this.bulkUpdate(ids, update, context);
+            return !!res;
+        });
+    }
+}
+exports.FoldedModel = FoldedModel;

package/build/common/base/mongo-utils.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from 'mongoose';
+import { BaseDBItem } from '../types';
+import { ModelDef } from './mongo.types';
+import { BaseMongoDoc, BaseMongoModel } from './base.interfaces';
+import { BaseModel } from './base.model';
+export declare const codedEntitySchema: {
+    code: {
+        type: StringConstructor;
+        required: boolean;
+        unique: boolean;
+    };
+    name: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    description: StringConstructor;
+    startDate: {
+        type: DateConstructor;
+    };
+    endDate: {
+        type: DateConstructor;
+    };
+    data: typeof mongoose.Schema.Types.Mixed;
+};
+export declare const foldedSchema: {
+    name: StringConstructor;
+    description: StringConstructor;
+    locked: BooleanConstructor;
+    public: BooleanConstructor;
+    folder: BooleanConstructor;
+    folderId: typeof mongoose.Schema.Types.ObjectId;
+    ownerId: typeof mongoose.Schema.Types.ObjectId;
+    users: (typeof mongoose.Schema.Types.Mixed)[];
+    organizations: (typeof mongoose.Schema.Types.Mixed)[];
+    createdAt: DateConstructor;
+    updatedAt: DateConstructor;
+};
+/**
+ *
+ * @param model
+ */
+export declare function loadModel(model: BaseModel<any, any, any>): void;
+/**
+ * name        - name of the Model to be created
+ * classDef    - (optional) class to be used to create model
+ * modelName   - name of the Mongoose Model to be created
+ * modelParams - (optional) default model APP parameters (eg. default data sorting)
+ * schema      - (optional) data schema used by mongoose
+ *               (if not present it use the default schema "codedEntitySchema")
+ * collection  - (optional) name of the collection for mongoose model
+ * load        - (optional) if true add model in models array
+ * mergeSchema - (optional) if true "schema" object will be merged with default schema "codedEntitySchema"
+ *               (property of "codedEntitySchema" with same key of "schema" will be overridden)
+ * @param { name, modelName, schema, collection, mergeSchema } param
+ * @param load
+ */
+export declare function createModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>, TNxModel>({ name, classDef, modelName, modelParams, collection, schema, mergeSchema }: ModelDef<TDoc, TMongoModel, TNxModel>, load: boolean, logger?: any): TNxModel;
+/**
+ *
+ * @param {*} modelName
+ * @param {*} schema
+ * @param {*} collection
+ */
+export declare function loadMongoModel<TAttrs extends BaseDBItem, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>>(modelName: string, schema: any, collection: string, version?: boolean): TMongoModel;
+/**
+ * transform string or string array to ObjectId or ObjectId array
+ *
+ * @param {*} value value or values to be converted
+ * @param {*} generate if true generate new id if value is not valid
+ */
+export declare function toObjectId(value: string | mongoose.Types.ObjectId, generate?: boolean): mongoose.Types.ObjectId;
+/**
+ *
+ * @param values
+ * @param generate
+ * @returns
+ */
+export declare function toObjectIds(values: any[], generate?: boolean): mongoose.Types.ObjectId[];
+/**
+ * return a new ObjectId value
+ *
+ * @param {*} value
+ */
+export declare function genObjectId(): mongoose.Types.ObjectId;
+/**
+ * Check if string or string array is a valid ObjectId
+ *
+ * @param {*} value
+ */
+export declare function isValidObjectId(value: any): boolean | undefined;
+/**
+ *
+ * @param {*} id1
+ * @param {*} id2
+ * @returns
+ */
+export declare function isSameId(id1: mongoose.Types.ObjectId | string, id2: mongoose.Types.ObjectId | string): boolean;

package/build/common/base/mongo-utils.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameId = exports.isValidObjectId = exports.genObjectId = exports.toObjectIds = exports.toObjectId = exports.loadMongoModel = exports.createModel = exports.loadModel = exports.foldedSchema = exports.codedEntitySchema = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_update_if_current_1 = require("mongoose-update-if-current");
+const constants_1 = require("../constants");
+const base_model_1 = require("./base.model");
+exports.codedEntitySchema = {
+    code: { type: String, required: true, unique: true },
+    name: { type: String, required: true },
+    description: String,
+    startDate: { type: Date },
+    endDate: { type: Date },
+    data: mongoose_1.default.SchemaTypes.Mixed
+};
+exports.foldedSchema = {
+    name: String,
+    description: String,
+    locked: Boolean,
+    public: Boolean,
+    folder: Boolean,
+    folderId: mongoose_1.default.SchemaTypes.ObjectId,
+    ownerId: mongoose_1.default.SchemaTypes.ObjectId,
+    users: [mongoose_1.default.SchemaTypes.Mixed],
+    organizations: [mongoose_1.default.SchemaTypes.Mixed],
+    createdAt: Date,
+    updatedAt: Date
+};
+/**
+ *
+ * @param model
+ */
+function loadModel(model) {
+    if (model.collectionName)
+        constants_1.APP.mongoModels[model.collectionName] = model;
+}
+exports.loadModel = loadModel;
+/**
+ * name        - name of the Model to be created
+ * classDef    - (optional) class to be used to create model
+ * modelName   - name of the Mongoose Model to be created
+ * modelParams - (optional) default model APP parameters (eg. default data sorting)
+ * schema      - (optional) data schema used by mongoose
+ *               (if not present it use the default schema "codedEntitySchema")
+ * collection  - (optional) name of the collection for mongoose model
+ * load        - (optional) if true add model in models array
+ * mergeSchema - (optional) if true "schema" object will be merged with default schema "codedEntitySchema"
+ *               (property of "codedEntitySchema" with same key of "schema" will be overridden)
+ * @param { name, modelName, schema, collection, mergeSchema } param
+ * @param load
+ */
+function createModel({ name, classDef, modelName, modelParams, collection, schema, mergeSchema }, load, logger = constants_1.APP.logger) {
+    let entitySchema;
+    if (!name)
+        throw new Error('Missing param to create model');
+    if (!modelName)
+        modelName = name;
+    if (!schema)
+        entitySchema = exports.codedEntitySchema;
+    else
+        entitySchema = mergeSchema ? mergeDBSchema(exports.codedEntitySchema, schema) : schema;
+    const mgModel = loadMongoModel(modelName, entitySchema, collection);
+    const model = classDef ? new classDef({ name, model: mgModel, params: modelParams, logger }) : new base_model_1.BaseModel({ name, model: mgModel, params: modelParams, logger });
+    if (load)
+        loadModel(model);
+    logger.info(`created model ${modelName} (load: ${!!load})`);
+    //console.log(`created model ${modelName} (load: ${!!load})`);
+    return model;
+}
+exports.createModel = createModel;
+/**
+ *
+ * @param {*} modelName
+ * @param {*} schema
+ * @param {*} collection
+ */
+function loadMongoModel(modelName, schema, collection, version = true) {
+    const mgSchema = new mongoose_1.default.Schema(schema, {
+        minimize: false,
+        toJSON: {
+            // convert _id to a standard id attribute
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+            }
+        }
+    });
+    // change documents' version key from __v to version
+    mgSchema.set('versionKey', 'version');
+    // apply version increment to every document update
+    if (version)
+        mgSchema.plugin(mongoose_update_if_current_1.updateIfCurrentPlugin);
+    mgSchema.statics.build = (attrs) => {
+        const item = { _id: attrs.id };
+        delete attrs.id;
+        Object.assign(item, attrs);
+        return new MGModel(item);
+    };
+    mgSchema.statics.findByEvent = (event) => {
+        return MGModel.findOne({
+            _id: toObjectId(event.id),
+            version: event.version - 1
+        });
+    };
+    // mgSchema.pre('save', async function(done) {
+    //   console.log('CIAONE');
+    //   done();
+    // });
+    const MGModel = (constants_1.APP.mongoose || mongoose_1.default).model(modelName, mgSchema, collection);
+    return MGModel;
+}
+exports.loadMongoModel = loadMongoModel;
+/**
+ *
+ * @param {*} baseSchema
+ * @param {*} schemaToMerge
+ */
+function mergeDBSchema(baseSchema, schemaToMerge) {
+    let schema = Object.assign({}, baseSchema);
+    for (let property in schemaToMerge)
+        schema[property] = schemaToMerge[property];
+    return schema;
+}
+/**
+ * transform string or string array to ObjectId or ObjectId array
+ *
+ * @param {*} value value or values to be converted
+ * @param {*} generate if true generate new id if value is not valid
+ */
+function toObjectId(value, generate = false) {
+    if (!value || !isValidObjectId(value))
+        return generate ? genObjectId() : value;
+    return (value instanceof mongoose_1.default.Types.ObjectId) ? value : mongoose_1.default.Types.ObjectId.createFromHexString(value);
+}
+exports.toObjectId = toObjectId;
+/**
+ *
+ * @param values
+ * @param generate
+ * @returns
+ */
+function toObjectIds(values, generate = false) {
+    return values.map(v => toObjectId(v));
+}
+exports.toObjectIds = toObjectIds;
+/**
+ * return a new ObjectId value
+ *
+ * @param {*} value
+ */
+function genObjectId() {
+    return new mongoose_1.default.Types.ObjectId();
+}
+exports.genObjectId = genObjectId;
+// /**
+//  * 
+//  * @param {*} period 
+//  * @param {*} year 
+//  */
+// export function toFilterDatePeriod(period: DatePeriod, year: number) {
+//   let values = getDatePeriod(period, year);
+//   return values ? { $gte: values[0], $lt: values[1] } : {};
+// }
+// /**
+//  * 
+//  * @param {*} idKey 
+//  * @param {*} model 
+//  * @param {*} item 
+//  */
+// export function checkDBItem<T>(idKey: string, model: T, item, upsert, logger = APP.logger) {
+//   if (!idKey || !model || !item || !item[idKey]) return (cb) => cb();
+//   let select    = {};
+//   select[idKey] = item[idKey];
+//   return (cb) => {
+//     if (upsert) {
+//       return model.mgModel.updateOne(select, item, { upsert: true }).then(res => {
+//         logger.info(`Upserted ${model.name} (${item[idKey]})`, logClassCtx(this));
+//         cb();
+//       });
+//     }
+//     model.findOneNative(select).then(res => {
+//       if (res) return cb();
+//       model.mgModel.collection.insertOne(item).then(res => {
+//         logger.info(`Created ${model.name} (${item[idKey]})`, logClassCtx(this));
+//         cb();
+//       });
+//     });
+//   }
+// }
+// export function checkDBItemByList(id: mongoose.Types.ObjectId, model, items = [], logger = APP.logger) {
+//   let item = items.find(i => i._id.toString() === id);
+//   if (!item) {
+//     return (cb) => {
+//       logger.info(`${model.name} (${id}) not defined`, logClassCtx(this));
+//       cb();
+//     };
+//   }
+//   return checkDBItem('_id', model, item, logger = APP.logger);
+// }
+/**
+ * Check if string or string array is a valid ObjectId
+ *
+ * @param {*} value
+ */
+function isValidObjectId(value) {
+    if (!value)
+        return;
+    if (Array.isArray(value))
+        return value.every(v => mongoose_1.default.isValidObjectId(v));
+    return mongoose_1.default.isValidObjectId(value);
+}
+exports.isValidObjectId = isValidObjectId;
+/**
+ *
+ * @param {*} id1
+ * @param {*} id2
+ * @returns
+ */
+function isSameId(id1, id2) {
+    return (id1 === null || id1 === void 0 ? void 0 : id1.toString()) === (id2 === null || id2 === void 0 ? void 0 : id2.toString());
+}
+exports.isSameId = isSameId;
+// /**
+//  * 
+//  * @param {*} cursor 
+//  * @param {*} method 
+//  * @param {*} resolve 
+//  */
+// export function manageCursor(cursor: any, method = (_item?: any) => {}, resolve: (res: boolean) => void) {
+//   if (!cursor)
+//     return resolve && resolve(true);
+//   cursor.next((_err: any, item: any) => {
+//     if (!item)
+//       return resolve && resolve(true);
+//     Promise.resolve(method(item)).then(() => {
+//       manageCursor(cursor, method, resolve);
+//     });
+//   });
+// }

package/build/common/base/mongo.types.d.ts

@@ -0,0 +1,20 @@
+import { NxObject } from '../interfaces';
+export type ModelDef<TDoc, TMongoModel, TNxModel> = {
+    classDef: new (params: ModelData<TDoc, TMongoModel>) => TNxModel;
+    name: string;
+    modelName: string;
+    modelParams: ModelDefParams;
+    collection: string;
+    schema: NxObject;
+    mergeSchema?: boolean;
+};
+export type ModelData<TDoc, TMongoModel> = {
+    name: string;
+    model: TMongoModel;
+    params: ModelDefParams;
+    logger: any;
+};
+export type ModelDefParams = {
+    sort?: NxObject;
+    CRUDEvents?: boolean;
+};

package/build/common/base/mongo.types.js

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

package/build/common/base/sql-utils.d.ts

@@ -0,0 +1,20 @@
+import sequelize from 'sequelize';
+import { NxObject } from '../interfaces';
+export declare const codedEntitySQLSchema: {
+    code: {
+        type: sequelize.StringDataTypeConstructor;
+        allowNull: boolean;
+        unique: boolean;
+    };
+    name: {
+        type: sequelize.StringDataTypeConstructor;
+    };
+};
+export declare const TABLE_SYNC_PROMISES: NxObject;
+/**
+ *
+ * @param {*} modelName
+ * @param {*} schema
+ * @param {*} collection
+ */
+export declare function loadSQLModel(modelName: string, modelDef: any, schema: any, tableName: string, schemaName: string, params?: any): any;