@modular-rest/server 1.11.12 → 1.12.0

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 {};