@grandlinex/kernel 0.30.2 → 0.30.5

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

@@ -0,0 +1,108 @@
+"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 });
+    }
+    jwtGenerateAccessToken(data, expire) {
+        return jwt.sign(data, 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,43 @@
+import { IBaseKernelModule } from '../lib/index.js';
+import { BaseApiAction, IExtensionInterface } from '../classes/index.js';
+import { XRequest, XResponse } from '../lib/express.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 {
+    /**
+     *
+     * @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/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,19 @@
+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;
+    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/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,20 @@
+import * as jwt from 'jsonwebtoken';
+import { XRequest } from '../lib/express.js';
+export interface JwtToken extends jwt.JwtPayload {
+    username: string;
+    userid: string;
+}
+export type AuthResult = {
+    valid: boolean;
+    userId: string | null;
+};
+export interface IAuthProvider {
+    authorizeToken(userid: string, token: string, requestType: string): Promise<AuthResult>;
+    validateAccess(token: JwtToken, requestType: string): Promise<boolean>;
+    bearerTokenValidation(req: XRequest): Promise<JwtToken | number>;
+}
+export default abstract class BaseAuthProvider implements IAuthProvider {
+    abstract authorizeToken(username: string, token: string, requestType: string): Promise<AuthResult>;
+    abstract validateAccess(token: JwtToken, requestType: string): Promise<boolean>;
+    abstract bearerTokenValidation(req: XRequest): Promise<JwtToken | number>;
+}

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/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 } 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>;
+    jwtDecodeAccessToken(token: string): jwt.JwtPayload | null;
+    jwtGenerateAccessToken(data: JwtToken, expire?: string | number): 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>;
+}
+export interface IKernel extends ICoreKernel<ICClient> {
+    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>;
+}

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

@@ -0,0 +1,21 @@
+import { CoreCryptoClient } from '@grandlinex/core';
+import * as jwt from 'jsonwebtoken';
+import { ICClient, IKernel } from '../../lib/index.js';
+import { IAuthProvider, JwtToken } from '../../classes/index.js';
+import { XRequest } from '../../lib/express.js';
+export default class CryptoClient extends CoreCryptoClient implements ICClient {
+    protected authProvider: IAuthProvider | null;
+    protected kernel: IKernel;
+    protected expiresIn: string;
+    constructor(key: string, kernel: IKernel);
+    setAuthProvider(provider: IAuthProvider): boolean;
+    jwtVerifyAccessToken(token: string): Promise<JwtToken | number>;
+    jwtDecodeAccessToken(token: string): jwt.JwtPayload | null;
+    jwtGenerateAccessToken(data: JwtToken, expire?: string | number): 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>;
+}

package/dist/{modules → mjs/modules}/crypto/CryptoClient.js

@@ -30,7 +30,9 @@ export default class CryptoClient extends CoreCryptoClient {
         });
     }
     jwtDecodeAccessToken(token) {
-        return jwt.default.decode(token, { json: true });
+        // MSJ-CJS SWITCH
+        const mod = jwt.default || jwt;
+        return mod.decode(token, { json: true });
     }
     jwtGenerateAccessToken(data, expire) {
         return jwt.sign(data, this.AesKey, { expiresIn: expire ?? this.expiresIn });

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

@@ -0,0 +1,3 @@
+import CryptoClient from './CryptoClient.js';
+export { CryptoClient };
+export * from './utils/cors.js';

package/dist/mjs/modules/crypto/utils/cors.d.ts

@@ -0,0 +1,3 @@
+import { XNextFc, XRequest, XResponse } from '../../../lib/express.js';
+export type CorsMiddleWare = (req: XRequest, res: XResponse, next: XNextFc) => void;
+export declare const cors: CorsMiddleWare;

package/dist/mjs/package.json

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

package/package.json

@@ -1,25 +1,34 @@
 {
   "name": "@grandlinex/kernel",
-  "version": "0.30.2",
+  "version": "0.30.5",
   "description": "GrandLineX is an out-of-the-box server framework on top of ExpressJs.",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/mjs/index.d.ts",
+        "default": "./dist/mjs/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
       }
     }
   },
+  "types": "dist/cjs/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/mjs/index.js",
   "scripts": {
-    "buildprep": "tsc",
+    "buildprep": "npm run build-mjs && npm run build-cjs && npm run build-fix",
+    "build-mjs": "tsc",
+    "build-cjs": "tsc -p tsconfig-cjs.json",
+    "build-fix": "node ./node_modules/@grandlinex/core/fix.js",
     "lint": "eslint src",
     "test": "jest --runInBand ",
-    "run": "ts-node-esm src/tests/run.ts",
+    "run": "ts-node tests/run.ts",
     "pack-dev": "npm version -no-git-tag-version prerelease && npm run buildprep && npm pack",
     "test-converage": "jest --runInBand --ci --collectCoverage   --coverageDirectory=\"./coverage\"  --reporters=default --reporters=jest-junit",
+    "doc-converage": "jest --runInBand --ci --collectCoverage   --coverageDirectory=\"./docs/coverage\"  --reporters=default --reporters=jest-junit",
     "makeDocs": "typedoc",
     "openDocs": "npm run makeDocs",
     "makeSpec": "makeOpenApi"