@ccci/micro-server 0.0.38 → 0.0.39

package/dist/decorators/Endpoints.d.ts

@@ -0,0 +1,12 @@
+export declare const endpoint: (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
+export declare const PublicAccess: <T extends new (...args: any[]) => {}>(constructor: T) => {
+    new (...args: any[]): {
+        grantPublicAccess: boolean;
+    };
+} & T;
+export declare const PrivateAccess: <T extends new (...args: any[]) => {}>(constructor: T) => {
+    new (...args: any[]): {
+        grantPublicAccess: boolean;
+    };
+} & T;
+//# sourceMappingURL=Endpoints.d.ts.map

package/dist/types/BaseControllerTypes.d.ts

@@ -0,0 +1,39 @@
+import { Order, WhereOptions } from "sequelize";
+export type RequestQuery = {
+    search?: string;
+    limit?: number;
+    page?: number;
+    includes?: string;
+    fields?: string;
+    sort?: string;
+    paginate?: string;
+    date_range?: string;
+    others?: any;
+    scan?: string;
+};
+export type QueryOptions = {
+    where?: WhereOptions<any>;
+    limit?: number;
+    offset?: number;
+    attributes?: Array<string>;
+    order?: Order;
+    includes?: Array<string | IncludeType>;
+};
+export type ResponseType = {
+    success: boolean;
+    error?: number;
+    statusCode?: number;
+    errorMessage?: string;
+    errorDescription?: string;
+    response?: object;
+    version?: string;
+    errors?: string[];
+};
+export type IncludeType = {
+    association?: string;
+    include?: Array<IncludeType>;
+};
+export type CommonType = {
+    [x: string | symbol]: any;
+};
+//# sourceMappingURL=BaseControllerTypes.d.ts.map

package/dist/types/BaseModelTypes.d.ts

@@ -0,0 +1,33 @@
+export declare enum FindTypeEnum {
+    FIND_ALL = "findAndCountAll",
+    FIND_PK = "findByPk",
+    FIND_ONE = "findOne",
+    COUNT = "count"
+}
+export type IncludesType = {
+    path?: string;
+    association?: AssociationType;
+};
+export type AssociationType = {
+    include: Array<string> | Array<object>;
+    association?: string;
+    where?: object;
+};
+export type QueryType = {
+    where?: object;
+    limit?: number;
+    offset?: number;
+    select?: object;
+    order?: object;
+    attributes?: object;
+    returning?: boolean;
+    raw?: boolean;
+    nest?: boolean;
+    distinct?: string;
+    include?: object;
+};
+export type RequestUserType = {
+    id?: number;
+    email?: string;
+};
+//# sourceMappingURL=BaseModelTypes.d.ts.map

package/dist/types/BaseRouterTypes.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from 'express';
+import { ResponseType } from './BaseControllerTypes';
+export type Mappings = {
+    path: string;
+    method: string;
+    function: (req: Request, res: Response, next: NextFunction) => Promise<void | ResponseType>;
+    middleware?: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+//# sourceMappingURL=BaseRouterTypes.d.ts.map

package/dist/utils/ApplicationServer.d.ts

@@ -0,0 +1,9 @@
+export default class ApplicationServer {
+    /**
+     * Initializes the application server
+     * @param path root directory
+     * @param port port for the micro service
+     */
+    static bootstrap(path: string, port: number): Promise<void>;
+}
+//# sourceMappingURL=ApplicationServer.d.ts.map

package/dist/utils/BaseController.d.ts

@@ -0,0 +1,76 @@
+import { Request, Response, NextFunction } from 'express';
+import { ResponseType } from '../types/BaseControllerTypes';
+export default class BaseController {
+    protected _model: import("sequelize").ModelCtor<import("sequelize").Model<any, any>> | undefined;
+    _modelName: string | undefined;
+    protected broadcastOnCreate: boolean;
+    protected broadcastOnUpdate: boolean;
+    protected broadcastOnDelete: boolean;
+    constructor(model?: string);
+    /**
+     * Find all the rows matching your query, within a specified offset / limit,
+     * and get the total number of rows matching your query.
+     * ```js
+     * Controller.find(req, res, next)
+     * ```
+     * @param req
+     * @param res
+     * @param next
+     */
+    find(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Search for a single instance by its primary key.
+     * This applies LIMIT 1, so the listener will always be called with a single instance.
+     * @param req
+     * @param res
+     * @param next
+     */
+    findById(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    create(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Update multiple instances that match the where options. The promise returns an array with one or two elements. The first element is always the number of affected rows, while the second element is the actual affected rows (only supported in postgres and mssql with options.returning true.)
+     * @param req
+     * @param res
+     * @param next
+     */
+    update(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Delete multiple instances, or set their deletedAt timestamp to the current time if paranoid is enabled.
+     * @param req
+     * @param res
+     * @param next
+     */
+    delete(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Find all the rows matching your query, within a specified offset / limit,
+     * and get the total number of rows matching your query.
+     * ```js
+     * Controller.find(req, res, next)
+     * ```
+     * @param req
+     * @param res
+     * @param next
+     */
+    archives(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    restore(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * ###############################################################
+     * ###################### LIFE CYCLE HOOKS #######################
+     * ###############################################################
+     */
+    beforeCreate(req: Request): Promise<void>;
+    afterCreate(req: Request, rec: any): Promise<void>;
+    beforeUpdate(req: Request): Promise<void>;
+    afterUpdate(req: Request, rec: any, orig: any): Promise<void>;
+    beforeDelete(req: Request): Promise<void>;
+    afterDelete(req: Request, rec: any): Promise<void>;
+    beforeFind(req: Request): Promise<void>;
+    afterFind(req: Request): Promise<void>;
+}
+//# sourceMappingURL=BaseController.d.ts.map

package/dist/utils/BaseControllerHelper.d.ts

@@ -0,0 +1,7 @@
+import { BaseError, UniqueConstraintError } from "sequelize";
+import { RequestQuery, QueryOptions, ResponseType } from "../types/BaseControllerTypes";
+export declare function ConstructQuery(query: RequestQuery): QueryOptions;
+export declare function ResponseHelper(response?: any): ResponseType;
+export declare function ErrorResponseHandler(error: UniqueConstraintError | BaseError | Error | any): ResponseType;
+export { ResponseType };
+//# sourceMappingURL=BaseControllerHelper.d.ts.map

package/dist/utils/BaseModel.d.ts

@@ -0,0 +1,27 @@
+import { DataTypes, Model } from 'sequelize';
+import type { ModelAttributes } from "sequelize";
+import type IBaseModel from './IBaseModel';
+export default class BaseModel extends Model implements IBaseModel {
+    id?: number;
+    /**
+     * Sets common model attributes
+     * @returns
+     */
+    static getCommonAttributes(): {
+        createdById: {
+            type: DataTypes.IntegerDataType;
+            comment: string;
+        };
+        updatedById: {
+            type: DataTypes.IntegerDataType;
+            comment: string;
+        };
+        isActive: {
+            type: DataTypes.AbstractDataType;
+            comment: string;
+        };
+    };
+    static getCommonAssociations(): void;
+    static initialize(fields: ModelAttributes, name: string): void;
+}
+//# sourceMappingURL=BaseModel.d.ts.map

package/dist/utils/BaseRouter.d.ts

@@ -0,0 +1,77 @@
+import { Request, Response, NextFunction, Router } from 'express';
+import BaseController from './BaseController';
+import { Mappings } from '../types/BaseRouterTypes';
+export default class BaseRouter<T extends BaseController> {
+    grantPublicAccess: boolean;
+    controller: T;
+    /**
+     *
+     * @param {Controller} controller
+     */
+    constructor(controller: T);
+    /**
+     * @description GET route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    get(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description GET ARCHIVES route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    archives(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description POST route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    post(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description GET route (/:id)
+     * @param {HttpRequest} req
+     * @param {HttpResponse} res
+     * @param {*} next
+     */
+    getId(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description PUT route (/:id)
+     * @param {HttpRequest} req
+     * @param {HttpResponse} res
+     * @param {*} next
+     */
+    update(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    delete(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    restore(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description default mappings that will be inherited across all router class
+     * @returns {Array} mappings
+     */
+    getMapping: () => Mappings[];
+    /**
+     * @description additional mappings placeholder, designed to be overriden
+     * @returns {Array} mappings
+     */
+    getAdditionalMapping: () => Mappings[];
+    /**
+     * @description create the express router
+     * @returns {Router} router
+     */
+    getRoutes(): Router;
+}
+//# sourceMappingURL=BaseRouter.d.ts.map

package/dist/utils/DatabaseConnector.d.ts

@@ -0,0 +1,22 @@
+import { Model, ModelStatic, Sequelize } from "sequelize";
+export default class DatabaseConnector {
+    private static connections;
+    private static connection;
+    private static rootDir;
+    constructor(path: string);
+    /**
+     *
+     * @param path
+     */
+    static init(): Promise<Array<Sequelize>>;
+    /**
+     *
+     * @param path root dir
+     */
+    initializeModels(): Promise<void>;
+    getConnections(): Array<Sequelize>;
+    static getConnection(): Sequelize;
+    connect(connection: Sequelize): Promise<void>;
+    static getModel(modelName: string): ModelStatic<Model>;
+}
+//# sourceMappingURL=DatabaseConnector.d.ts.map

package/dist/utils/ErrorHandler.d.ts

@@ -0,0 +1,5 @@
+export default class ErrorHandler extends Error {
+    statusCode: number | undefined;
+    constructor(message?: string, statusCode?: number);
+}
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/dist/utils/IBaseModel.d.ts

@@ -0,0 +1,9 @@
+export default interface IBaseModel {
+    id?: number;
+    createdById?: number;
+    updatedById?: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    _search?: string;
+}
+//# sourceMappingURL=IBaseModel.d.ts.map

package/dist/utils/Logger.d.ts

@@ -0,0 +1,7 @@
+export default class Logger {
+    static info(message: string): void;
+    static error(error: Error): void;
+    static warn(message: string): void;
+    static debug(message: string): void;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/RouterFactory.d.ts

@@ -0,0 +1,12 @@
+import { Application, Request, Response, NextFunction } from 'express';
+export default class RouterFactory {
+    /**
+     *
+     * @param app express application instance
+     * @param pathName root path of the application
+     * @param folderName path of the routers (default: routes)
+     */
+    constructor(app: Application, pathName: string, folderName?: string, context?: string);
+    authenticate(req: Request, res: Response, next: NextFunction, grantPublicAccess?: boolean): Response<any, Record<string, any>> | undefined;
+}
+//# sourceMappingURL=RouterFactory.d.ts.map

package/dist/utils/TokenGenerator.d.ts

@@ -0,0 +1,11 @@
+import { Request } from 'express';
+import { RequestUserType } from '../types/BaseModelTypes';
+/**
+ * generate jwt token from the payload
+ * @param payload
+ * @returns
+ */
+export declare function generate(payload: object): string;
+export declare function verify(token: string): RequestUserType;
+export declare function decode(val: string | Request): RequestUserType;
+//# sourceMappingURL=TokenGenerator.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccci/micro-server",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "module": "index.ts",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,9 @@
   "license": "MIT",
   "files": [
     "dist/*.js",
-    "dist/*.d.ts"
+    "dist/*.d.ts",
+    "dist/*/*.js",
+    "dist/*/*.d.ts"
   ],
   "dependencies": {
     "cors": "^2.8.5",