@xitkov/core 2.4.9

package/src/services/micro-service.ts

@@ -0,0 +1,188 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { BadRequest, InternalServer, NoContent, Unauthorized } from '../errors';
+import { Logger } from '../logger';
+
+export type MicroServiceQuery = {[key: string]: any};
+
+export interface InternalMicroServiceMethods {
+  find<T = any>(query: MicroServiceQuery, config?: IConfig<T>): Promise<T[]>;
+  get<T = any>(id: string | null, query?: MicroServiceQuery, config?: IConfig<T>): Promise<T | null>;
+  create<T = any, U = any>(data: Partial<U>, query?: MicroServiceQuery, config?: IConfig<T>): Promise<T | null>;
+  update<T = any, U = any>(id: string, data: U, query?: MicroServiceQuery, config?: IConfig<T>): Promise<T | null>;
+  patch<T = any, U = any>(id: string, data: Partial<U>, query?: MicroServiceQuery, config?: IConfig<T>): Promise<T | null>;
+  remove<T = any>(id: string, query?: MicroServiceQuery, config?: IConfig<T>): Promise<T | T[] | null>;
+  readonly request: AxiosInstance;
+  readonly call: AxiosInstance
+  readonly name: string;
+  readonly baseURL: string;
+  readonly service: string
+  readonly url: string
+}
+
+export interface InternalMicroServiceOptions {
+    axiosConfig?: AxiosRequestConfig;
+    name: string;
+    baseURL: string;
+    service: string
+}
+
+interface IExceptionConfig<T = any> {
+    handle?: boolean;
+    defaultValue?: Partial<T> | null;
+}
+
+interface IConfig<T = any> {
+    axiosConfig?: AxiosRequestConfig;
+    exception?: IExceptionConfig<T>;
+    /** @deprecated typo alias, use `exception` */
+    execption?: IExceptionConfig<T>;
+}
+
+export class MicroService implements InternalMicroServiceMethods {
+    readonly request: AxiosInstance
+    readonly name: string
+    readonly baseURL: string
+    readonly service: string
+    readonly url: string
+
+    constructor({ axiosConfig, name, service, baseURL }: InternalMicroServiceOptions) {
+        const providedAxiosConfig = (axiosConfig ?? {})
+        this.request = axios.create({ 
+            baseURL,
+            headers: {
+                InternalToken: process.env.INTERNAL_TOKEN ?? 'internal_token',
+                ...providedAxiosConfig.headers,
+            },
+            ...providedAxiosConfig,
+        })
+        this.name = name
+        this.baseURL = baseURL;
+        this.service = service
+        this.url = `/${service}`
+    }
+
+    throwError(err: any): Error {
+        const message = err?.response?.data?.message
+        const status = err?.response?.status
+        if (message) {
+            switch(status) {
+                case 401: return new Unauthorized(message)
+                case 400: return new BadRequest(message)
+                case 500: return new InternalServer(message)
+                case 204: return new NoContent(message)
+                default:  return new InternalServer(message)
+            }
+        }
+        return new InternalServer(err?.message ?? String(err))
+    }
+
+    async find<T = any>(query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T[]> {
+        const defaultValue: T[] = [];
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.get(`${this.url}`, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    async get<T = any>(id: string | null, query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T | null> {
+        const defaultValue = {};
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.get(`${this.url}/${id}`, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    async create<T = any, U = any>(payload: Partial<U>, query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T | null> {
+        const defaultValue = {};
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.post(`${this.url}`, payload, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    async update<T = any, U = any>(id: string, payload: U, query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T | null> {
+        const defaultValue = {};
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.put(`${this.url}/${id}`, payload, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    async patch<T = any, U = any>(id: string, payload: Partial<U>, query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T | null> {
+        const defaultValue = {};
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.patch(`${this.url}/${id}`, payload, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    async remove<T = any>(id: string, query?: MicroServiceQuery, config: IConfig<T> = {}): Promise<T | T[] | null> {
+        const defaultValue = {};
+        const { axiosConfig, exception } = this.getConfig(config, defaultValue);
+        try {
+            const { data } = await this.request.delete(`${this.url}/${id}`, { ...axiosConfig, params: query });
+            return data?.data ?? data
+        }
+        catch (err) {
+            return this.handleException(exception, defaultValue, err);
+        }
+    }
+
+    get call() {
+        return this.request
+    }
+
+    private getLog(err: any) {
+        const message = err?.response?.data?.message
+        const status = err?.response?.status
+        Logger.error(`Error ${this.name}`, {
+            message,
+            status,
+            url: this.url,
+            errorMessage: message ?? err?.message ?? err,
+            error: err?.response?.data ?? err?.response ?? err,
+        });
+    }
+
+    private getConfig(config: IConfig<any>, defaultValue: any) {
+        const src = config ?? {};
+        const axiosConfig = src.axiosConfig ?? {};
+        const exception = src.exception ?? src.execption ?? { defaultValue, handle: false };
+        return { axiosConfig, exception };
+    }
+    private handleException(exception: IExceptionConfig | undefined, defaultInitialValue: any, err: any) {
+        const { defaultValue = defaultInitialValue, handle = false } = exception ?? {};
+        if (handle) {
+            this.getLog(err);
+            return defaultValue;
+        }
+        throw this.throwError(err);
+    }
+}
+
+export interface IMicroService {
+    name: string;
+    baseURL: string;
+    config?: AxiosRequestConfig;
+    services: string[]
+}

package/src/services/register-micro-services.ts

@@ -0,0 +1,37 @@
+import {promises} from 'fs';
+import path from 'path';
+import { Logger } from '../logger';
+import { MicroService } from './micro-service';
+
+export async function registerMicroServices() {
+  if (require.main?.filename == undefined) {
+    throw new Error("Please provide service path")
+  }
+  const appDir = path.dirname(require.main?.filename as string);
+  const serviceDirPath = appDir + '/micro-services';
+
+  const servicesNames = (await promises.readdir(serviceDirPath)).filter(
+    file => !/^(index|types)\.(ts|js|d\.ts)$/.test(file) && !/\.map$/.test(file)
+  );
+
+  const services: any = {}
+
+  for (const serviceName of servicesNames) {
+    const servicePath = `${serviceDirPath}/${serviceName}`;
+    try {
+      const instance = new (require(servicePath).default)
+      if (instance) {
+        const { baseURL, name, services: subServicesNames, config } = instance
+        services[name] = services[name] ?? {}
+        subServicesNames?.forEach((subService: string) => {
+          services[name][subService] = new MicroService({ axiosConfig: config, name, service: subService, baseURL })
+        })
+      }
+    } catch(error) {
+      Logger.warn("No micro services", {
+        error
+      })
+    }
+  }
+  return services;
+}

package/src/services/register-services.ts

@@ -0,0 +1,268 @@
+import type {Application, Request, Response} from 'express';
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+import {promises} from 'fs';
+import path from 'path';
+import {Router} from 'express';
+import {Config, Dialect, IAuth, Logger, addQuerySupport} from '..';
+import {PostgresInternalServiceOptions, MongoInternalServiceOptions} from '.';
+import { BadRequest, Unauthorized } from '../errors';
+import { AuthService } from './auth';
+
+type Method = 'get' | 'post' | 'patch' | 'put' | 'delete';
+
+type Functions = 'find' | 'get' | 'create' | 'update' | 'patch' | 'remove';
+
+type InternalServiceOptions = (PostgresInternalServiceOptions | MongoInternalServiceOptions) & { dialect : Dialect };
+
+interface Methods {
+  method: Method;
+  url: string;
+  func: Functions;
+}
+
+async function validate(Validator: any, func: string, value: any) {
+  const schema = await Validator[func]
+  if (schema) {
+    try {
+      const schemaValue = await schema().validateAsync(value);
+      return schemaValue;
+    } catch (err: any) {
+      throw new BadRequest(err.message)
+    }
+  }
+  return value
+}
+
+async function hooks(Hooks: any, func: string, parameters: any[], methodName: string) {
+  const allHooks = Hooks[func]
+
+  allHooks?.forEach?.((hook: any) => {
+    hook?.(...parameters, methodName)
+  });
+  return allHooks
+}
+
+function getJWTDecoded(accessToken: string) {
+  try {
+    const base64Url = accessToken.split('.')[1];
+    const decoded = Buffer.from(base64Url, 'base64').toString()
+    return JSON.parse(decoded)
+  } catch(error) {
+    Logger.error("getJWTDecoded", error)
+    return {}
+  }
+}
+
+export async function registerServices(app: Application, auth?: IAuth, database?: Config['database']) {
+  if (require.main?.filename == undefined) {
+    throw new Error("Please provide service path")
+  }
+  const appDir = path.dirname(require.main?.filename as string);
+  const serviceDirPath = appDir + '/services';
+
+  const servicesNames = (await promises.readdir(serviceDirPath)).filter(
+    file => !/^index\.(ts|js|d\.ts)$/.test(file) && !/\.map$/.test(file)
+  );
+
+  const methods: Methods[] = [
+    {
+      method: 'get',
+      url: '/',
+      func: 'find',
+    },
+    {
+      method: 'get',
+      url: '/:id',
+      func: 'get',
+    },
+    {
+      method: 'post',
+      url: '/',
+      func: 'create',
+    },
+    {
+      method: 'patch',
+      url: '/:id',
+      func: 'patch',
+    },
+    {
+      method: 'put',
+      url: '/:id',
+      func: 'update',
+    },
+    {
+      method: 'delete',
+      url: '/:id',
+      func: 'remove',
+    },
+  ];
+
+  const services: {[serviceName: string]: any} = {}
+
+  for (const serviceName of servicesNames) {
+    const servicePath = `${serviceDirPath}/${serviceName}/service`;
+    const modelPath = `${serviceDirPath}/${serviceName}/model`;
+    const validatorPath = `${serviceDirPath}/${serviceName}/validator`;
+    const hooksPath = `${serviceDirPath}/${serviceName}/hooks`;
+    let Model = null
+    let Validator: any = null
+    let Hooks: any = null
+    try {
+        if(database?.instance) {
+          Model = (await import(modelPath)).default(database.instance);
+        } else {
+          Model = (await import(modelPath)).default;
+        }
+    } catch(err) {
+        //
+    }
+
+    try {
+      Validator = new (await import(validatorPath)).default;
+    } catch(err) {
+        //
+    }
+
+    try {
+      Hooks = new (await import(hooksPath)).default;
+    } catch(err) {
+        //
+    }
+    const serviceConfig: Partial<InternalServiceOptions> = {}
+   
+    if (Model) {
+      serviceConfig.Model = Model
+    }
+    serviceConfig.dialect = database?.dialect ?? 'mongodb'
+
+    const service = new (await import(servicePath)).default(serviceConfig);
+    services[serviceName] = service
+    const router = Router();
+    for (const {method, url, func} of methods) {
+      const callback = async (req: Request, res: Response) => {
+        const { required, baseURL } = auth ?? {}
+        const {params, query, body, baseUrl, ...rest} = req;
+
+        try {
+          if (service.auth !== false) {
+            // TODO: Temp will find the better solution later
+            if (req.headers['internaltoken'] !== (process.env.INTERNAL_TOKEN ?? 'internal_token')) {
+              if (required && baseURL) {
+                const authorization = req.headers['authorization']
+                if (!authorization) {
+                  throw new Unauthorized("You don't have permission")
+                }
+
+                const authService = new AuthService({ 
+                  baseURL: baseURL, 
+                  axiosConfig: {
+                    headers: {
+                      Authorization: authorization
+                    }
+                  }
+                })
+
+                const authData = await authService.verify()
+                const {businessId} = authData ?? {}
+                const decodedAccessToken = getJWTDecoded(authorization);
+                const { business } = decodedAccessToken;
+                const userBusinessId = businessId ?? business
+                if (!userBusinessId) {
+                  throw new Unauthorized("You don't have permission")
+                }
+              
+                const userData = ((req as any).user ?? {});
+                (req as any).user = { ...userData, userBusinessId }
+              }
+            }
+          }
+          
+          const user = (req as any).user
+          const {id} = params;
+          let parameters: any[] = [];
+          let validatorValue
+          switch (func) {
+            case 'find':
+              parameters = [query, user, req];
+              validatorValue = query
+              break;
+            case 'get':
+              parameters = [id, query, user, req];
+              validatorValue = query
+              break;
+            case 'create':
+              parameters = [body, query, user, req];
+              validatorValue = body
+              break;
+            case 'patch':
+              parameters = [id, body, query, user, req];
+              validatorValue = body
+              break;
+            case 'update':
+              parameters = [id, body, query, user, req];
+              validatorValue = body
+              break;
+            case 'remove':
+              parameters = [id, query, user, req];
+              validatorValue = query
+              break;
+          }
+          if (Hooks) {
+            await hooks(Hooks, 'all', parameters, func)
+            await hooks(Hooks, func, parameters, func)
+          }
+          if (service.filtering !== false && func === 'find') {
+            parameters[0] = addQuerySupport(...parameters, func)
+          }
+
+          if(service[func] == undefined) {
+            return res.status(404).send({
+              message: "Not found"
+            });
+          }
+          if (Validator) {
+            await validate(Validator, func, validatorValue)
+          }
+
+          const response = await service[func](...parameters)
+          let data: any = response
+          let count: number | undefined = undefined
+
+          if (func === 'find' && data && !Array.isArray(data) && data.rows) {
+            count = data.count
+            data = data.rows
+          } else if (response == null) {
+            if (id) {
+              return res.status(400).send({message: `No record found for ${id}`});
+            }
+            return res.status(400).send({message: 'Bad Request'});
+          }
+
+          return res.send({
+            message: "ok",
+            data,
+            count
+          });
+        } catch (error: any) {
+          Logger.error('Error', {
+            baseUrl,
+            url,
+            error,
+            message: error?.message
+          });
+          const status = error?.status
+          const message = error?.message
+          if (typeof status === 'number' && message) {
+            return res.status(status).send({ message });
+          }
+          return res.status(500).send({ message: 'Something went wrong' });
+        }
+      };
+      router[method](url, callback);
+    }
+    app.set('services', services)
+
+    app.use(`/${serviceName}`, router);
+  }
+  return services;
+}

package/src/services/service.ts

@@ -0,0 +1,118 @@
+import { Request, Response } from "express";
+import { Model as MongoModel } from "mongoose";
+import { ModelStatic as SequelizeModel} from 'sequelize'
+import { Dialect } from "..";
+import { FindResponse, InternalServiceMethods, MongoDBService, PostgreSQLService, Query, User } from './databases'
+
+/**
+ * Augment via:
+ *   declare module 'xitkov' {
+ *     interface XitkovConfig { dialect: 'postgres' }
+ *   }
+ */
+export interface XitkovConfig {}
+
+export type DefaultDialect = XitkovConfig extends { dialect: infer D }
+  ? D extends Dialect ? D : 'mongodb'
+  : 'mongodb';
+
+type ServiceType<T, U> =
+  U extends 'postgres'
+    ? PostgreSQLService<T>
+      : U extends 'mongodb'
+      ? MongoDBService<T>
+      : any;
+
+type ModelType<T, U> =
+      U extends 'postgres'
+        ? SequelizeModel<any>
+        : U extends "mongodb"
+          ? MongoModel<T>
+          : any
+
+export interface IXitovServiceProps {
+  Model: any;
+  dialect?: Dialect;
+  pagination?: boolean
+}
+
+export class XitkovService<T, U extends Dialect = DefaultDialect> implements InternalServiceMethods<T> {
+  private service: ServiceType<T, U>;
+  private Model: ModelType<T, U>
+  pagination?: boolean;
+
+  static defaultDialect: Dialect = 'mongodb';
+
+  static setDefaultDialect(dialect: Dialect) {
+    XitkovService.defaultDialect = dialect;
+  }
+
+  constructor({Model, dialect, pagination}: IXitovServiceProps) {
+    this.Model = Model;
+    const resolved = dialect ?? XitkovService.defaultDialect;
+    switch(resolved) {
+      case 'postgres':
+        this.service = new PostgreSQLService({ Model, pagination }) as any;
+        break;
+      case 'mongodb':
+      default:
+        this.service = new MongoDBService({ Model }) as any;
+    }
+  }
+
+  async find(query: Query, user?: any, req?: Request, res?: Response): Promise<FindResponse<T>> {
+    return await this.service.find(query, user, req, res);
+  }
+
+  async get(id: string | null, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.service.get(id, query, user, req, res);
+  }
+
+  async create(data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T>;
+  async create(data: Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T[]>;
+  async create(data: Partial<T> | Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[]> {
+    return this.service.create(data, query, user, req, res);
+  }
+
+  async update(id: string, data: T, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.service.update(id, data, query, user, req, res);
+  }
+
+  async patch(id: string, data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.service.patch(id, data, query, user, req, res);
+  }
+  
+  async remove(id: string, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.service.remove(id, query, user, req, res);
+  }
+
+  get model(): ModelType<T, U> {
+    return this.Model
+  }
+
+  async _find(query: Query, user?: any, req?: Request, res?: Response): Promise<FindResponse<T>> {
+    return await this.service.find(query, user, req, res);
+  }
+
+  async _get(id: string | null, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.service.get(id, query, user, req, res);
+  }
+
+  async _create(data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T>;
+  async _create(data: Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T[]>;
+  async _create(data: Partial<T> | Partial<T>[], query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[]> {
+    return this.service.create(data, query, user, req, res);
+  }
+
+  async _update(id: string, data: T, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | null> {
+    return await this.service.update(id, data, query, user, req, res);
+  }
+
+  async _patch(id: string, data: Partial<T>, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.service.patch(id, data, query, user, req, res);
+  }
+  
+  async _remove(id: string, query?: Query, user?: User, req?: Request, res?: Response): Promise<T | T[] | null> {
+    return await this.service.remove(id, query, user, req, res);
+  }
+}