@modular-rest/server 1.11.6 → 1.11.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modular-rest/server",
-  "version": "1.11.6",
+  "version": "1.11.8",
   "description": "a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.",
   "main": "src/index.js",
   "scripts": {
@@ -10,7 +10,7 @@
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/navidshad/modular-rest.git"
+    "url": "git+https://github.com/modular-rest/modular-rest.git"
   },
   "keywords": [
     "app",
@@ -21,9 +21,9 @@
   "author": "Navid Shad <navidshad72@gmail.com> (http://navid-shad.ir)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/navidshad/modular-rest/issues"
+    "url": "https://github.com/modular-rest/modular-rest/issues"
   },
-  "homepage": "https://github.com/navidshad/modular-rest#readme",
+  "homepage": "https://github.com/modular-rest/modular-rest#readme",
   "dependencies": {
     "@koa/cors": "^3.1.0",
     "colog": "^1.0.4",
@@ -44,4 +44,4 @@
     "@types/koa__cors": "^5.0.0",
     "typescript": "^5.3.3"
   }
-}
+}

package/types/src/application.d.ts

@@ -0,0 +1,97 @@
+export = createRest;
+/**
+ * Create a modular REST instance with Koa and MongoDB support.
+ * @param {{
+ *   cors?: Cors; // CORS options.
+ *   modulesPath?: string; // Root directory of your router.js/db.js files.
+ *   uploadDirectory?: string; // Root directory of your uploaded files.
+ *   koaBodyOptions?: object; // Options for koa-body.
+ *    staticPath?: {
+ *        rootDir: string; // Root directory of your static files.
+ *        rootPath: string; // Root path of your static files, defaults to '/assets'.
+ *        maxage?: number; // Browser cache max-age in milliseconds. Defaults to 0.
+ *        hidden?: boolean; // Allow transfer of hidden files. Defaults to false.
+ *        index?: string; // Default file name. Defaults to 'index.html'.
+ *        defer?: boolean; // If true, serves after return next(), allowing any downstream middleware to respond first. Defaults to false.
+ *        gzip?: boolean; // Try to serve the gzipped version of a file automatically when gzip is supported by a client and if the requested file with .gz extension exists. Defaults to true.
+ *        br?: boolean; // Try to serve the brotli version of a file automatically when brotli is supported by a client and if the requested file with .br extension exists. Note that brotli is only accepted over https. Defaults to false.
+ *        setHeaders?: Function; // Function to set custom headers on response.
+ *        extensions?: boolean|Array; // Try to match extensions from passed array to search for file when no extension is suffixed in URL. First found is served. Defaults to false.
+ *    };
+ *   onBeforeInit?: (koaApp:Koa) => void; // A callback called before initializing the Koa server.
+ *   onAfterInit?: (koaApp:Koa) => void; // A callback called after server initialization.
+ *   port?: number; // Server port.
+ *   dontListen?: boolean; // If true, the server will not run and will only return the Koa app object.
+ *   mongo?: {
+ *     dbPrefix: string; // A prefix for your database name.
+ *     mongoBaseAddress: string; // The address of your MongoDB server without any database specification.
+ *     addressMap?: string; // Specific addresses for each database.
+ *   };
+ *   keypair?: {
+ *     private: string; // Private key for RSA authentication.
+ *     public: string; // Public key for RSA authentication.
+ *   };
+ *   adminUser?: {
+ *     email: string; // Admin user email.
+ *     password: string; // Admin user password.
+ *   };
+ *   verificationCodeGeneratorMethod: () => string; // A method to return a verification code when registering a new user.
+ *   collectionDefinitions?: CollectionDefinition[]; // An array of additional collection definitions.
+ *   permissionGroups?: PermissionGroup[]; // An array of additional permission groups.
+ *   authTriggers?: CmsTrigger[]; // An array of additional database triggers for the auth collection.
+ *   fileTriggers?: CmsTrigger[]; // An array of additional database triggers for the auth collection.
+ * }} options
+ * @returns {Promise<{app: Koa, server: Server}>}
+ */
+declare function createRest(options: {
+    cors?: Cors;
+    modulesPath?: string;
+    uploadDirectory?: string;
+    koaBodyOptions?: object;
+    staticPath?: {
+        rootDir: string;
+        rootPath: string;
+        maxage?: number;
+        hidden?: boolean;
+        index?: string;
+        defer?: boolean;
+        gzip?: boolean;
+        br?: boolean;
+        setHeaders?: Function;
+        extensions?: boolean | any[];
+    };
+    onBeforeInit?: (koaApp: Koa) => void;
+    onAfterInit?: (koaApp: Koa) => void;
+    port?: number;
+    dontListen?: boolean;
+    mongo?: {
+        dbPrefix: string;
+        mongoBaseAddress: string;
+        addressMap?: string;
+    };
+    keypair?: {
+        private: string;
+        public: string;
+    };
+    adminUser?: {
+        email: string;
+        password: string;
+    };
+    verificationCodeGeneratorMethod: () => string;
+    collectionDefinitions?: CollectionDefinition[];
+    permissionGroups?: PermissionGroup[];
+    authTriggers?: CmsTrigger[];
+    fileTriggers?: CmsTrigger[];
+}): Promise<{
+    app: Koa;
+    server: Server;
+}>;
+declare namespace createRest {
+    export { Koa, server, Cors, PermissionGroup, CmsTrigger };
+}
+import cors = require("@koa/cors");
+type Cors = import('@koa/cors').Options;
+type Koa = import('koa');
+type PermissionGroup = import('./class/security.js').PermissionGroup;
+type CmsTrigger = import('./class/cms_trigger.js');
+type server = import('http').Server;

package/types/src/class/cms_trigger.d.ts

@@ -0,0 +1,24 @@
+export = CmsTrigger;
+/**
+ * `CmsTrigger` is a class that defines a callback to be called on a specific database transaction.
+ *
+ * @class
+ */
+declare class CmsTrigger {
+    /**
+     * Creates a new instance of `CmsTrigger`.
+     *
+     * @param {'update-one' | 'insert-one' | 'remove-one' } operation - The operation to be triggered.
+     * @param {function({query: any, queryResult: any}): void} [callback=(context) => {}] - The callback to be called when the operation is executed. The callback function takes an object as parameter with two properties: 'query' and 'queryResult'.
+     * @constructor
+     */
+    constructor(operation: 'update-one' | 'insert-one' | 'remove-one', callback?: (arg0: {
+        query: any;
+        queryResult: any;
+    }) => void);
+    operation: "update-one" | "insert-one" | "remove-one";
+    callback: (arg0: {
+        query: any;
+        queryResult: any;
+    }) => void;
+}

package/types/src/class/collection_definition.d.ts

@@ -0,0 +1,36 @@
+export = CollectionDefinition;
+/**
+ * @typedef {import('./security.js').Permission} Permission
+ * @typedef {import('./database_trigger.js')} DatabaseTrigger
+ */
+declare class CollectionDefinition {
+    /**
+     * This class helps to create a mongoose collection
+     * associated with permissions and triggers.
+     *
+     * @class
+     * @param {Object} option
+     * @param {string} option.db - Database name
+     * @param {string} option.collection - Collection name
+     * @param {Object} option.schema - Mongoose schema
+     * @param {Array<Permission>} option.permissions - A list of permissions for this collection
+     * @param {Array<DatabaseTrigger>=} option.triggers - A database trigger
+     */
+    constructor({ db, collection, schema, permissions, triggers }: {
+        db: string;
+        collection: string;
+        schema: any;
+        permissions: Array<Permission>;
+        triggers?: Array<DatabaseTrigger> | undefined;
+    });
+    database: string;
+    collection: string;
+    schema: any;
+    permissions: import("./security.js").Permission[];
+    triggers: import("./database_trigger.js")[];
+}
+declare namespace CollectionDefinition {
+    export { Permission, DatabaseTrigger };
+}
+type Permission = import('./security.js').Permission;
+type DatabaseTrigger = import('./database_trigger.js');

package/types/src/class/combinator.d.ts

@@ -0,0 +1,30 @@
+export = Combinator.instance;
+declare var instance: Combinator;
+declare class Combinator {
+    static get instance(): Combinator;
+    combineRoutesByFilePath(rootDirectory: any, app: any): Promise<void>;
+    /**
+     *
+     * @param {object} option
+     * @param {string} option.rootDirectory root directory of files
+     * @param {object} option.filename an object of {name, extension}
+     * @param {string} option.filename.name name of file
+     * @param {string} option.filename.extension the extension of the file
+     * @param {boolean} option.combineWithRoot combine all file content and return theme as a object
+     * @param {boolean} option.convertToArray return file content as an array instead an object
+     */
+    combineModulesByFilePath({ rootDirectory, filename, combineWithRoot, convertToArray, }: {
+        rootDirectory: string;
+        filename: {
+            name: string;
+            extension: string;
+        };
+        combineWithRoot: boolean;
+        convertToArray: boolean;
+    }): Promise<any>;
+    combineFunctionsByFilePath({ rootDirectory, filename }: {
+        rootDirectory: any;
+        filename: any;
+    }): Promise<void>;
+    extendObj(obj: any, src: any): any;
+}

package/types/src/class/database_trigger.d.ts

@@ -0,0 +1,24 @@
+export = DatabaseTrigger;
+/**
+ * `DatabaseTrigger` is a class that defines a callback to be called on a specific database transaction.
+ *
+ * @class
+ */
+declare class DatabaseTrigger {
+    /**
+     * Creates a new instance of `DatabaseTrigger`.
+     *
+     * @param {'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate'} operation - The operation to be triggered. Supported operations are: 'find', 'find-one', 'count', 'update-one', 'insert-one', 'remove-one', 'aggregate'.
+     * @param {function({query: any, queryResult: any}): void} [callback=(context) => {}] - The callback to be called when the operation is executed. The callback function takes an object as parameter with two properties: 'query' and 'queryResult'.
+     * @constructor
+     */
+    constructor(operation: 'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate', callback?: (arg0: {
+        query: any;
+        queryResult: any;
+    }) => void);
+    operation: "find" | "count" | "aggregate" | "find-one" | "update-one" | "insert-one" | "remove-one";
+    callback: (arg0: {
+        query: any;
+        queryResult: any;
+    }) => void;
+}

package/types/src/class/db_schemas.d.ts

@@ -0,0 +1,2 @@
+import mongoose = require("mongoose");
+export let file: mongoose.Schema<mongoose.Document<any, any, any>, mongoose.Model<mongoose.Document<any, any, any>, any, any>, undefined, {}>;

package/types/src/class/directory.d.ts

@@ -0,0 +1,2 @@
+export function walk(dir: any, settings: any, done: any): void;
+export function find(dir: any, settings: any): Promise<any>;

package/types/src/class/paginator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a pagination object based on the given parameters.
+ * @param {number} count - The total number of items to paginate.
+ * @param {number} perPage - The number of items to display per page.
+ * @param {number} page - The current page number.
+ * @returns {Object} - An object containing pagination information.
+ */
+export function create(count: number, perPage: number, page: number): any;

package/types/src/class/reply.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a response object with the given status and detail.
+ *
+ * @param {string} status - The status of the response. Can be "s" for success, "f" for fail, or "e" for error.
+ * @param {Object} [detail={}] - The detail of the response. Can contain any additional information about the response.
+ * @returns {Object} - The response object with the given status and detail.
+ */
+export function create(status: string, detail?: any): any;

package/types/src/class/security.d.ts

@@ -0,0 +1,109 @@
+export type PermissionType = ('user_access' | 'upload_file_access' | 'remove_file_access' | 'anonymous_access' | 'advanced_settings');
+/**
+ * Class representing an access definition.
+ */
+export class AccessDefinition {
+    /**
+     * Create an access definition.
+     * @param {Object} options - The options for the access definition.
+     * @param {string} options.database - The name of the database.
+     * @param {string} options.collection - The name of the collection.
+     * @param {Array.<Permission>} options.permissionList - The list of permissions.
+     */
+    constructor({ database, collection, permissionList }: {
+        database: string;
+        collection: string;
+        permissionList: Array<Permission>;
+    });
+    database: string;
+    collection: string;
+    permissionList: Permission[];
+}
+/**
+ * @typedef {('user_access'|'upload_file_access'|'remove_file_access'|'anonymous_access'|'advanced_settings')} PermissionType
+ */
+/**
+ * Class representing a permission.
+ */
+export class Permission {
+    /**
+     * Create a permission.
+     * @param {Object} options - The options for the permission.
+     * @param {PermissionType} options.type - The type of the permission.
+     * @param {boolean} [options.read=false] - The read access of the permission.
+     * @param {boolean} [options.write=false] - The write access of the permission.
+     * @param {boolean} [options.onlyOwnData=false] - If true, users can perform CRUD on documents that they created already.
+     * @param {string} [options.ownerIdField='refId'] - The name of the field that contains the owner's id of the document.
+     */
+    constructor({ type, read, write, onlyOwnData, ownerIdField, }: {
+        type: PermissionType;
+        read?: boolean;
+        write?: boolean;
+        onlyOwnData?: boolean;
+        ownerIdField?: string;
+    });
+    type: PermissionType;
+    read: boolean;
+    write: boolean;
+    onlyOwnData: boolean;
+    ownerIdField: string;
+}
+/**
+ * Class representing different types of permissions.
+ * Each static getter returns a string that represents a specific type of permission.
+ */
+export class PermissionTypes {
+    /**
+     * Get the string representing god access permission type.
+     * @return {string} The god access permission type.
+     */
+    static get god_access(): string;
+    /**
+     * Get the string representing advanced settings permission type.
+     * @return {string} The advanced settings permission type.
+     */
+    static get advanced_settings(): string;
+    /**
+     * Get the string representing user access permission type.
+     * @return {string} The user access permission type.
+     */
+    static get user_access(): string;
+    /**
+     * Get the string representing upload file access permission type.
+     * @return {string} The upload file access permission type.
+     */
+    static get upload_file_access(): string;
+    /**
+     * Get the string representing remove file access permission type.
+     * @return {string} The remove file access permission type.
+     */
+    static get remove_file_access(): string;
+}
+export class PermissionGroup {
+    /**
+     * Create a permission group.
+     * @param {Object} options - The options for the permission group.
+     * @param {string} options.title - The title of the permission group.
+     * @param {boolean} [options.isDefault=false] - If true, the permission group is the default permission group.
+     * @param {boolean} [options.isAnonymous=false] - If true, the permission group is the anonymous permission group.
+     * @param {Array.<PermissionType>} [options.validPermissionTypes=[]] - The valid permission types of the permission group.
+     * @return {PermissionGroup} The created permission group.
+     */
+    constructor({ title, isDefault, isAnonymous, validPermissionTypes, }: {
+        title: string;
+        isDefault?: boolean;
+        isAnonymous?: boolean;
+        validPermissionTypes?: Array<PermissionType>;
+    });
+    title: string;
+    isDefault: boolean;
+    isAnonymous: boolean;
+    validPermissionTypes: PermissionType[];
+}
+/**
+ * Class representing access types.
+ */
+export class AccessTypes {
+    static get read(): string;
+    static get write(): string;
+}

package/types/src/class/trigger_operator.d.ts

@@ -0,0 +1,19 @@
+export = TriggerOperator.instance;
+declare var instance: TriggerOperator;
+declare class TriggerOperator {
+    static get instance(): TriggerOperator;
+    triggers: any[];
+    /**
+     * add a collection trigger
+     * @param {object} trigger DatabaseTrigger object
+     */
+    addTrigger(trigger: object): void;
+    /**
+     * Call a trigger
+     * @param {'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate'} operation operation name
+     * @param {string} database database name
+     * @param {string} collection collection name
+     * @param {string} data
+     */
+    call(operation: 'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate', database: string, collection: string, data: string): void;
+}

package/types/src/class/user.d.ts

@@ -0,0 +1,24 @@
+export = User;
+declare class User {
+    static loadFromModel(model: any): Promise<any>;
+    static createFromModel(model: any, detail: any): Promise<any>;
+    static notValid(object: any): string;
+    constructor(id: any, permissionGroup: any, phone: any, email: any, password: any, type: any, model: any);
+    id: any;
+    permissionGroup: any;
+    email: any;
+    phone: any;
+    password: any;
+    type: any;
+    dbModel: any;
+    getBrief(): {
+        id: any;
+        permissionGroup: import("./security").PermissionGroup;
+        phone: any;
+        email: any;
+        type: any;
+    };
+    setNewDetail(detail: any): void;
+    hasPermission(permissionField: any): boolean;
+    save(): Promise<void>;
+}

package/types/src/class/validator.d.ts

@@ -0,0 +1,9 @@
+export = validate;
+/**
+ * Validates an object by checking if it contains all the required fields.
+ * @param {Object} obj - The object to be validated.
+ * @param {string|Object} requiredFields - The list of required fields. If it's a string, it should contain keys separated by spaces. If it's an object, it should contain key-value pairs where the key is the field name and the value is a boolean indicating whether the field is required or not.
+ * @returns {boolean} - Returns true if the object contains all the required fields, otherwise returns false.
+ * @throws {string} - Throws an error if the requiredFields parameter is not a string or an object.
+ */
+declare function validate(obj: any, requiredFields: string | any): boolean;

package/types/src/config.d.ts

@@ -0,0 +1,101 @@
+export type Koa = import('koa');
+export type Cors = import('@koa/cors').Options;
+export type CollectionDefinition = import('./class/collection_definition.js');
+export type PermissionGroup = import('./class/security.js').PermissionGroup;
+export type CmsTrigger = import('./class/cms_trigger.js');
+export type Config = {
+    cors?: Cors;
+    modulesPath?: string;
+    koaBodyOptions?: object;
+    staticPath?: {
+        rootDir: string;
+        rootPath: string;
+        maxage?: number;
+        hidden?: boolean;
+        index?: string;
+        defer?: boolean;
+        gzip?: boolean;
+        br?: boolean;
+        setHeaders?: Function;
+        extensions?: boolean | any[];
+    };
+    onBeforeInit?: (koaApp: Koa) => void;
+    onAfterInit?: (koaApp: Koa) => void;
+    port?: number;
+    dontListen?: boolean;
+    mongo?: {
+        dbPrefix: string;
+        mongoBaseAddress: string;
+        addressMap?: string;
+    };
+    keypair?: {
+        private: string;
+        public: string;
+    };
+    adminUser?: {
+        email: string;
+        password: string;
+    };
+    verificationCodeGeneratorMethod: () => string;
+    collectionDefinitions?: CollectionDefinition[];
+    permissionGroups?: PermissionGroup[];
+    authTriggers?: DatabaseTrigger[];
+    fileTriggers?: CmsTrigger[];
+};
+/**
+ * @param {Config} options
+ */
+export function setConfig(options: Config): void;
+/**
+ * @typedef {import('koa')} Koa
+ * @typedef {import('@koa/cors').Options} Cors
+ * @typedef {import('./class/collection_definition.js')} CollectionDefinition
+ * @typedef {import('./class/security.js').PermissionGroup} PermissionGroup
+ * @typedef {import('./class/cms_trigger.js')} CmsTrigger
+ */
+/**
+ * @typedef {{
+ *   cors?: Cors; // CORS options.
+ *   modulesPath?: string; // Root directory of your router.js/db.js files.
+ *   koaBodyOptions?: object; // Options for koa-body.
+ *    staticPath?: {
+ *        rootDir: string; // Root directory of your static files.
+ *        rootPath: string; // Root path of your static files, defaults to '/assets'.
+ *        maxage?: number; // Browser cache max-age in milliseconds. Defaults to 0.
+ *        hidden?: boolean; // Allow transfer of hidden files. Defaults to false.
+ *        index?: string; // Default file name. Defaults to 'index.html'.
+ *        defer?: boolean; // If true, serves after return next(), allowing any downstream middleware to respond first. Defaults to false.
+ *        gzip?: boolean; // Try to serve the gzipped version of a file automatically when gzip is supported by a client and if the requested file with .gz extension exists. Defaults to true.
+ *        br?: boolean; // Try to serve the brotli version of a file automatically when brotli is supported by a client and if the requested file with .br extension exists. Note that brotli is only accepted over https. Defaults to false.
+ *        setHeaders?: Function; // Function to set custom headers on response.
+ *        extensions?: boolean|Array; // Try to match extensions from passed array to search for file when no extension is suffixed in URL. First found is served. Defaults to false.
+ *    };
+ *   onBeforeInit?: (koaApp:Koa) => void; // A callback called before initializing the Koa server.
+ *   onAfterInit?: (koaApp:Koa) => void; // A callback called after server initialization.
+ *   port?: number; // Server port.
+ *   dontListen?: boolean; // If true, the server will not run and will only return the Koa app object.
+ *   mongo?: {
+ *     dbPrefix: string; // A prefix for your database name.
+ *     mongoBaseAddress: string; // The address of your MongoDB server without any database specification.
+ *     addressMap?: string; // Specific addresses for each database.
+ *   };
+ *   keypair?: {
+ *     private: string; // Private key for RSA authentication.
+ *     public: string; // Public key for RSA authentication.
+ *   };
+ *   adminUser?: {
+ *     email: string; // Admin user email.
+ *     password: string; // Admin user password.
+ *   };
+ *   verificationCodeGeneratorMethod: () => string; // A method to return a verification code when registering a new user.
+ *   collectionDefinitions?: CollectionDefinition[]; // An array of additional collection definitions.
+ *   permissionGroups?: PermissionGroup[]; // An array of additional permission groups.
+ *   authTriggers?: DatabaseTrigger[]; // An array of additional database triggers for the auth collection.
+ *   fileTriggers?: CmsTrigger[]; // An array of additional database triggers for the auth collection.
+ * }} Config
+ * @exports Config
+ */
+/**
+ * @type {Config}
+ */
+export const config: Config;

package/types/src/events.d.ts

@@ -0,0 +1,7 @@
+/**
+ * onBeforeInit: (koaApp:Koa) => void; // A callback called before initializing the Koa server.
+ * onAfterInit: (koaApp:Koa) => void; // A callback called after server initialization.
+ * onNewUser:
+ */
+declare function registerEventCallback(event: any, callback: any): void;
+declare const eventCallbacks: any[];

package/types/src/helper/data_insertion.d.ts

@@ -0,0 +1,4 @@
+export function createAdminUser({ email, password }: {
+    email: any;
+    password: any;
+}): Promise<never>;

package/types/src/helper/presetup_services.d.ts

@@ -0,0 +1,5 @@
+export function setup({ keypair, adminUser, uploadDirectory }: {
+    keypair: any;
+    adminUser: any;
+    uploadDirectory: any;
+}): Promise<void>;

package/types/src/index.d.ts

@@ -0,0 +1,72 @@
+declare const _exports: {
+    defineFunction: typeof defineFunction;
+    TypeCasters: {
+        ObjectId: import("mongoose").Types.ObjectIdConstructor;
+        Date: (dateValue: any) => Date;
+    };
+    validator: typeof validator;
+    reply: typeof reply;
+    paginator: typeof paginator;
+    getCollection: typeof getCollection;
+    getFile: (fileId: string) => Promise<any>;
+    getFileLink: (fileId: string) => Promise<any>;
+    getFilePath: (fileId: any) => Promise<string>;
+    removeFile: (fileId: string) => Promise<any>;
+    storeFile: ({ file, ownerId, tag, removeFileAfterStore }: {
+        file: {
+            path: string;
+            type: string;
+            name: string;
+            size: number;
+        };
+        ownerId: string;
+        tag: string;
+        removeFileAfterStore?: boolean;
+    }) => Promise<any>;
+    middleware: typeof middleware;
+    userManager: {
+        tempIds: {};
+        setCustomVerificationCodeGeneratorMethod(generatorMethod: Function): void;
+        verificationCodeGeneratorMethod: Function;
+        generateVerificationCode(id: string, idType: any): Promise<import("./class/user")>;
+        getUserById(id: string): Promise<import("./class/user")>;
+        getUserByIdentity(id: string, idType: string): Promise<import("./class/user")>;
+        getUserByToken(token: string): Promise<import("./class/user")>;
+        isCodeValid(id: string, code: string): boolean;
+        loginUser(id?: string, idType?: string, password?: string): Promise<string>;
+        issueTokenForUser(email: string): Promise<string>;
+        loginAnonymous(): Promise<string>;
+        registerTemporaryID(id: string, type: string, code: string): void;
+        submitPasswordForTemporaryID(id: string, password: string, code: string): Promise<boolean>;
+        changePasswordForTemporaryID(id: string, password: string, code: string): Promise<boolean>;
+        registerUser(detail: any): Promise<string>;
+        changePassword(query: any, newPass: string): Promise<void>;
+    };
+    AccessDefinition: typeof SecurityClass.AccessDefinition;
+    Permission: typeof SecurityClass.Permission;
+    PermissionTypes: typeof SecurityClass.PermissionTypes;
+    PermissionGroup: typeof SecurityClass.PermissionGroup;
+    AccessTypes: typeof SecurityClass.AccessTypes;
+    createRest: typeof createRest;
+    CollectionDefinition: typeof CollectionDefinition;
+    Schemas: {
+        file: Schema<import("mongoose").Document<any, any, any>, import("mongoose").Model<import("mongoose").Document<any, any, any>, any, any>, undefined, {}>;
+    };
+    Schema: typeof Schema;
+    DatabaseTrigger: typeof DatabaseTrigger;
+    CmsTrigger: typeof CmsTrigger;
+};
+export = _exports;
+import { defineFunction } from "./services/functions/service";
+import validator = require("./class/validator");
+import reply = require("./class/reply");
+import paginator = require("./class/paginator");
+import { getCollection } from "./services/data_provider/service";
+import middleware = require("./middlewares");
+import SecurityClass = require("./class/security");
+import createRest = require("./application");
+import CollectionDefinition = require("./class/collection_definition");
+import Schema_1 = require("mongoose");
+import Schema = Schema_1.Schema;
+import DatabaseTrigger = require("./class/database_trigger");
+import CmsTrigger = require("./class/cms_trigger");

package/types/src/middlewares.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Authentication middleware
+ * It checks if incoming request has a valid token in header.authorization
+ *
+ * @param {Object} ctx - Koa context
+ * @param {Function} next - Koa next function
+ * @returns {Promise<void>}
+ */
+export function auth(ctx: any, next: Function): Promise<void>;

package/types/src/services/data_provider/router.d.ts

@@ -0,0 +1,3 @@
+export let name: string;
+declare let dataProvider: any;
+export { dataProvider as main };