@modular-rest/server 1.11.14 → 1.11.15

package/dist/class/combinator.js

@@ -0,0 +1,174 @@
+"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 };
+};
+const koa_router_1 = __importDefault(require("koa-router"));
+const directory = __importStar(require("./directory"));
+const service_1 = require("../services/functions/service");
+class Combinator {
+    async combineRoutesByFilePath(rootDirectory, app) {
+        // find route paths
+        const option = {
+            name: 'router',
+            filter: ['.js'],
+        };
+        let routerPaths = [];
+        try {
+            routerPaths = await directory.find(rootDirectory, option);
+        }
+        catch (e) {
+            console.log(e);
+        }
+        // create and combine routes into the app
+        for (let i = 0; i < routerPaths.length; i++) {
+            const service = require(routerPaths[i]);
+            const name = service.name;
+            const serviceRouter = new koa_router_1.default();
+            serviceRouter.use(`/${name}`, service.main.routes());
+            app.use(serviceRouter.routes());
+        }
+    }
+    /**
+     * Combine modules from files in a directory
+     * @param options - Configuration options
+     */
+    async combineModulesByFilePath({ rootDirectory, filename, combineWithRoot, convertToArray, }) {
+        // find route paths
+        let rootObject_temp;
+        const option = {
+            name: filename.name,
+            filter: [filename.extension],
+        };
+        let modulesPath = [];
+        try {
+            modulesPath = await directory.find(rootDirectory, option);
+        }
+        catch (e) {
+            console.log(e);
+        }
+        // create and combine routes into the app
+        for (let i = 0; i < modulesPath.length; i++) {
+            const moduleObject = require(modulesPath[i]);
+            // act by otherOption
+            if (combineWithRoot) {
+                if (moduleObject.name)
+                    delete moduleObject.name;
+                if (Array.isArray(moduleObject)) {
+                    if (!rootObject_temp)
+                        rootObject_temp = [];
+                    rootObject_temp = [...rootObject_temp, ...moduleObject];
+                }
+                else {
+                    rootObject_temp = this.extendObj(rootObject_temp, moduleObject);
+                }
+            }
+            // default act
+            else {
+                const name = moduleObject.name;
+                rootObject_temp[name] = moduleObject;
+            }
+        }
+        // options
+        // convertToArray
+        if (convertToArray) {
+            rootObject_temp = Object.values(rootObject_temp);
+        }
+        // set result to main rootObject
+        return rootObject_temp;
+    }
+    /**
+     * Combine functions from files in a directory
+     * @param options - Function options
+     */
+    async combineFunctionsByFilePath({ rootDirectory, filename }) {
+        // find route paths
+        const option = {
+            name: filename.name,
+            filter: [filename.extension],
+        };
+        let functionsPaths = [];
+        try {
+            functionsPaths = await directory.find(rootDirectory, option);
+        }
+        catch (e) {
+            console.log(e);
+        }
+        // create and combine routes into the app
+        for (let i = 0; i < functionsPaths.length; i++) {
+            const modularFunctions = require(functionsPaths[i]);
+            if (!modularFunctions.functions) {
+                throw new Error(`Module file ${functionsPaths[i]} does not have functions property.`);
+            }
+            // if array
+            if (Array.isArray(modularFunctions.functions)) {
+                for (const moduleFunction of modularFunctions.functions) {
+                    (0, service_1.addFunction)(moduleFunction);
+                }
+            }
+            else {
+                (0, service_1.addFunction)(modularFunctions.functions);
+            }
+        }
+    }
+    /**
+     * Add functions from an array
+     * @param functionList - List of functions to add
+     */
+    addFunctionsByArray(functionList) {
+        for (const functionItem of functionList) {
+            (0, service_1.addFunction)(functionItem);
+        }
+    }
+    /**
+     * Extend an object with properties from another
+     * @param obj - Target object
+     * @param src - Source object
+     * @returns Extended object
+     */
+    extendObj(obj, src) {
+        obj = obj || {};
+        for (const key in src) {
+            if (Object.prototype.hasOwnProperty.call(src, key))
+                obj[key] = src[key];
+        }
+        return obj;
+    }
+    static get instance() {
+        return instance;
+    }
+}
+const instance = new Combinator();
+module.exports = instance;

package/dist/class/database_trigger.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Type for database operations that can trigger a callback
+ */
+export type DatabaseOperation = 'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate';
+/**
+ * Context interface for database trigger callbacks
+ * @interface DatabaseTriggerContext
+ * @property {Record<string, any>} doc - The document data for insert/update operations
+ * @property {Record<string, any>} query - The query data for find/find-one operations
+ * @property {Record<string, any>} update - The update data for update operations
+ * @property {Record<string, any>[]} pipelines - The aggregation pipelines for aggregate operations
+ * @property {Record<string, any> } queryResult - The result of the database operation
+ */
+export interface DatabaseTriggerContext {
+    doc?: Record<string, any>;
+    query?: Record<string, any>;
+    update?: Record<string, any>;
+    pipelines?: Record<string, any>[];
+    queryResult: Record<string, any>;
+}
+/**
+ * The callback function to be executed on specific database operations
+ * @param {DatabaseTriggerContext} context - The context of the database operation
+ * @example
+ * ```typescript
+ * const trigger = new DatabaseTrigger('insert-one', (context) => {
+ *   console.log('New document inserted:', context.queryResult);
+ * });
+ * ```
+ */
+type DatabaseTriggerCallback = (context: DatabaseTriggerContext) => void;
+/**
+ * in a complex application, you may need to perform additional actions after a database operation.
+ * this is where DatabaseTrigger comes in. so you can define a callback to be executed on specific database operations for a collection.
+ *
+ * Supported triggers are:
+ *
+ * | Trigger      | Description                                                  |
+ * | ------------ | ------------------------------------------------------------ |
+ * | `find`       | Triggered when a find query is executed on collection.       |
+ * | `find-one`   | Triggered when a find one query is executed on collection.   |
+ * | `count`      | Triggered when a count query is executed on collection.      |
+ * | `update-one` | Triggered when a update one query is executed on collection. |
+ * | `insert-one` | Triggered when a insert one query is executed on collection. |
+ * | `remove-one` | Triggered when a remove one query is executed on collection. |
+ * | `aggregate`  | Triggered when a aggregate query is executed on collection.  |
+ *
+ * @property {DatabaseOperation} operation - The database operation that triggers the callback
+ * @property {DatabaseTriggerCallback} callback - The callback function to be executed
+ *
+ * @example
+ * ```typescript
+ * import { DatabaseTrigger } from '@server-ts/database';
+ *
+ * const trigger = new DatabaseTrigger('insert-one', ({ query, queryResult }) => {
+ *   console.log('New document inserted:', queryResult);
+ *
+ *   try {
+ *     // Perform additional actions after document insertion
+ *   } catch (error) {
+ *     console.error('Error performing additional actions:', error);
+ *   }
+ * });
+ *
+ * // Use the trigger in a collection definition
+ * const collection = new CollectionDefinition({
+ *   triggers: [trigger]
+ * });
+ * ```
+ */
+export declare class DatabaseTrigger {
+    operation: DatabaseOperation;
+    callback: (context: DatabaseTriggerContext) => void;
+    /**
+     * @hidden
+     *
+     * Creates a new DatabaseTrigger instance
+     * @param {DatabaseOperation} operation - The database operation to trigger on
+     * @param {DatabaseTriggerCallback} [callback=() => {}] - The callback function to execute
+     *
+     * @example
+     * ```typescript
+     * const trigger = new DatabaseTrigger('insert-one', (context) => {
+     *   console.log('New document inserted:', context.queryResult);
+     * });
+     *
+     */
+    constructor(operation: DatabaseOperation, callback?: DatabaseTriggerCallback);
+}
+export default DatabaseTrigger;

package/dist/class/database_trigger.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseTrigger = void 0;
+/**
+ * in a complex application, you may need to perform additional actions after a database operation.
+ * this is where DatabaseTrigger comes in. so you can define a callback to be executed on specific database operations for a collection.
+ *
+ * Supported triggers are:
+ *
+ * | Trigger      | Description                                                  |
+ * | ------------ | ------------------------------------------------------------ |
+ * | `find`       | Triggered when a find query is executed on collection.       |
+ * | `find-one`   | Triggered when a find one query is executed on collection.   |
+ * | `count`      | Triggered when a count query is executed on collection.      |
+ * | `update-one` | Triggered when a update one query is executed on collection. |
+ * | `insert-one` | Triggered when a insert one query is executed on collection. |
+ * | `remove-one` | Triggered when a remove one query is executed on collection. |
+ * | `aggregate`  | Triggered when a aggregate query is executed on collection.  |
+ *
+ * @property {DatabaseOperation} operation - The database operation that triggers the callback
+ * @property {DatabaseTriggerCallback} callback - The callback function to be executed
+ *
+ * @example
+ * ```typescript
+ * import { DatabaseTrigger } from '@server-ts/database';
+ *
+ * const trigger = new DatabaseTrigger('insert-one', ({ query, queryResult }) => {
+ *   console.log('New document inserted:', queryResult);
+ *
+ *   try {
+ *     // Perform additional actions after document insertion
+ *   } catch (error) {
+ *     console.error('Error performing additional actions:', error);
+ *   }
+ * });
+ *
+ * // Use the trigger in a collection definition
+ * const collection = new CollectionDefinition({
+ *   triggers: [trigger]
+ * });
+ * ```
+ */
+class DatabaseTrigger {
+    /**
+     * @hidden
+     *
+     * Creates a new DatabaseTrigger instance
+     * @param {DatabaseOperation} operation - The database operation to trigger on
+     * @param {DatabaseTriggerCallback} [callback=() => {}] - The callback function to execute
+     *
+     * @example
+     * ```typescript
+     * const trigger = new DatabaseTrigger('insert-one', (context) => {
+     *   console.log('New document inserted:', context.queryResult);
+     * });
+     *
+     */
+    constructor(operation, callback = () => { }) {
+        this.operation = operation;
+        this.callback = callback;
+    }
+}
+exports.DatabaseTrigger = DatabaseTrigger;
+exports.default = DatabaseTrigger;

package/dist/class/db_schemas.d.ts

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+/**
+ * File schema interface
+ */
+export interface IFile {
+    originalName: string;
+    fileName: string;
+    owner: string;
+    format: string;
+    tag: string;
+    size: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * File schema
+ */
+export declare const fileSchema: mongoose.Schema<IFile, mongoose.Model<IFile, any, any>, undefined, {}>;
+/**
+ * Schema definitions
+ */
+export declare const schemas: {
+    file: mongoose.Schema<IFile, mongoose.Model<IFile, any, any>, undefined, {}>;
+};
+export default schemas;

package/dist/class/db_schemas.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemas = exports.fileSchema = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const { Schema } = mongoose_1.default;
+/**
+ * File schema
+ */
+exports.fileSchema = new Schema({
+    originalName: String,
+    fileName: String,
+    owner: String,
+    format: String,
+    // Tag being used as the parent dir for files
+    // uploadDir/$format/$tag/timestamp.format
+    tag: String,
+    size: Number,
+}, { timestamps: true });
+/**
+ * Schema definitions
+ */
+exports.schemas = {
+    file: exports.fileSchema,
+};
+exports.default = exports.schemas;

package/dist/class/directory.d.ts

@@ -0,0 +1,20 @@
+interface DirectorySettings {
+    name?: string;
+    filter?: string[];
+}
+type WalkCallback = (err: Error | null, results: string[]) => void;
+/**
+ * Walk through a directory and its subdirectories
+ * @param dir - Directory to walk
+ * @param settings - Settings for filtering files
+ * @param done - Callback function
+ */
+declare function walk(dir: string, settings: DirectorySettings, done: WalkCallback): void;
+/**
+ * Find files in a directory with Promise API
+ * @param dir - Directory to search
+ * @param settings - Settings for filtering files
+ * @returns Promise resolving to an array of file paths
+ */
+declare function find(dir: string, settings: DirectorySettings): Promise<string[]>;
+export { walk, find };

package/dist/class/directory.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walk = walk;
+exports.find = find;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Walk through a directory and its subdirectories
+ * @param dir - Directory to walk
+ * @param settings - Settings for filtering files
+ * @param done - Callback function
+ */
+function walk(dir, settings, done) {
+    let results = [];
+    // Read director file and folders
+    fs_1.default.readdir(dir, function (err, list) {
+        if (err)
+            return done(err, results);
+        let pending = list.length;
+        if (!pending)
+            return done(null, results);
+        list.forEach(function (file) {
+            file = path_1.default.join(dir, file);
+            fs_1.default.stat(file, function (err, stat) {
+                if (err) {
+                    // Handle file stat error but continue with other files
+                    console.error(`Error reading file stats for ${file}:`, err);
+                    if (!--pending)
+                        done(null, results);
+                    return;
+                }
+                // If directory, execute a recursive call
+                if (stat && stat.isDirectory()) {
+                    // Add directory to array [comment if you need to remove the directories from the array]
+                    // results.push(file);
+                    walk(file, settings, function (err, res) {
+                        results = results.concat(res);
+                        if (!--pending)
+                            done(null, results);
+                    });
+                }
+                else {
+                    // file filter
+                    const extension = path_1.default.extname(file);
+                    const fileName = path_1.default.basename(file).split('.')[0];
+                    let fileNameKey = true;
+                    // name filter
+                    if (settings.name && settings.name === fileName)
+                        fileNameKey = true;
+                    else
+                        fileNameKey = false;
+                    // extension filter
+                    if (settings.filter && fileNameKey) {
+                        settings.filter.forEach(function (element) {
+                            if (element.toLowerCase() === extension.toLowerCase())
+                                results.push(file);
+                        });
+                    }
+                    // push any file if no option
+                    else if (fileNameKey)
+                        results.push(file);
+                    if (!--pending)
+                        done(null, results);
+                }
+            });
+        });
+    });
+}
+/**
+ * Find files in a directory with Promise API
+ * @param dir - Directory to search
+ * @param settings - Settings for filtering files
+ * @returns Promise resolving to an array of file paths
+ */
+function find(dir, settings) {
+    return new Promise((resolve, reject) => {
+        walk(dir, settings, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+}

package/dist/class/paginator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pagination result interface
+ */
+export interface PaginationResult {
+    pages: number;
+    page: number;
+    from: number;
+    to: number;
+}
+/**
+ * Creates a pagination object based on the given parameters.
+ * @param count - The total number of items to paginate.
+ * @param perPage - The number of items to display per page.
+ * @param page - The current page number.
+ * @returns An object containing pagination information.
+ *
+ * @example
+ * ```typescript
+ * import { paginator } from '@modular-rest/server';
+ *
+ * const pagination = paginator.create(100, 10, 1);
+ * // json response will be like this
+ * // {
+ * //   pages: 10,
+ * //   page: 1,
+ * //   from: 0,
+ * //   to: 10,
+ * // }
+ * ```
+ */
+export declare function create(count: number, perPage: number, page: number): PaginationResult;

package/dist/class/paginator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+/**
+ * Creates a pagination object based on the given parameters.
+ * @param count - The total number of items to paginate.
+ * @param perPage - The number of items to display per page.
+ * @param page - The current page number.
+ * @returns An object containing pagination information.
+ *
+ * @example
+ * ```typescript
+ * import { paginator } from '@modular-rest/server';
+ *
+ * const pagination = paginator.create(100, 10, 1);
+ * // json response will be like this
+ * // {
+ * //   pages: 10,
+ * //   page: 1,
+ * //   from: 0,
+ * //   to: 10,
+ * // }
+ * ```
+ */
+function create(count, perPage, page) {
+    const totalPages = Math.ceil(count / perPage);
+    if (page > totalPages)
+        page = 1;
+    let from = 0;
+    if (perPage === 1)
+        from = page - 1;
+    else
+        from = perPage * page - perPage;
+    if (page <= 1)
+        from = 0;
+    const result = {
+        pages: totalPages,
+        page: page,
+        from: from,
+        to: perPage,
+    };
+    return result;
+}

package/dist/class/reply.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Response status type
+ */
+export type ResponseStatus = 's' | 'f' | 'e';
+/**
+ * Response object interface
+ */
+export interface ResponseObject {
+    status: 'success' | 'fail' | 'error';
+    [key: string]: any;
+}
+/**
+ * Creates a response object with the given status and detail.
+ *
+ * @param status - The status of the response. Can be "s" for success, "f" for fail, or "e" for error.
+ * @param detail - The detail of the response. Can contain any additional information about the response.
+ * @returns The response object with the given status and detail.
+ *
+ * @example
+ * ```typescript
+ * import { reply } from '@modular-rest/server';
+ *
+ * // inside the router
+ * const response = reply.create("s", { message: "Hello, world!" });
+ * ctx.body = response;
+ * ctx.status = 200;
+ * ```
+ */
+export declare function create(status: ResponseStatus, detail?: Record<string, any>): ResponseObject;

package/dist/class/reply.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+/**
+ * Creates a response object with the given status and detail.
+ *
+ * @param status - The status of the response. Can be "s" for success, "f" for fail, or "e" for error.
+ * @param detail - The detail of the response. Can contain any additional information about the response.
+ * @returns The response object with the given status and detail.
+ *
+ * @example
+ * ```typescript
+ * import { reply } from '@modular-rest/server';
+ *
+ * // inside the router
+ * const response = reply.create("s", { message: "Hello, world!" });
+ * ctx.body = response;
+ * ctx.status = 200;
+ * ```
+ */
+function create(status, detail = {}) {
+    // Initialize with a default status that will be overwritten
+    const result = {
+        status: 'success',
+        ...detail,
+    };
+    // define status
+    switch (status) {
+        case 's':
+            result.status = 'success';
+            break;
+        case 'f':
+            result.status = 'fail';
+            break;
+        case 'e':
+            result.status = 'error';
+            break;
+        default:
+            result.status = 'success';
+            break;
+    }
+    // return
+    return result;
+}