@modular-rest/server 1.11.13 → 1.11.15

package/dist/services/data_provider/service.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeCasters = exports.triggers = exports.name = void 0;
+exports.addCollectionDefinitionByList = addCollectionDefinitionByList;
+exports.getCollection = getCollection;
+exports.checkAccess = checkAccess;
+exports.getAsID = getAsID;
+exports.performPopulateToQueryObject = performPopulateToQueryObject;
+exports.performAdditionalOptionsToQueryObject = performAdditionalOptionsToQueryObject;
+const mongoose_1 = __importDefault(require("mongoose"));
+const security_1 = require("../../class/security");
+const trigger_operator_1 = __importDefault(require("../../class/trigger_operator"));
+exports.triggers = trigger_operator_1.default;
+const typeCasters_1 = __importDefault(require("./typeCasters"));
+exports.TypeCasters = typeCasters_1.default;
+/**
+ * Service name constant
+ * @constant {string}
+ */
+exports.name = 'dataProvider';
+// Set mongoose options
+mongoose_1.default.set('useCreateIndex', true);
+// Database connections and collections storage
+const connections = {};
+const collections = {};
+const permissionDefinitions = {};
+/**
+ * Connects to a database and sets up collections based on collection definitions
+ * @function connectToDatabaseByCollectionDefinitionList
+ * @param {string} dbName - Name of the database to connect to
+ * @param {CollectionDefinition[]} [collectionDefinitionList=[]] - List of collection definitions
+ * @param {MongoOption} mongoOption - MongoDB connection options
+ * @returns {Promise<void>} A promise that resolves when the connection is established
+ * @throws {Error} If triggers are not properly configured
+ * @private
+ */
+function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList = [], mongoOption) {
+    return new Promise((done, reject) => {
+        // Create db connection
+        const fullDbName = (mongoOption.dbPrefix || '') + dbName;
+        const connectionString = mongoOption.mongoBaseAddress;
+        console.info(`- Connecting to database: ${fullDbName}`);
+        const connection = mongoose_1.default.createConnection(connectionString, {
+            useUnifiedTopology: true,
+            useNewUrlParser: true,
+            dbName: fullDbName,
+        });
+        // Store connection
+        connections[dbName] = connection;
+        // add db models from schemas
+        collectionDefinitionList.forEach(collectionDefinition => {
+            const collection = collectionDefinition.collection;
+            const schema = collectionDefinition.schema;
+            if (collections[dbName] == undefined)
+                collections[dbName] = {};
+            if (permissionDefinitions[dbName] == undefined)
+                permissionDefinitions[dbName] = {};
+            // create model from schema
+            // and store in on global collection object
+            const model = connection.model(collection, schema);
+            collections[dbName][collection] = model;
+            // define Access Definition from component permissions
+            // and store it on global access definition object
+            permissionDefinitions[dbName][collection] = new security_1.AccessDefinition({
+                database: dbName,
+                collection: collection,
+                permissionList: collectionDefinition.permissions,
+            });
+            // add trigger
+            if (collectionDefinition.triggers != undefined) {
+                if (!Array.isArray(collectionDefinition.triggers)) {
+                    throw new Error('Triggers must be an array');
+                }
+                collectionDefinition.triggers.forEach(trigger => {
+                    trigger_operator_1.default.addTrigger({
+                        ...trigger,
+                        database: collectionDefinition.database,
+                        collection: collectionDefinition.collection,
+                    });
+                });
+            }
+        });
+        connection.on('connected', () => {
+            console.info(`- ${fullDbName} database has been connected`);
+            done();
+        });
+    });
+}
+/**
+ * Adds collection definitions and connects to their respective databases
+ * @function addCollectionDefinitionByList
+ * @param {CollectionDefinitionListOption} options - Collection definition options
+ * @returns {Promise<void>} A promise that resolves when all collections are set up
+ * @example
+ * ```typescript
+ * await addCollectionDefinitionByList({
+ *   list: [
+ *     new CollectionDefinition({
+ *       database: 'myapp',
+ *       collection: 'users',
+ *       schema: userSchema,
+ *       permissions: [new Permission({ type: 'user_access', read: true })]
+ *     })
+ *   ],
+ *   mongoOption: {
+ *     mongoBaseAddress: 'mongodb://localhost:27017',
+ *     dbPrefix: 'myapp_'
+ *   }
+ * });
+ * ```
+ */
+async function addCollectionDefinitionByList({ list, mongoOption, }) {
+    // Group collection definitions by database
+    const dbGroups = {};
+    list.forEach(collectionDefinition => {
+        if (!dbGroups[collectionDefinition.database]) {
+            dbGroups[collectionDefinition.database] = [];
+        }
+        dbGroups[collectionDefinition.database].push(collectionDefinition);
+    });
+    // Connect to each database
+    const connectionPromises = Object.entries(dbGroups).map(([dbName, collectionDefinitionList]) => connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList, mongoOption));
+    await Promise.all(connectionPromises);
+}
+/**
+ * Gets a Mongoose model for a specific collection
+ * @function getCollection
+ * @param {string} db - Database name
+ * @param {string} collection - Collection name
+ * @returns {Model<T>} Mongoose model for the collection
+ * @throws {Error} If the collection doesn't exist
+ * @example
+ * ```typescript
+ * const userModel = getCollection('myapp', 'users');
+ * const users = await userModel.find();
+ * ```
+ */
+function getCollection(db, collection) {
+    if (!collections[db] || !collections[db][collection]) {
+        throw new Error(`Collection ${collection} not found in database ${db}`);
+    }
+    return collections[db][collection];
+}
+/**
+ * Gets the permission list for a specific operation on a collection
+ * @function _getPermissionList
+ * @param {string} db - Database name
+ * @param {string} collection - Collection name
+ * @param {string} operationType - Type of operation (read/write)
+ * @returns {any[]} List of permissions
+ * @private
+ */
+function _getPermissionList(db, collection, operationType) {
+    if (!permissionDefinitions[db] || !permissionDefinitions[db][collection]) {
+        return [];
+    }
+    return permissionDefinitions[db][collection].permissionList;
+}
+/**
+ * Checks if a user has access to perform an operation on a collection
+ * @function checkAccess
+ * @param {string} db - Database name
+ * @param {string} collection - Collection name
+ * @param {string} operationType - Type of operation (read/write)
+ * @param {Record<string, any>} queryOrDoc - Query or document being accessed
+ * @param {User} user - User performing the operation
+ * @returns {boolean} Whether the user has access
+ * @example
+ * ```typescript
+ * const hasAccess = checkAccess('myapp', 'users', 'read', {}, currentUser);
+ * if (hasAccess) {
+ *   const users = await getCollection('myapp', 'users').find();
+ * }
+ * ```
+ */
+function checkAccess(db, collection, operationType, queryOrDoc, user) {
+    const permissionList = _getPermissionList(db, collection, operationType);
+    return permissionList.some(permission => {
+        if (permission.accessType === 'god_access')
+            return true;
+        if (permission.accessType === 'anonymous_access' && user.type === 'anonymous')
+            return true;
+        if (permission.accessType === 'user_access' && user.type === 'user')
+            return true;
+        return false;
+    });
+}
+/**
+ * Converts a string ID to a MongoDB ObjectId
+ * @function getAsID
+ * @param {string} strId - String ID to convert
+ * @returns {mongoose.Types.ObjectId | undefined} MongoDB ObjectId or undefined if invalid
+ * @example
+ * ```typescript
+ * const id = getAsID('507f1f77bcf86cd799439011');
+ * if (id) {
+ *   const doc = await collection.findById(id);
+ * }
+ * ```
+ */
+function getAsID(strId) {
+    try {
+        return mongoose_1.default.Types.ObjectId(strId);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/**
+ * Applies populate options to a Mongoose query
+ * @function performPopulateToQueryObject
+ * @param {Query<T, any>} queryObj - Mongoose query object
+ * @param {PopulateOptions[]} [popArr=[]] - Array of populate options
+ * @returns {Query<T, any>} Query with populate options applied
+ * @example
+ * ```typescript
+ * const query = collection.find();
+ * const populatedQuery = performPopulateToQueryObject(query, [
+ *   { path: 'author', select: 'name email' }
+ * ]);
+ * ```
+ */
+function performPopulateToQueryObject(queryObj, popArr = []) {
+    popArr.forEach(pop => {
+        queryObj.populate(pop);
+    });
+    return queryObj;
+}
+/**
+ * Applies additional options to a Mongoose query
+ * @function performAdditionalOptionsToQueryObject
+ * @param {Query<T, any>} queryObj - Mongoose query object
+ * @param {Record<string, any>} options - Additional query options
+ * @returns {Query<T, any>} Query with additional options applied
+ * @example
+ * ```typescript
+ * const query = collection.find();
+ * const queryWithOptions = performAdditionalOptionsToQueryObject(query, {
+ *   sort: { createdAt: -1 },
+ *   limit: 10
+ * });
+ * ```
+ */
+function performAdditionalOptionsToQueryObject(queryObj, options) {
+    Object.entries(options).forEach(([key, value]) => {
+        // @ts-ignore
+        queryObj[key](value);
+    });
+    return queryObj;
+}

package/dist/services/data_provider/typeCasters.d.ts

@@ -0,0 +1,9 @@
+import mongoose from 'mongoose';
+/**
+ * Type casting functions for MongoDB types
+ */
+declare const TypeCasters: {
+    ObjectId: mongoose.Types.ObjectIdConstructor;
+    Date: (dateValue: string | Date) => Date;
+};
+export default TypeCasters;

package/dist/services/data_provider/typeCasters.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+/**
+ * Type casting functions for MongoDB types
+ */
+const TypeCasters = {
+    ObjectId: mongoose_1.default.Types.ObjectId,
+    Date: (dateValue) => {
+        const strDate = dateValue.toString();
+        const mongoDateFormateInString = new Date(strDate).toISOString().split('T')[0];
+        return new Date(mongoDateFormateInString);
+    },
+};
+exports.default = TypeCasters;

package/dist/services/file/db.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/file/db.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const db_schemas_1 = __importDefault(require("../../class/db_schemas"));
+const collection_definition_1 = require("../../class/collection_definition");
+const security_1 = require("../../class/security");
+const config_1 = require("../../config");
+module.exports = [
+    new collection_definition_1.CollectionDefinition({
+        database: 'cms',
+        collection: 'file',
+        schema: db_schemas_1.default.file,
+        permissions: [
+            new security_1.Permission({
+                accessType: security_1.PermissionTypes.upload_file_access,
+                read: true,
+                write: true,
+                onlyOwnData: false,
+            }),
+            new security_1.Permission({
+                accessType: security_1.PermissionTypes.remove_file_access,
+                read: true,
+                write: true,
+                onlyOwnData: false,
+            }),
+        ],
+        triggers: config_1.config.fileTriggers || [],
+    }),
+];

package/dist/services/file/router.d.ts

@@ -0,0 +1,4 @@
+import Router from 'koa-router';
+declare const name = "file";
+declare const fileRouter: Router<any, {}>;
+export { name, fileRouter as main };

package/dist/services/file/router.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.name = void 0;
+const koa_router_1 = __importDefault(require("koa-router"));
+const validator_1 = require("../../class/validator");
+const reply_1 = require("../../class/reply");
+const security_1 = require("./../../class/security");
+const DataService = __importStar(require("./../data_provider/service"));
+const service_1 = require("./service");
+const middleware = __importStar(require("../../middlewares"));
+const name = 'file';
+exports.name = name;
+const fileRouter = new koa_router_1.default();
+exports.main = fileRouter;
+fileRouter.use('/', middleware.auth, async (ctx, next) => {
+    await next();
+});
+fileRouter.post('/', async (ctx) => {
+    const body = ctx.request.body;
+    // validate result
+    const bodyValidate = (0, validator_1.validateObject)(body, 'tag');
+    // fields validation
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        ctx.body = (0, reply_1.create)('e', { e: bodyValidate.requires });
+        return;
+    }
+    // Access validation
+    const hasAccess = DataService.checkAccess('cms', 'file', security_1.AccessTypes.write, body, ctx.state.user);
+    if (!hasAccess) {
+        ctx.throw(403, 'access denied');
+        return;
+    }
+    const files = ctx.request.files;
+    const file = files && files.file;
+    let result;
+    if (!file) {
+        ctx.status = 412;
+        result = (0, reply_1.create)('f', { message: 'file field required' });
+    }
+    else {
+        await service_1.main
+            .storeFile({
+            file: file,
+            ownerId: ctx.state.user.id,
+            tag: body.tag,
+        })
+            .then(file => {
+            result = (0, reply_1.create)('s', { file });
+        })
+            .catch(error => {
+            ctx.status = 412;
+            result = (0, reply_1.create)('e', error);
+        });
+    }
+    ctx.body = result;
+});
+fileRouter.delete('/', async (ctx) => {
+    const body = ctx.request.query;
+    // validate
+    const bodyValidate = (0, validator_1.validateObject)(body, 'id');
+    let result;
+    if (!bodyValidate.isValid) {
+        ctx.status = 412;
+        result = (0, reply_1.create)('f', { message: 'some fields required.', error: bodyValidate.requires });
+    }
+    else {
+        await service_1.main
+            .removeFile(body.id)
+            .then(() => {
+            result = (0, reply_1.create)('s');
+        })
+            .catch(e => {
+            ctx.status = 412;
+            result = (0, reply_1.create)('e', { error: e });
+        });
+    }
+    ctx.body = result;
+});

package/dist/services/file/service.d.ts

@@ -0,0 +1,204 @@
+import { IFile } from '../../class/db_schemas';
+/**
+ * Service name constant
+ * @constant {string}
+ */
+export declare const name = "file";
+/**
+ * File storage detail interface
+ * @interface StoredFileDetail
+ * @property {string} fileName - Generated unique filename
+ * @property {string} fullPath - Full path to the stored file
+ * @property {string} fileFormat - File format/extension
+ */
+interface StoredFileDetail {
+    fileName: string;
+    fullPath: string;
+    fileFormat: string;
+}
+/**
+ * File upload options interface
+ * @interface StoreFileOptions
+ * @property {Object} file - File details
+ * @property {string} file.path - Temporary file path
+ * @property {string} file.type - MIME type of the file
+ * @property {string} file.name - Original filename
+ * @property {number} file.size - File size in bytes
+ * @property {string} ownerId - ID of the file owner
+ * @property {string} tag - Tag for file organization
+ * @property {boolean} [removeFileAfterStore=true] - Whether to remove the temporary file after storage
+ */
+interface StoreFileOptions {
+    file: {
+        path: string;
+        type: string;
+        name: string;
+        size: number;
+    };
+    ownerId: string;
+    tag: string;
+    removeFileAfterStore?: boolean;
+}
+/**
+ * File service for handling file storage and retrieval.
+ *
+ * This service provides functionality for storing, retrieving, and managing files.
+ * It handles file storage on disk and maintains file metadata in the database.
+ * Files are organized by format and tag in the upload directory.
+ */
+declare class FileService {
+    /**
+     * @hidden
+     */
+    private directory;
+    /**
+     * @hidden
+     */
+    static instance: FileService;
+    /**
+     * @hidden
+     */
+    constructor();
+    /**
+     * @hidden
+     *
+     * Sets the upload directory for file storage
+     * @param {string} directory - Directory path for file storage
+     * @throws {Error} If directory is invalid or not writable
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * fileService.setUploadDirectory('/path/to/uploads');
+     * ```
+     */
+    setUploadDirectory(directory: string): void;
+    /**
+     * @hidden
+     *
+     * Creates stored file details with unique filename
+     * @param {string} fileType - MIME type of the file
+     * @param {string} tag - Tag for file organization
+     * @returns {StoredFileDetail} Storage details including filename and path
+     * @throws {Error} If upload directory is not set
+     *
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * const details = fileService.createStoredDetail('image/jpeg', 'profile');
+     * // Returns: { fileName: '1234567890.jpeg', fullPath: '/uploads/jpeg/profile/1234567890.jpeg', fileFormat: 'jpeg' }
+     * ```
+     */
+    createStoredDetail(fileType: string, tag: string): StoredFileDetail;
+    /**
+     * @hidden
+     *
+     * Stores a file, removes the temporary file, and saves metadata to database
+     * @param {StoreFileOptions} options - File storage options
+     * @returns {Promise<IFile>} Promise resolving to stored file document
+     * @throws {Error} If upload directory is not set or storage fails
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * const file = await fileService.storeFile({
+     *   file: {
+     *     path: '/tmp/upload.jpg',
+     *     type: 'image/jpeg',
+     *     name: 'profile.jpg',
+     *     size: 1024
+     *   },
+     *   ownerId: 'user123',
+     *   tag: 'profile',
+     *   removeFileAfterStore: true
+     * });
+     * ```
+     */
+    storeFile({ file, ownerId, tag, removeFileAfterStore }: StoreFileOptions): Promise<IFile>;
+    /**
+     * @hidden
+     *
+     * Removes a file from the disk
+     * @param {string} path - File path to remove
+     * @returns {Promise<void>} Promise resolving when file is removed
+     * @throws {Error} If file removal fails
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * await fileService.removeFromDisc('/uploads/jpeg/profile/1234567890.jpeg');
+     * ```
+     */
+    removeFromDisc(path: string): Promise<void>;
+    /**
+     * Removes a file from both database and disk
+     *
+     * @param {string} fileId - File ID to remove
+     * @returns {Promise<void>} Promise resolving when file is removed
+     * @throws {Error} If file is not found or removal fails
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * try {
+     *   await fileService.removeFile('file123');
+     *   console.log('File removed successfully');
+     * } catch (error) {
+     *   console.error('Failed to remove file:', error);
+     * }
+     * ```
+     */
+    removeFile(fileId: string): Promise<void>;
+    /**
+     * Retrieves a file document from the database
+     *
+     * @param {string} fileId - File ID to retrieve
+     * @returns {Promise<IFile>} Promise resolving to file document
+     * @throws {Error} If collection model is not found or file is not found
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * const fileDoc = await fileService.getFile('file123');
+     * console.log('File details:', fileDoc);
+     * ```
+     */
+    getFile(fileId: string): Promise<IFile>;
+    /**
+     * Retrieves the public URL link for a file
+     *
+     * @param {string} fileId - File ID to get link for
+     * @returns {Promise<string>} Promise resolving to file URL
+     * @throws {Error} If static path root is not defined or file is not found
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * const link = await fileService.getFileLink('file123');
+     * // Returns: '/static/jpeg/profile/1234567890.jpeg'
+     * ```
+     */
+    getFileLink(fileId: string): Promise<string>;
+    /**
+     * Gets the full filesystem path for a file
+     *
+     * @param {string} fileId - File ID to get path for
+     * @returns {Promise<string>} Promise resolving to full file path
+     * @throws {Error} If upload directory is not set or file is not found
+     * @example
+     * ```typescript
+     * import { fileService } from '@modular-rest/server';
+     *
+     * const path = await fileService.getFilePath('file123');
+     * // Returns: '/uploads/jpeg/profile/1234567890.jpeg'
+     * ```
+     */
+    getFilePath(fileId: string): Promise<string>;
+}
+/**
+ * Main file service instance
+ * @constant {FileService}
+ */
+export declare const main: FileService;
+export {};