@xitkov/core 2.4.9

package/src/hooks/business.ts

@@ -0,0 +1,23 @@
+interface IUser {
+  userBusinessId?: string;
+}
+
+export function setBusinessId(...params: any[]) {
+  const req = params[params.length - 2];
+  const hookName = params[params.length - 1];
+  const user: IUser = req?.user;
+  const { userBusinessId: businessId } = user ?? {};
+  let idx = 0;
+  if (/^(patch|update|remove|get)$/i.test(hookName)) {
+    idx = 1;
+  }
+  const target = params[idx];
+  if (target == null) return;
+  if (Array.isArray(target)) {
+    target.forEach(item => { if (item && typeof item === 'object') item.businessId = businessId });
+    return;
+  }
+  if (typeof target === 'object') {
+    target.businessId = businessId;
+  }
+}

package/src/hooks/hooks.ts

@@ -0,0 +1,60 @@
+import { Op } from "sequelize";
+import { NotFound, Unauthorized } from "../errors";
+import { Logger } from "../logger";
+
+export const disallow = () => {
+  throw new NotFound('Not Found')
+}
+
+export const externalDisallow = (...params: any[]) => {
+  const req = params[params.length - 2]
+  const internalToken = req.headers['internaltoken']
+  if (internalToken === (process.env.INTERNAL_TOKEN ?? 'internal_token')) {
+    Logger.info('externalDisallow', { internalToken })
+    return
+  }
+  throw new NotFound('Not Found')
+}
+
+export const loggedIn = (...params: any[]) => {
+  const req = params[params.length - 2]
+  const user = req?.user
+  if (!user) {
+    throw new Unauthorized("Logged in required")
+  }
+  return user;
+}
+
+export const addQuerySupport = (...params: any[]) => {
+  const hookName = params[params.length - 1];
+  let queryIndex = 0;
+
+  if (/^(create|patch|update|remove|get)$/i.test(hookName)) {
+    queryIndex = 1;
+  }
+
+  const query = params[queryIndex] ?? {};
+  const queryObj: any = {};
+  Object.keys(query).forEach(key => {
+    const value = query[key];
+    if (typeof value === 'object') {
+      let [conditionValue] = Object.values(value);
+      const [condition] = Object.keys(value);
+      const sequelizeOp = (Op as any)[condition.replace('$', '')];
+      try {
+        conditionValue = JSON.parse(conditionValue as any);
+      } catch (err) {
+        //
+      }
+      if (sequelizeOp) {
+        queryObj[key] = {
+          [sequelizeOp]: conditionValue,
+        };
+      }
+    } else {
+      queryObj[key] = value;
+    }
+  });
+  params[queryIndex] = queryObj;
+  return queryObj;
+}

package/src/hooks/index.ts

@@ -0,0 +1,3 @@
+export * from './hooks'
+export * from './types'
+export * from './business'

package/src/hooks/types.ts

@@ -0,0 +1,9 @@
+export interface HooksMethods {
+    readonly all?: Function[]
+    readonly find: Function[]
+    readonly get: Function[]
+    readonly create: Function[]
+    readonly patch: Function[]
+    readonly remove: Function[]
+    readonly update: Function[]
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from './services';
+export * from './errors';
+export * from './hooks';
+export * from './libs';
+export * from './logger';
+export * from './app';
+
+export interface ServiceTypes {
+    [service: string]: any
+}
+export interface MicroServiceNames {
+    [microService: string]: {
+        [service: string]: any;
+    };
+}
+export interface SubMicroServiceNames {
+    [service: string]: any;
+}

package/src/libs/cache.ts

@@ -0,0 +1,25 @@
+import {Redis} from 'ioredis';
+
+export class Cache {
+  static client: Redis;
+  static async set(key: string, value: any, expirationInSeconds = 600) {
+    await Cache.client.set(key, JSON.stringify(value));
+    await Cache.client.expire(key, expirationInSeconds);
+  }
+
+  static async get(key: string) {
+    const cacheData = await Cache.client.get(key);
+    if (!cacheData) {
+      return null;
+    }
+    const data = JSON.parse(cacheData);
+
+    return data;
+  }
+
+  static async delete(key: string) {
+    await Cache.client.del(key);
+  }
+
+}
+

package/src/libs/index.ts

@@ -0,0 +1,5 @@
+export * from './queue';
+export * from './socket';
+export * from './logs';
+export * from './utils';
+export * from './cache';

package/src/libs/logs.ts

@@ -0,0 +1,21 @@
+import winston from 'winston';
+import expressWinston from 'express-winston';
+
+export class InternalLogs {
+    static middleware(options?: Partial<expressWinston.LoggerOptions>) {
+        return expressWinston.logger({
+            transports: [
+              new winston.transports.Console()
+            ],
+            format: winston.format.combine(
+              winston.format.json(),
+            ),
+            meta: true, // optional: control whether you want to log the meta data about the request (default to true)
+            msg: "HTTP {{req.method}} {{req.url}}", // optional: customize the default logging message. E.g. "{{res.statusCode}} {{req.method}} {{res.responseTime}}ms {{req.url}}"
+            expressFormat: true, // Use the default Express/morgan request formatting. Enabling this will override any msg if true. Will only output colors with colorize set to true
+            colorize: false, // Color the text and status code, using the Express/morgan color palette (text: gray, status: default green, 3XX cyan, 4XX yellow, 5XX red).
+            ignoreRoute: function (req, res) { return false; }, // optional: allows to skip some log messages based on request and/or response
+            ...(options ?? {})
+        })
+    }
+}

package/src/libs/queue.ts

@@ -0,0 +1,48 @@
+import BullQueue from 'bull';
+import { Logger } from '../logger';
+
+export class Queue<T = any> {
+  readonly queue: BullQueue.Queue<T>;
+  private readonly queueName: string;
+  
+  constructor(name: string, redisUrl: string, opts: BullQueue.QueueOptions = {}) {
+    const defaultOpts: BullQueue.QueueOptions = {
+      limiter: {
+        duration: 50000,
+        max: 30,
+      },
+      ...opts
+    }
+    const env = process.env.ENVIRONMENT ?? 'dev';
+    let queueName = `${name}_${env}`
+    if (/prod/gi.test(env) && !/pre/gi.test(env)) {
+      queueName = name
+    }
+    this.queue = new BullQueue(queueName, redisUrl, defaultOpts);
+    this.queueName = queueName
+
+    this.queue.on('completed', function (job, result) {
+      const payload = { job, result }
+      Logger.info(`Completed ${queueName}: `, payload)
+    });
+    
+    this.queue.on('failed', async function (job, error) {
+      const payload = { job, error }
+      Logger.info(`Failed ${queueName}: `, payload)
+    });
+  }
+
+  async add(data: T, opts?: BullQueue.JobOptions) {
+    const options: BullQueue.JobOptions = {
+      removeOnComplete: true, // removes job from queue on success
+      removeOnFail: true, // removes job from queue on failure,
+      attempts: 1,
+      ...(opts ?? {})
+    }
+    return this.queue.add(data, options);
+  }
+
+  get consume() {
+    return this.queue.process;
+  }
+}

package/src/libs/socket.ts

@@ -0,0 +1,28 @@
+import type { DefaultEventsMap } from "socket.io/dist/typed-events";
+import { Server, Socket as SocketIO } from "socket.io";
+import { Logger } from "..";
+
+export class Socket {
+    static io: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>
+
+    static emit(eventName: string, data: any) {
+        return Socket.io.emit(eventName, data)
+    }
+
+    static on(eventName: string, cb: (...args: any[]) => void) {
+        return Socket.io.on(eventName, cb)
+    }
+
+    static client(cb: (socket: SocketIO<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>) => void, debug = false) {
+        Socket.io.on('connection', function(socket) {
+            if (debug) {
+                Logger.debug('Client Connected', socket.id);
+            }
+            cb(socket);
+            // Whenever someone disconnects this piece of code executed
+            socket.on('disconnect', function () {
+                Logger.debug('Client Disconnected', socket.id);
+            });
+        });
+    }
+}

package/src/libs/utils.ts

@@ -0,0 +1,28 @@
+/**
+ * Function to slice an array given a limit and offset
+ * @param array input array
+ * @param limit how many records to return
+ * @param offset offset to discard elements
+ * @returns sliced array or empty if input is null or has length = 0 or even if the params (limit/offset) exceeds the array length
+ */
+export function limitOffset<T>(array: T[], limit: string, offset: string): T[] {
+    if (!array) return [];
+  
+    const $limit = parseInt(limit, 10);
+    const $offset = parseInt(offset, 10);
+  
+    const length = array.length;
+  
+    if (!length) {
+      return [];
+    }
+    if ($offset > length - 1) {
+      return [];
+    }
+  
+    const start = Math.min(length - 1, $offset);
+    const end = Math.min(length, $offset + $limit);
+  
+    return array.slice(start, end);
+  }
+  

package/src/logger/index.ts

@@ -0,0 +1,49 @@
+import winston from 'winston';
+
+export type Level = "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly"
+
+export class Logger {
+  private static isLocalEnv = process.env.NODE_ENV === "local"
+  static readonly instance = winston.createLogger({
+    transports: [
+      new winston.transports.Console(),
+    ],
+    format: winston.format.combine(
+      winston.format.json()
+    ),
+    exitOnError: false,
+  });
+
+  static info(message: string, payload: any = {}) {
+    if (Logger.isLocalEnv) {
+      console.info(message, payload)
+      return
+    }
+    Logger.instance.info(message, payload);
+  }
+  static error(message: string, error: any) {
+    if (Logger.isLocalEnv) {
+      console.error(message, error)
+      return
+    }
+    Logger.instance.error(message, error);
+  }
+  static warn(message: string, data: any) {
+    if (Logger.isLocalEnv) {
+      console.warn(message, data)
+      return
+    }
+    Logger.instance.warn(message, data);
+  }
+  static debug(message: string, data: any) {
+    if (Logger.isLocalEnv) {
+      console.debug(message, data)
+      return
+    }
+    Logger.instance.debug(message, data);
+  }
+
+  static enableLogger() {
+    Logger.isLocalEnv = false
+  }
+}

package/src/services/auth.ts

@@ -0,0 +1,48 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { BadRequest, InternalServer, NoContent, Unauthorized } from '../errors';
+
+export type AuthServiceQuery = {[key: string]: any};
+
+export interface InternalAuthServiceMethods {
+  readonly request: AxiosInstance;
+  readonly baseURL: string;
+}
+
+export interface InternalAuthServiceOptions {
+    axiosConfig?: AxiosRequestConfig;
+    baseURL: string;
+}
+
+export class AuthService implements InternalAuthServiceMethods {
+    readonly request: AxiosInstance
+    readonly baseURL: string
+
+    constructor({ axiosConfig, baseURL }: InternalAuthServiceOptions) {
+        this.request = axios.create({ ...(axiosConfig ?? {}), baseURL,})
+        this.baseURL = baseURL;
+    }
+
+    throwError(err: any): never {
+        const message = err?.response?.data?.message
+        const status = err?.response?.status
+        if (message) {
+            switch(status) {
+                case 401: throw new Unauthorized(message)
+                case 400: throw new BadRequest(message)
+                case 500: throw new InternalServer(message)
+                case 204: throw new NoContent(message)
+                default:  throw new InternalServer(message)
+            }
+        }
+        throw new InternalServer(err?.message ?? String(err))
+    }
+
+    async verify<T = any>(query?: AuthServiceQuery, config: AxiosRequestConfig = {}): Promise<T> {
+        try {
+            const { data } = await this.request.post(`/verify`, undefined, { ...config, params: query })
+            return data?.data ?? data
+        } catch(err: any) {
+            this.throwError(err)
+        }
+    }
+}

package/src/services/databases/index.ts

@@ -0,0 +1,3 @@
+export * from './postgres-service';
+export * from './mongo-service';
+export * from './types';

package/src/services/databases/mongo-service.ts

@@ -0,0 +1,75 @@
+import { Request, Response } from "express";
+import { Model } from "mongoose";
+import type { InternalServiceMethods, Query, User } from "./types";
+
+export interface MongoInternalServiceMethods<T = any> extends InternalServiceMethods<T> {
+  model: Model<T>
+}
+
+export interface MongoInternalServiceOptions {
+  Model: Model<any>;
+}
+
+export class MongoDBService<T> implements MongoInternalServiceMethods<T> {
+  readonly Model: Model<any>;
+  constructor({Model}: MongoInternalServiceOptions) {
+    this.Model = Model;
+  }
+  async find(query?: Query, user?: User, req?: Request, res?: Response): Promise<T[]> {
+    return await this.Model.find(query ?? {})
+  }
+
+  async get(id: string | null, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.Model.findOne({
+      _id: id,
+      ...query
+    })
+  }
+
+  async create(data: Partial<T> | Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[]> {
+    return (await this.Model.create(data as any)).toJSON()
+  }
+
+  async update(id: string, data: T, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.Model.findOneAndUpdate({_id: id}, {$set: data as any}, {new:true}) as any;
+  }
+
+  async patch(id: string, data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.Model.findOneAndUpdate({_id: id}, {$set: data as any}, {new:true}) as any;
+  }
+  
+  async remove(id: string, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.Model.findOneAndDelete({_id: id, ...query});
+  }
+
+  get model() {
+    return this.Model
+  }
+
+  async _find(query?: Query): Promise<T[]> {
+    return await this.Model.find(query ?? {})
+  }
+
+  async _get(id: string | null, query?: Query): Promise<T | null> {
+    return await this.Model.findOne({
+      _id: id,
+      ...query
+    })
+  }
+
+  async _create(data: Partial<T> | Partial<T>[]): Promise<T | T[]> {
+    return (await this.Model.create(data as any)).toJSON()
+  }
+
+  async _update(id: string, data: T): Promise<T | null> {
+    return await this.Model.findOneAndUpdate({_id: id}, {$set: data as any}, {new:true}) as any;
+  }
+
+  async _patch(id: string, data: Partial<T>): Promise<T | T[] | null> {
+    return await this.Model.findOneAndUpdate({_id: id}, {$set: data as any}, {new:true}) as any;
+  }
+  
+  async _remove(id: string, query?: Query): Promise<T | T[] | null> {
+    return await this.Model.findOneAndDelete({_id: id, ...query});
+  }
+}

package/src/services/databases/postgres-service.ts

@@ -0,0 +1,149 @@
+import { Request, Response } from "express";
+import { ModelStatic, FindOptions, DestroyOptions } from 'sequelize'
+
+import { FindResponse, InternalServiceMethods, Query, User } from "./types";
+
+export interface PostgresInternalServiceMethods<T = any> extends InternalServiceMethods<any> {
+  model: ModelStatic<any>
+}
+
+export interface PostgresInternalServiceOptions<T = any> {
+  Model: ModelStatic<any>
+  pagination?: boolean
+}
+
+export class PostgreSQLService<T = any> implements PostgresInternalServiceMethods<T> {
+  protected readonly Model: ModelStatic<any>;
+  pagination?: boolean | undefined;
+  constructor({Model, pagination}: PostgresInternalServiceOptions<T>) {
+    this.Model = Model;
+    this.pagination = pagination
+  }
+  async find(query?: any, user?: User, req?: Request): Promise<FindResponse<T>> {
+    const { $limit, $offset, ...restQuery } = query ?? {}
+    const modelQuery: FindOptions<any> = {
+      where: {
+        ...(restQuery ?? {})
+      },
+    }
+    if ($limit) {
+      modelQuery.limit = $limit
+    }
+    if ($offset) {
+      modelQuery.offset = $offset
+    }
+    if (this.pagination) {
+      return await this.Model.findAndCountAll(modelQuery)
+    }
+    return await this.Model.findAll(modelQuery)
+  }
+
+  async get(id: string | null, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    if(id) {
+        return await this.Model.findByPk(id)
+    }
+    return await this.Model.findOne({
+       where: {
+        ...(query ?? {})
+       }
+    })
+  }
+
+  async create(data: Partial<T> | Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[]> {
+    return await this.Model.create(data as any) as any
+  }
+
+  async update(id: string, data: any, query?: Query, user?: User, req?: Request, res?: Response): Promise<any> {
+    return await this.Model.update({ ...data }, {
+        where: {
+            id,
+            ...(query ?? {})
+        },
+    });
+  }
+
+  async patch(id: string, data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<any> {
+    return await this.Model.update({ ...data }, {
+        where: {
+            id,
+            ...(query ?? {})
+        },
+    });
+  }
+  
+  async remove(id: string, query?: DestroyOptions, user?: User, req?: Request, res?: Response): Promise<any> {
+    return await this.Model.destroy({
+        where: {
+            id,
+            ...(query ?? {})
+        }
+    });
+  }
+
+  get model() {
+    return this.Model
+  }
+
+  async _find(query?: Query, user?: User, req?: Request): Promise<FindResponse<T>> {
+    const { $limit, $offset, ...restQuery } = query ?? {}
+    const modelQuery: FindOptions<any> = {
+      where: {
+        ...(restQuery ?? {})
+      },
+    }
+    if ($limit) {
+      modelQuery.limit = $limit
+    }
+    if ($offset) {
+      modelQuery.offset = $offset
+    }
+    if (this.pagination) {
+      return await this.Model.findAndCountAll(modelQuery)
+    }
+    return await this.Model.findAll(modelQuery)
+  }
+
+  async _get(id: string | null, query?: Query): Promise<T | null> {
+    if(id) {
+        return await this.Model.findByPk(id)
+    }
+    return await this.Model.findOne({
+      where: {
+        ...(query ?? {})
+      }
+    })
+  }
+
+  async _create(data: Partial<T> | Partial<T>[]): Promise<T | T[]> {
+    return await this.Model.create(data as any)
+  }
+
+  async _update(id: string, data: Partial<any>): Promise<any> {
+    const [, updatedData] = await this.Model.update({ ...data }, {
+        where: {
+            id
+        },
+        returning: true
+    });
+    return updatedData
+  }
+
+  async _patch(id: string, data: Partial<T>): Promise<any> {
+    const [, updatedData] = await this.Model.update({ ...data }, {
+        where: {
+          id
+        },
+        returning: true,
+    });
+    return updatedData
+  }
+  
+  async _remove(id: string, query?: Query): Promise<any> {
+    return await this.Model.destroy({
+        where: {
+            id,
+            ...(query ?? {})
+        }
+    });
+  }
+}

package/src/services/databases/types.ts

@@ -0,0 +1,29 @@
+import { Request, Response } from "express";
+
+
+export type Query = {[key: string]: any};
+
+export type User = any
+
+export type FindResponse<T> = T[] | {
+    rows: T[];
+    count: number;
+  }
+  
+export interface InternalServiceMethods<T = any> {
+    find(query: Query, user?: any, req?: Request, res?: Response): Promise<FindResponse<T>>;
+    get(id: string | null, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null>;
+    create(data: Partial<T> | Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[]>;
+    update(id: string, data: T, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null>;
+    patch(id: string, data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null>;
+    remove(id: string, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null>;
+    _find: InternalServiceMethods<T>['find']
+    _get: InternalServiceMethods<T>['get']
+    _create: InternalServiceMethods<T>['create']
+    _patch: InternalServiceMethods<T>['patch']
+    _update: InternalServiceMethods<T>['update']
+    _remove: InternalServiceMethods<T>['remove']
+    pagination?: boolean
+    filtering?: boolean
+    auth?: boolean
+}

package/src/services/index.ts

@@ -0,0 +1,6 @@
+export * from './service';
+export * from './micro-service';
+export * from './register-services';
+export * from './register-micro-services';
+export * from './auth';
+export * from './databases'