@xrystal/core 3.7.1 → 3.7.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.7.1",
+  "version": "3.7.4",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

package/source/utils/models/classes/class.controller.d.ts

@@ -1,4 +1,4 @@
-import { ProtocolEnum, ResponseSchema } from '../../index';
+import { ProtocolEnum } from '../../index';
 export interface CustomRequest {
     accounts?: any;
     query: Record<string, any>;
@@ -43,38 +43,32 @@ declare abstract class Controller {
     protected protocol: ProtocolEnum | null;
     protected req: CustomRequest | null;
     protected res: CustomResponse | null;
+    protected locals: Record<string, any>;
+    protected accounts: any;
+    protected startDate: string | null;
+    protected date: string | null;
+    protected dateStart: string | null;
+    protected endDate: string | null;
+    protected sort: Sort | null;
+    protected offset: string | null;
+    protected limit: string | null;
+    defaultLimitSize: number;
+    maxLimitSize: number;
     constructor({ protocol, req, res, ctx }: {
         protocol: ProtocolEnum;
         req?: any;
         res?: any;
         ctx?: any;
     });
-    protected responseProtocolSwitch: ({ protocol, req, res, resStatus, context }: {
-        protocol: ProtocolEnum;
-        req: CustomRequest;
-        res: CustomResponse;
-        resStatus?: number;
-        context: (helpers: {
-            localeLanguageConverter?: Function;
-        }) => ResponseSchema;
-    }) => Promise<any>;
+    protected responseProtocolSwitch: ({ res, resStatus, context, req }: any) => Promise<any>;
     protected parsedQuerys: (url: string) => Record<string, any>;
     protected log: (level: string, message: string) => Promise<void>;
 }
 export declare class ControllerSchema extends Controller {
     schema({ checks, logic, response, }: {
-        checks?: (args: {
-            payload: any;
-            convertedPayload: any;
-        }) => Promise<ReturnChecksCallbackFuncInterface | Array<any>>;
-        logic: (args: {
-            payload: any;
-            convertedPayload: any;
-        }) => Promise<ReturnLogicCallbackFuncInterface>;
-        response?: (args: {
-            payload: any;
-            convertedPayload: any;
-        }) => Promise<ReturnResponseCallbackFuncInterface>;
+        checks?: (args: any) => Promise<any>;
+        logic: (args: any) => Promise<any>;
+        response?: (args: any) => Promise<any>;
     }): Promise<any>;
 }
 export { Controller };

package/source/utils/models/classes/class.controller.js

@@ -1,18 +1,29 @@
 import qs from 'qs';
 import { LoggerService } from '../../../loader';
-import { responseMessageHelper, ResponseSchema, x } from '../../index';
+import { ProtocolEnum, responseMessageHelper, ResponseSchema, x } from '../../index';
 class Controller {
     logger = x.get(LoggerService);
     protocol = null;
     req = null;
     res = null;
+    locals = {};
+    accounts = null;
+    startDate = null;
+    date = null;
+    dateStart = null;
+    endDate = null;
+    sort = null;
+    offset = null;
+    limit = null;
+    defaultLimitSize = 20;
+    maxLimitSize = 100;
     constructor({ protocol, req, res, ctx }) {
         this.protocol = protocol;
         if (ctx) {
             this.req = {
-                url: ctx.request.url,
-                method: ctx.request.method,
-                headers: Object.fromEntries(ctx.request.headers),
+                url: ctx.request?.url || '',
+                method: ctx.request?.method || '',
+                headers: ctx.headers || (ctx.request?.headers ? Object.fromEntries(ctx.request.headers) : {}),
                 body: ctx.body,
                 params: ctx.params,
                 query: ctx.query || {},
@@ -20,20 +31,21 @@ class Controller {
                 t: ctx.t
             };
             this.res = {
-                locals: {},
-                status(code) {
+                locals: this.locals,
+                status: (code) => {
                     this.locals._code = code;
-                    return this;
+                    return this.res;
                 },
-                send(data) {
+                send: (data) => {
+                    if (this.protocol === ProtocolEnum.WEBSOCKET) {
+                        return data;
+                    }
                     return new Response(JSON.stringify(data), {
                         status: this.locals._code || 200,
                         headers: { 'content-type': 'application/json' }
                     });
                 },
-                json(data) {
-                    return this.send(data);
-                }
+                json: (data) => this.res.send(data)
             };
         }
         else {
@@ -47,30 +59,37 @@ class Controller {
                 accounts: req?.accounts,
                 t: req?.t
             };
+            this.locals = res?.locals || {};
             this.res = {
-                locals: res?.locals || {},
-                status(code) {
-                    res.status(code);
-                    return this;
+                locals: this.locals,
+                status: (code) => {
+                    if (res && typeof res.status === 'function') {
+                        res.status(code);
+                    }
+                    return this.res;
                 },
-                send(data) {
-                    return res.send(data);
+                send: (data) => {
+                    if (res && typeof res.send === 'function') {
+                        return res.send(data);
+                    }
+                    return data;
                 },
-                json(data) {
-                    return res.json(data);
+                json: (data) => {
+                    if (res && typeof res.json === 'function') {
+                        return res.json(data);
+                    }
+                    return data;
                 }
             };
         }
     }
-    responseProtocolSwitch = async ({ protocol, req, res, resStatus = 200, context }) => {
+    responseProtocolSwitch = async ({ res, resStatus = 200, context, req }) => {
         const responseData = context({ localeLanguageConverter: req.t });
         return res.status(resStatus).send(responseData);
     };
     parsedQuerys = (url) => {
         const queryString = url.includes('?') ? url.split('?')[1] : '';
-        if (!queryString)
-            return {};
-        return qs.parse(queryString, { decoder: decodeURIComponent });
+        return queryString ? qs.parse(queryString, { decoder: decodeURIComponent }) : {};
     };
     log = async (level, message) => {
         this.logger.winston.log({ level, message });
@@ -92,7 +111,6 @@ export class ControllerSchema extends Controller {
                 }
                 else if (typeof checkResult === 'object' && checkResult.message) {
                     return await this.responseProtocolSwitch({
-                        protocol: this.protocol,
                         req: this.req,
                         res: this.res,
                         context: () => new ResponseSchema({
@@ -105,7 +123,6 @@ export class ControllerSchema extends Controller {
                 }
                 if (isInvalid) {
                     return await this.responseProtocolSwitch({
-                        protocol: this.protocol,
                         req: this.req,
                         res: this.res,
                         resStatus: 400,
@@ -122,7 +139,6 @@ export class ControllerSchema extends Controller {
             }
             if (logicResult.message) {
                 return await this.responseProtocolSwitch({
-                    protocol: this.protocol,
                     req: this.req,
                     res: this.res,
                     resStatus: 400,
@@ -140,7 +156,6 @@ export class ControllerSchema extends Controller {
                     return resResult.response(resResult);
                 }
                 return await this.responseProtocolSwitch({
-                    protocol: this.protocol,
                     req: this.req,
                     res: this.res,
                     resStatus: 200,
@@ -154,10 +169,7 @@ export class ControllerSchema extends Controller {
         }
         catch (error) {
             await this.log('error', `Schema Error: ${error.message}`);
-            return this.res.status(500).send({
-                status: false,
-                message: error.message
-            });
+            return this.res.status(500).send({ status: false, message: error.message });
         }
     }
 }

package/source/utils/models/enums/index.d.ts

@@ -41,6 +41,12 @@ export declare enum ContentTypeEnum {
     applicationJson = "application/json",
     applicationXWwwFormUrlencoded = "application/x-www-form-urlencoded"
 }
+export declare enum DeviceStatusEnum {
+    PENDING = 0,
+    OFFLINE = 1,
+    ONLINE = 2,
+    AUTHED = 2
+}
 export declare enum DevicePlatformEnum {
     WEB = "web",
     NATIVE = "native",

package/source/utils/models/enums/index.js

@@ -49,6 +49,13 @@ export var ContentTypeEnum;
     ContentTypeEnum["applicationJson"] = "application/json";
     ContentTypeEnum["applicationXWwwFormUrlencoded"] = "application/x-www-form-urlencoded";
 })(ContentTypeEnum || (ContentTypeEnum = {}));
+export var DeviceStatusEnum;
+(function (DeviceStatusEnum) {
+    DeviceStatusEnum[DeviceStatusEnum["PENDING"] = 0] = "PENDING";
+    DeviceStatusEnum[DeviceStatusEnum["OFFLINE"] = 1] = "OFFLINE";
+    DeviceStatusEnum[DeviceStatusEnum["ONLINE"] = 2] = "ONLINE";
+    DeviceStatusEnum[DeviceStatusEnum["AUTHED"] = 2] = "AUTHED";
+})(DeviceStatusEnum || (DeviceStatusEnum = {}));
 export var DevicePlatformEnum;
 (function (DevicePlatformEnum) {
     DevicePlatformEnum["WEB"] = "web";