@grandlinex/kernel 0.30.2 → 0.31.0

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kernel = exports.KernelModule = void 0;
+/**
+ * @name Kernel Main Module
+ * @author David Nagy
+ */
+const Kernel_js_1 = __importDefault(require("./Kernel.js"));
+exports.Kernel = Kernel_js_1.default;
+const KernelModule_js_1 = __importDefault(require("./KernelModule.js"));
+exports.KernelModule = KernelModule_js_1.default;
+__exportStar(require("./actions/index.js"), exports);
+__exportStar(require("./api/index.js"), exports);
+__exportStar(require("./classes/index.js"), exports);
+__exportStar(require("./modules/crypto/index.js"), exports);
+__exportStar(require("./lib/index.js"), exports);
+__exportStar(require("./lib/express.js"), exports);
+__exportStar(require("@grandlinex/core"), exports);
+exports.default = Kernel_js_1.default;

package/dist/cjs/lib/express.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{lib → cjs/lib}/index.d.ts

@@ -1,22 +1,22 @@
 import { ICoreAction, ICoreBridge, ICoreCache, ICoreCClient, ICoreClient, ICoreElement, ICoreKernel, ICoreKernelModule, ICorePresenter, ICoreService, IDataBase } from '@grandlinex/core';
 import express from 'express';
 import * as jwt from 'jsonwebtoken';
-import { IAuthProvider, JwtToken, IExtensionInterface } from '../classes/index.js';
+import { IAuthProvider, JwtToken, IExtensionInterface, JwtExtend } from '../classes/index.js';
 import { XNextFc, XRequest, XResponse } from './express.js';
 export type ActionTypes = 'POST' | 'GET' | 'USE' | 'PATCH' | 'DELETE';
-export interface ICClient extends ICoreCClient {
-    setAuthProvider(provider: IAuthProvider): boolean;
-    jwtVerifyAccessToken(token: string): Promise<JwtToken | number>;
+export interface ICClient<T extends JwtExtend = JwtExtend> extends ICoreCClient {
+    setAuthProvider(provider: IAuthProvider<T>): boolean;
+    jwtVerifyAccessToken(token: string): Promise<JwtToken<T> | number>;
     jwtDecodeAccessToken(token: string): jwt.JwtPayload | null;
-    jwtGenerateAccessToken(data: JwtToken, expire?: string | number): string;
+    jwtGenerateAccessToken(data: JwtToken<T>, expire?: string | number): Promise<string>;
     apiTokenValidation(username: string, token: string, requestType: string): Promise<{
         valid: boolean;
         userId: string | null;
     }>;
-    permissionValidation(token: JwtToken, requestType: string): Promise<boolean>;
-    bearerTokenValidation(req: XRequest): Promise<JwtToken | number>;
+    permissionValidation(token: JwtToken<T>, requestType: string): Promise<boolean>;
+    bearerTokenValidation(req: XRequest): Promise<JwtToken<T> | number>;
 }
-export interface IKernel extends ICoreKernel<ICClient> {
+export interface IKernel<T extends JwtExtend = JwtExtend> extends ICoreKernel<ICClient<T>> {
     getAppServerPort(): number;
     setAppServerPort(port: number): void;
     responseCodeFunction(data: {

package/dist/cjs/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/modules/crypto/CryptoClient.d.ts

@@ -0,0 +1,20 @@
+import { CoreCryptoClient } from '@grandlinex/core';
+import { ICClient, IKernel } from '../../lib/index.js';
+import { IAuthProvider, JwtExtend, JwtToken } from '../../classes/index.js';
+import { XRequest } from '../../lib/express.js';
+export default class CryptoClient<T extends JwtExtend = JwtExtend> extends CoreCryptoClient implements ICClient<T> {
+    protected authProvider: IAuthProvider<T> | null;
+    protected kernel: IKernel;
+    protected expiresIn: string;
+    constructor(key: string, kernel: IKernel);
+    setAuthProvider(provider: IAuthProvider<T>): boolean;
+    jwtVerifyAccessToken(token: string): Promise<JwtToken<T> | number>;
+    jwtDecodeAccessToken(token: string): JwtToken<T> | null;
+    jwtGenerateAccessToken(data: JwtToken<T>, expire?: string | number): Promise<string>;
+    apiTokenValidation(username: string, token: string, requestType: string): Promise<{
+        valid: boolean;
+        userId: string | null;
+    }>;
+    permissionValidation(token: JwtToken<T>, requestType: string): Promise<boolean>;
+    bearerTokenValidation(req: XRequest): Promise<JwtToken<T> | number>;
+}

package/dist/cjs/modules/crypto/CryptoClient.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@grandlinex/core");
+const jwt = __importStar(require("jsonwebtoken"));
+class CryptoClient extends core_1.CoreCryptoClient {
+    constructor(key, kernel) {
+        super(kernel, key);
+        this.kernel = kernel;
+        this.authProvider = null;
+        this.expiresIn = kernel.getConfigStore().get('JWT_EXPIRE') || '1 days';
+    }
+    setAuthProvider(provider) {
+        if (this.authProvider) {
+            return false;
+        }
+        this.authProvider = provider;
+        return true;
+    }
+    jwtVerifyAccessToken(token) {
+        return new Promise((resolve) => {
+            jwt.verify(token, this.AesKey, (err, user) => {
+                if (err instanceof jwt.TokenExpiredError) {
+                    resolve(498);
+                }
+                else if (err || user === null) {
+                    resolve(403);
+                }
+                else {
+                    resolve(user);
+                }
+            });
+        });
+    }
+    jwtDecodeAccessToken(token) {
+        // MSJ-CJS SWITCH
+        const mod = jwt.default || jwt;
+        return mod.decode(token, { json: true });
+    }
+    async jwtGenerateAccessToken(data, expire) {
+        let sData;
+        if (this.authProvider) {
+            sData = await this.authProvider.jwtAddData(data);
+        }
+        else {
+            sData = data;
+        }
+        return jwt.sign(sData, this.AesKey, {
+            expiresIn: expire ?? this.expiresIn,
+        });
+    }
+    async apiTokenValidation(username, token, requestType) {
+        if (this.authProvider) {
+            return this.authProvider.authorizeToken(username, token, requestType);
+        }
+        const store = this.kernel.getConfigStore();
+        const cc = this.kernel.getCryptoClient();
+        if (!store.has('SERVER_PASSWORD')) {
+            return { valid: false, userId: null };
+        }
+        if (cc?.timeSavePWValidation(token, store.get('SERVER_PASSWORD') || '') ||
+            (token === store.get('SERVER_PASSWORD') && username === 'admin')) {
+            return {
+                valid: true,
+                userId: 'admin',
+            };
+        }
+        return {
+            valid: false,
+            userId: null,
+        };
+    }
+    async permissionValidation(token, requestType) {
+        if (this.authProvider) {
+            return this.authProvider.validateAccess(token, requestType);
+        }
+        return false;
+    }
+    async bearerTokenValidation(req) {
+        if (this.authProvider) {
+            return this.authProvider.bearerTokenValidation(req);
+        }
+        const authHeader = req.headers.authorization;
+        const token = authHeader && authHeader.split(' ')[1];
+        if (!token) {
+            return 401;
+        }
+        const tokenData = await this.jwtVerifyAccessToken(token);
+        if (tokenData) {
+            return tokenData;
+        }
+        return 403;
+    }
+}
+exports.default = CryptoClient;

package/dist/cjs/modules/crypto/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoClient = void 0;
+const CryptoClient_js_1 = __importDefault(require("./CryptoClient.js"));
+exports.CryptoClient = CryptoClient_js_1.default;
+__exportStar(require("./utils/cors.js"), exports);

package/dist/cjs/modules/crypto/utils/cors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cors = void 0;
+const cors = (req, res, next) => {
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', '*');
+    next();
+};
+exports.cors = cors;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/mjs/Kernel.d.ts

@@ -0,0 +1,28 @@
+import { CoreLogger, CoreKernel } from '@grandlinex/core';
+import { ICClient, IKernel } from './lib/index.js';
+import { XRequest } from './lib/express.js';
+/**
+ *  @class Kernel
+ */
+export default class Kernel extends CoreKernel<ICClient> implements IKernel {
+    private expressPort;
+    /**
+     * Default Constructor
+     * @param options App Name
+     */
+    constructor(options: {
+        appName: string;
+        appCode: string;
+        pathOverride?: string;
+        portOverride?: number;
+        envFilePath?: string;
+        loadFromLocalEnv?: boolean;
+        logger?: (k: CoreKernel<any>) => CoreLogger;
+    });
+    getAppServerPort(): number;
+    setAppServerPort(port: number): void;
+    responseCodeFunction(data: {
+        code: number;
+        req: XRequest;
+    }): void;
+}

package/dist/mjs/KernelModule.d.ts

@@ -0,0 +1,8 @@
+import { InMemCache } from '@grandlinex/core';
+import BaseKernelModule from './classes/BaseKernelModule.js';
+import { IKernel } from './lib/index.js';
+import KernelEndpoint from './api/KernelEndpoint.js';
+export default class KernelModule extends BaseKernelModule<IKernel, null, null, InMemCache, KernelEndpoint> {
+    constructor(kernel: IKernel);
+    initModule(): Promise<void>;
+}

package/dist/mjs/actions/ApiAuthTestAction.d.ts

@@ -0,0 +1,11 @@
+import { IBaseKernelModule } from '../lib/index.js';
+import { BaseApiAction, JwtToken } from '../classes/index.js';
+import { XRequest, XResponse } from '../lib/express.js';
+/**
+ * @name ApiAuthTestAction
+ *
+ */
+export default class ApiAuthTestAction extends BaseApiAction {
+    constructor(module: IBaseKernelModule<any, any, any, any>);
+    handler(req: XRequest, res: XResponse, next: () => void, data: JwtToken): Promise<void>;
+}

package/dist/mjs/actions/ApiVersionAction.d.ts

@@ -0,0 +1,11 @@
+import { IBaseKernelModule } from '../lib/index.js';
+import { BaseApiAction, IExtensionInterface } from '../classes/index.js';
+import { XRequest, XResponse } from '../lib/express.js';
+/**
+ * @name ApiVersionAction
+ *
+ */
+export default class ApiVersionAction extends BaseApiAction {
+    constructor(module: IBaseKernelModule);
+    handler(req: XRequest, res: XResponse, next: () => void, data: any, ex: IExtensionInterface): Promise<void>;
+}

package/dist/mjs/actions/GetTokenAction.d.ts

@@ -0,0 +1,11 @@
+import { IBaseKernelModule } from '../lib/index.js';
+import { BaseApiAction, IExtensionInterface } from '../classes/index.js';
+import { XRequest, XResponse } from '../lib/express.js';
+export default class GetTokenAction extends BaseApiAction {
+    /**
+     *
+     * @param module Parent Module
+     */
+    constructor(module: IBaseKernelModule<any, any, any, any>);
+    handler(req: XRequest, res: XResponse, next: () => void, data: any, ex: IExtensionInterface): Promise<void>;
+}

package/dist/{actions → mjs/actions}/GetTokenAction.js

@@ -1,36 +1,4 @@
 import { BaseApiAction, ActionMode, } from '../classes/index.js';
-/**
- * @openapi
- * /token:
- *   post:
- *     summary: Get Bearer for user.
- *     tags:
- *       - Kernel
- *     description: Returns JWT.
- *     responses:
- *       '200':
- *         description: OK
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 token:
- *                   type: string
- *       '403':
- *         description: Not Authorized
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               username:
- *                 type: string
- *               token:
- *                 type: string
- */
 export default class GetTokenAction extends BaseApiAction {
     /**
      *
@@ -54,7 +22,7 @@ export default class GetTokenAction extends BaseApiAction {
         const { username, token } = req.body;
         const valid = await ex.timing.startFunc('validation', () => cc.apiTokenValidation(username, token, 'api'));
         if (valid.valid && valid.userId) {
-            const jwt = cc.jwtGenerateAccessToken({
+            const jwt = await cc.jwtGenerateAccessToken({
                 userid: valid.userId,
                 username,
             });

package/dist/mjs/actions/index.js

@@ -0,0 +1,4 @@
+import ApiAuthTestAction from './ApiAuthTestAction.js';
+import ApiVersionAction from './ApiVersionAction.js';
+import GetTokenAction from './GetTokenAction.js';
+export { ApiVersionAction, ApiAuthTestAction, GetTokenAction };

package/dist/mjs/api/KernelEndpoint.js

@@ -0,0 +1,3 @@
+import BaseEndpoint from '../classes/BaseEndpoint.js';
+export default class KernelEndpoint extends BaseEndpoint {
+}

package/dist/mjs/api/index.d.ts

@@ -0,0 +1,2 @@
+import KernelEndpoint from './KernelEndpoint.js';
+export { KernelEndpoint };

package/dist/mjs/classes/BaseAction.d.ts

@@ -0,0 +1,20 @@
+import { CoreAction, IDataBase } from '@grandlinex/core';
+import { IBaseAction, IBaseCache, IBaseClient, IBaseKernelModule, IBasePresenter, IKernel } from '../lib/index.js';
+import { JwtToken } from './BaseAuthProvider.js';
+import { IExtensionInterface } from './timing/index.js';
+import { XNextFc, XRequest, XResponse } from '../lib/express.js';
+export declare enum ActionMode {
+    'DEFAULT' = 0,
+    'DMZ' = 1,
+    'DMZ_WITH_USER' = 2
+}
+export default abstract class BaseAction<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> extends CoreAction<K, T, P, C, E> implements IBaseAction<K, T, P, C, E> {
+    mode: ActionMode;
+    forceDebug: boolean;
+    constructor(chanel: string, module: IBaseKernelModule<K, T, P, C, E>);
+    abstract handler(req: XRequest, res: XResponse, next: XNextFc, data: JwtToken | null, extension: IExtensionInterface): Promise<void>;
+    secureHandler(req: XRequest, res: XResponse, next: () => void): Promise<void>;
+    setMode(mode: ActionMode): void;
+    abstract register(): void;
+    private initExtension;
+}

package/dist/{classes → mjs/classes}/BaseAction.js

@@ -5,12 +5,13 @@ export var ActionMode;
     ActionMode[ActionMode["DEFAULT"] = 0] = "DEFAULT";
     ActionMode[ActionMode["DMZ"] = 1] = "DMZ";
     ActionMode[ActionMode["DMZ_WITH_USER"] = 2] = "DMZ_WITH_USER";
-})(ActionMode = ActionMode || (ActionMode = {}));
+})(ActionMode || (ActionMode = {}));
 export default class BaseAction extends CoreAction {
     constructor(chanel, module) {
         super(chanel, module);
         this.secureHandler = this.secureHandler.bind(this);
         this.mode = ActionMode.DEFAULT;
+        this.forceDebug = false;
     }
     async secureHandler(req, res, next) {
         const extension = this.initExtension(res);

package/dist/mjs/classes/BaseApiAction.d.ts

@@ -0,0 +1,9 @@
+import { IDataBase } from '@grandlinex/core';
+import { ActionTypes, IBaseAction, IBaseCache, IBaseClient, IBaseKernelModule, IBasePresenter, IKernel } from '../lib/index.js';
+import BaseAction from './BaseAction.js';
+export default abstract class BaseApiAction<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> extends BaseAction<K, T, P, C, E> implements IBaseAction<K, T, P, C, E> {
+    exmod: undefined | IBaseKernelModule<K>;
+    type: ActionTypes;
+    constructor(type: ActionTypes, chanel: string, module: IBaseKernelModule<K, T, P, C, E>, extMod?: IBaseKernelModule<K>);
+    register(): void;
+}

package/dist/mjs/classes/BaseAuthProvider.d.ts

@@ -0,0 +1,23 @@
+import * as jwt from 'jsonwebtoken';
+import { XRequest } from '../lib/express.js';
+export type JwtExtend = {
+    username: string;
+    userid: string;
+} & Partial<Record<string, string | number | number[] | string[]>>;
+export type JwtToken<T extends JwtExtend = JwtExtend> = T & jwt.JwtPayload;
+export type AuthResult = {
+    valid: boolean;
+    userId: string | null;
+};
+export interface IAuthProvider<T extends JwtExtend> {
+    authorizeToken(userid: string, token: string, requestType: string): Promise<AuthResult>;
+    validateAccess(token: JwtToken<T>, requestType: string): Promise<boolean>;
+    bearerTokenValidation(req: XRequest): Promise<JwtToken<T> | number>;
+    jwtAddData(token: JwtToken<T>): Promise<JwtToken<T>>;
+}
+export default abstract class BaseAuthProvider<T extends JwtExtend = JwtExtend> implements IAuthProvider<T> {
+    abstract authorizeToken(username: string, token: string, requestType: string): Promise<AuthResult>;
+    abstract validateAccess(token: JwtToken<T>, requestType: string): Promise<boolean>;
+    abstract bearerTokenValidation(req: XRequest): Promise<JwtToken<T> | number>;
+    jwtAddData(token: JwtToken<T>): Promise<JwtToken<T>>;
+}

package/dist/mjs/classes/BaseAuthProvider.js

@@ -0,0 +1,5 @@
+export default class BaseAuthProvider {
+    async jwtAddData(token) {
+        return token;
+    }
+}

package/dist/mjs/classes/BaseKernelModule.d.ts

@@ -0,0 +1,4 @@
+import { CoreKernelModule, IDataBase } from '@grandlinex/core';
+import { IBaseCache, IBaseClient, IBaseKernelModule, IBasePresenter, IKernel } from '../lib/index.js';
+export default abstract class BaseKernelModule<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> extends CoreKernelModule<K, T, P, C, E> implements IBaseKernelModule<K, T, P, C, E> {
+}

package/dist/mjs/classes/index.d.ts

@@ -0,0 +1,10 @@
+import { CoreBridge as BaseBridge, CoreCache as BaseCache, CoreClient as BaseClient, CoreElement as BaseElement, CoreLoopService as BaseLoopService, CoreService as BaseService } from '@grandlinex/core';
+import BaseAction, { ActionMode } from './BaseAction.js';
+import BaseEndpoint, { keepRawBody } from './BaseEndpoint.js';
+import BaseKernelModule from './BaseKernelModule.js';
+import BaseApiAction from './BaseApiAction.js';
+import BaseAuthProvider from './BaseAuthProvider.js';
+export * from './BaseAction.js';
+export * from './BaseAuthProvider.js';
+export * from './timing/index.js';
+export { BaseLoopService, BaseAuthProvider, BaseKernelModule, BaseService, BaseApiAction, BaseEndpoint, BaseElement, BaseCache, BaseAction, BaseClient, BaseBridge, keepRawBody, ActionMode, };

package/dist/{classes → mjs/classes}/index.js

@@ -1,5 +1,5 @@
 import { CoreBridge as BaseBridge, CoreCache as BaseCache, CoreClient as BaseClient, CoreElement as BaseElement, CoreLoopService as BaseLoopService, CoreService as BaseService, } from '@grandlinex/core';
-import BaseAction from './BaseAction.js';
+import BaseAction, { ActionMode } from './BaseAction.js';
 import BaseEndpoint, { keepRawBody } from './BaseEndpoint.js';
 import BaseKernelModule from './BaseKernelModule.js';
 import BaseApiAction from './BaseApiAction.js';
@@ -7,4 +7,4 @@ import BaseAuthProvider from './BaseAuthProvider.js';
 export * from './BaseAction.js';
 export * from './BaseAuthProvider.js';
 export * from './timing/index.js';
-export { BaseLoopService, BaseAuthProvider, BaseKernelModule, BaseService, BaseApiAction, BaseEndpoint, BaseElement, BaseCache, BaseAction, BaseClient, BaseBridge, keepRawBody, };
+export { BaseLoopService, BaseAuthProvider, BaseKernelModule, BaseService, BaseApiAction, BaseEndpoint, BaseElement, BaseCache, BaseAction, BaseClient, BaseBridge, keepRawBody, ActionMode, };

package/dist/mjs/classes/timing/ExpressServerTiming.d.ts

@@ -0,0 +1,17 @@
+import { CoreElement } from '@grandlinex/core';
+import { XResponse } from '../../lib/express.js';
+export type IExtensionInterface = {
+    done: () => void;
+    timing: ExpressServerTiming;
+};
+export default class ExpressServerTiming {
+    private timing;
+    private baseApiAction;
+    constructor(baseApiAction: CoreElement<any>);
+    start(chanel: string): import("./ServerTimingElement.js").default;
+    startFunc<T>(chanel: string, fc: () => Promise<T>): Promise<T>;
+    dbQuery<T>(fc: () => Promise<T>): Promise<T>;
+    getHeader(): string;
+    addHeader(res: XResponse): void;
+    static init(baseApiAction: CoreElement<any>, res: XResponse): [ExpressServerTiming, () => void];
+}

package/dist/{classes → mjs/classes}/timing/ExpressServerTiming.js

@@ -26,7 +26,8 @@ export default class ExpressServerTiming {
     }
     addHeader(res) {
         if (this.timing.map.size > 0 &&
-            this.baseApiAction.getKernel().getDevMode()) {
+            (this.baseApiAction.getKernel().getDevMode() ||
+                this.baseApiAction.forceDebug)) {
             const a = ['Server-Timing', this.getHeader()];
             res.setHeader(a[0], a[1]);
             this.baseApiAction.debug(a);

package/dist/mjs/classes/timing/ServerTiming.d.ts

@@ -0,0 +1,8 @@
+import ServerTimingElement, { IServerElement } from './ServerTimingElement.js';
+export default class ServerTiming implements IServerElement {
+    map: Map<string, ServerTimingElement[]>;
+    constructor();
+    start(chanel: string): ServerTimingElement;
+    startFunc<T>(chanel: string, fc: () => Promise<T>): Promise<T>;
+    completeElement(e: ServerTimingElement): void;
+}

package/dist/mjs/classes/timing/ServerTimingElement.d.ts

@@ -0,0 +1,12 @@
+export type IServerElement = {
+    completeElement: (e: ServerTimingElement) => void;
+};
+export default class ServerTimingElement {
+    private el;
+    readonly chanel: string;
+    private readonly start;
+    private end;
+    constructor(el: IServerElement, chanel: string);
+    stop(): void;
+    getDuration(): number;
+}

package/dist/mjs/classes/timing/index.d.ts

@@ -0,0 +1,4 @@
+import ExpressServerTiming, { IExtensionInterface } from './ExpressServerTiming.js';
+import ServerTiming from './ServerTiming.js';
+import ServerTimingElement from './ServerTimingElement.js';
+export { ExpressServerTiming, ServerTimingElement, ServerTiming, IExtensionInterface, };

package/dist/mjs/index.js

@@ -0,0 +1,15 @@
+/**
+ * @name Kernel Main Module
+ * @author David Nagy
+ */
+import Kernel from './Kernel.js';
+import KernelModule from './KernelModule.js';
+export * from './actions/index.js';
+export * from './api/index.js';
+export * from './classes/index.js';
+export * from './modules/crypto/index.js';
+export * from './lib/index.js';
+export * from './lib/express.js';
+export * from '@grandlinex/core';
+export { KernelModule, Kernel };
+export default Kernel;

package/dist/mjs/lib/express.d.ts

@@ -0,0 +1,6 @@
+import express from 'express';
+export type XRequest = express.Request & {
+    rawBody?: string | null | undefined;
+};
+export type XResponse = express.Response;
+export type XNextFc = express.NextFunction;

package/dist/mjs/lib/index.d.ts

@@ -0,0 +1,36 @@
+import { ICoreAction, ICoreBridge, ICoreCache, ICoreCClient, ICoreClient, ICoreElement, ICoreKernel, ICoreKernelModule, ICorePresenter, ICoreService, IDataBase } from '@grandlinex/core';
+import express from 'express';
+import * as jwt from 'jsonwebtoken';
+import { IAuthProvider, JwtToken, IExtensionInterface, JwtExtend } from '../classes/index.js';
+import { XNextFc, XRequest, XResponse } from './express.js';
+export type ActionTypes = 'POST' | 'GET' | 'USE' | 'PATCH' | 'DELETE';
+export interface ICClient<T extends JwtExtend = JwtExtend> extends ICoreCClient {
+    setAuthProvider(provider: IAuthProvider<T>): boolean;
+    jwtVerifyAccessToken(token: string): Promise<JwtToken<T> | number>;
+    jwtDecodeAccessToken(token: string): jwt.JwtPayload | null;
+    jwtGenerateAccessToken(data: JwtToken<T>, expire?: string | number): Promise<string>;
+    apiTokenValidation(username: string, token: string, requestType: string): Promise<{
+        valid: boolean;
+        userId: string | null;
+    }>;
+    permissionValidation(token: JwtToken<T>, requestType: string): Promise<boolean>;
+    bearerTokenValidation(req: XRequest): Promise<JwtToken<T> | number>;
+}
+export interface IKernel<T extends JwtExtend = JwtExtend> extends ICoreKernel<ICClient<T>> {
+    getAppServerPort(): number;
+    setAppServerPort(port: number): void;
+    responseCodeFunction(data: {
+        code: number;
+        req: XRequest;
+    }): void;
+}
+export type IBaseKernelModule<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> = ICoreKernelModule<K, T, P, C, E>;
+export type IBasePresenter = ICorePresenter<express.Express>;
+export type IBaseService<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> = ICoreService<K, T, P, C, E>;
+export type IBaseClient<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> = ICoreClient;
+export type IBaseBrige = ICoreBridge;
+export type IBaseCache<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> = ICoreCache<K, T, P, C, E>;
+export type IBaseElement<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> = ICoreElement<K, T, P, C, E>;
+export interface IBaseAction<K extends IKernel = IKernel, T extends IDataBase<any, any> | null = any, P extends IBaseClient | null = any, C extends IBaseCache | null = any, E extends IBasePresenter | null = any> extends ICoreAction<K, T, P, C, E> {
+    handler(req: XRequest, res: XResponse, next: XNextFc, data: JwtToken | null, extension: IExtensionInterface): Promise<void>;
+}