@rockster/core 0.0.1

package/controllers/services/restful-action-builder.js

@@ -0,0 +1,132 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestfulActionBuilder = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const create_interceptor_1 = require("../../core/functions/create-interceptor");
+const request_interceptor_1 = require("../interfaces/enum/request-interceptor");
+const interceptor_1 = require("../../core/interfaces/interceptor");
+const path_1 = __importDefault(require("path"));
+const http_controller_1 = require("../../http/http.controller");
+const common_1 = require("@rockster/common");
+const constants_1 = require("../constants");
+const class_pipe_1 = require("@rockster/class-pipe");
+const web_socket_1 = require("../../web-socket");
+const use_auth_1 = require("../../security/functions/use-auth");
+let RestfulActionBuilder = class RestfulActionBuilder {
+    constructor(httpController) {
+        this.httpController = httpController;
+    }
+    async create(object) {
+        const data = await (0, class_injector_1.createExecutors)(object.objectClass);
+        const properties = core
+            .storage
+            .getProperties(object.objectClass)
+            .filter((property) => {
+            return property.isRestful;
+        });
+        for (const property of properties) {
+            const isSecure = !property.public;
+            const fullPath = path_1.default.join(object.path, property.path);
+            const onBeforeValidationFilter = [request_interceptor_1.requestInterceptor.onBeforeValidation];
+            const onBeforeExecuteFilter = [interceptor_1.commonInterceptor.onBeforeExecute];
+            const onAfterExecuteFilter = [interceptor_1.commonInterceptor.onAfterExecute];
+            const onBeforeValidation = (0, create_interceptor_1.createExecuteInterceptors)(onBeforeValidationFilter, object, property);
+            const onBeforeExecute = (0, create_interceptor_1.createExecuteInterceptors)(onBeforeExecuteFilter, object, property);
+            const onAfterExecute = (0, create_interceptor_1.createExecuteInterceptors)(onAfterExecuteFilter, object, property);
+            const httpMethod = property.httpMethod;
+            property.fullPath = !fullPath.startsWith('/') ? `/${fullPath}` : fullPath;
+            this.httpController.addRoute(httpMethod, property.fullPath, async (req, res) => {
+                try {
+                    let session = null;
+                    if (isSecure && !req.isWs)
+                        session = await (0, use_auth_1.useAuth)().httpInterceptor(req);
+                    if (req.isWs)
+                        session = req.session;
+                    const initialData = {
+                        [constants_1.SESSION_KEY]: session,
+                        [constants_1.REQUEST_KEY]: req,
+                        [constants_1.RESPONSE_KEY]: res,
+                        [web_socket_1.WS_CLIENT_KEY]: req
+                    };
+                    await onBeforeValidation({ property, req, res });
+                    const headers = req.headers;
+                    const params = req.params;
+                    const query = req.query;
+                    const body = req.body;
+                    await this.buildPartData(property, 'headers', constants_1.FROM_HEADERS_KEY, property.fromHeaders, property.fromHeadersFields, initialData, headers);
+                    await this.buildPartData(property, `params:${fullPath}`, constants_1.FROM_PARAMS_KEY, property.fromParams, property.fromParamsFields, initialData, params);
+                    await this.buildPartData(property, 'query', constants_1.FROM_QUERY_KEY, property.fromQuery, property.fromQueryFields, initialData, query);
+                    await this.buildPartData(property, 'body', constants_1.FROM_BODY_KEY, property.fromBody, property.fromBodyFields, initialData, body);
+                    await onBeforeExecute({ property, req, res });
+                    const handle = data.executors[property.propertyKey].handle;
+                    const result = await handle(initialData);
+                    const responseStatus = property.responseHttpStatus ?? common_1.HttpStatus.ok;
+                    if (property.hasResponse && property.responseType === 'json') {
+                        res.status(responseStatus).json(result);
+                    }
+                    else if (property.hasResponse && property.responseType === 'typed') {
+                        const responseType = property.getResponseType();
+                        const responseData = property.isResponseArray
+                            ? await Promise.all(result.map(item => (0, class_pipe_1.transform)({
+                                target: responseType,
+                                values: item,
+                                groups: property.exposeGroups
+                            })))
+                            : await (0, class_pipe_1.transform)({
+                                target: responseType,
+                                values: result,
+                                groups: property.exposeGroups
+                            });
+                        res.status(responseStatus).json(responseData);
+                    }
+                    else if (!property.customResponse) {
+                        res.sendStatus(responseStatus);
+                    }
+                    res.on('close', async () => {
+                        await onAfterExecute({ result, property, req, res }, true);
+                    });
+                }
+                catch (error) {
+                    const code = error.httpCode || common_1.HttpStatus.internalServerError;
+                    const body = code === common_1.HttpStatus.internalServerError ? null : error;
+                    res.status(code).json(body);
+                    core.options?.onRequestError?.apply(this, [error]);
+                }
+            });
+        }
+    }
+    async buildPartData(property, targetName, targetKey, target, targetFields, initialData, values = {}) {
+        if (target) {
+            let sanitized = {};
+            const errors = await (0, class_pipe_1.validate)(target, values, sanitized, { groups: property.validateGroups });
+            if (errors) {
+                errors.target = targetName;
+                throw errors;
+            }
+            ;
+            initialData[targetKey] = sanitized;
+        }
+        if (targetFields?.length > 0) {
+            targetFields.forEach((field) => {
+                initialData[`${targetKey}:${field}`] = values[field];
+            });
+        }
+    }
+};
+exports.RestfulActionBuilder = RestfulActionBuilder;
+exports.RestfulActionBuilder = RestfulActionBuilder = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [http_controller_1.HttpController])
+], RestfulActionBuilder);

package/core/core.controller.d.ts

@@ -0,0 +1,41 @@
+import '../global';
+import { Logger } from "@rockster/logger";
+import { ModuleController } from '../module/module.controller';
+import { DatabaseController } from '../database/database.controller';
+import { HttpController } from '../http/http.controller';
+import { CacheController } from '../cache/cache.controller';
+import { Instantiable } from '@rockster/common';
+import { CoreOptions } from './interfaces';
+import { WebSocketController } from '../web-socket';
+import { Server } from 'http';
+import { RequestRouter } from './services/request-router';
+import { AuthController } from '../security/auth.controller';
+import { StorageController } from '../storage';
+import { JobsController } from '../jobs/jobs.controller';
+import { WorkersController } from '../workers/workers.controller';
+import { NodeControlService } from './services/node-control.service';
+import { TranslationsController } from '../translations/translations.controller';
+import { FormsController } from '../forms/forms.controller';
+import { TasksController } from '../tasks/tasks.controller';
+export declare class CoreController {
+    protected moduleController: ModuleController;
+    protected databaseController: DatabaseController;
+    protected cacheController: CacheController;
+    protected httpController: HttpController;
+    protected webSocketController: WebSocketController;
+    protected actionRouter: RequestRouter;
+    protected authController: AuthController;
+    protected storageController: StorageController;
+    protected jobsController: JobsController;
+    protected workersController: WorkersController;
+    protected nodeControlService: NodeControlService;
+    protected translationsController: TranslationsController;
+    protected formsController: FormsController;
+    protected tasksController: TasksController;
+    protected logger: Logger;
+    constructor(moduleController: ModuleController, databaseController: DatabaseController, cacheController: CacheController, httpController: HttpController, webSocketController: WebSocketController, actionRouter: RequestRouter, authController: AuthController, storageController: StorageController, jobsController: JobsController, workersController: WorkersController, nodeControlService: NodeControlService, translationsController: TranslationsController, formsController: FormsController, tasksController: TasksController);
+    init(module: Instantiable, options: CoreOptions): Promise<void>;
+    protected initAsMain(module: Instantiable, port: number): Promise<void>;
+    protected initAsWorker(module: Instantiable): Promise<void>;
+    protected enableWebSocket(server: Server): Promise<void>;
+}

package/core/core.controller.js

@@ -0,0 +1,208 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreController = void 0;
+require("../global");
+const logger_1 = require("@rockster/logger");
+const module_controller_1 = require("../module/module.controller");
+const database_controller_1 = require("../database/database.controller");
+const http_controller_1 = require("../http/http.controller");
+const cache_controller_1 = require("../cache/cache.controller");
+const web_socket_1 = require("../web-socket");
+const request_router_1 = require("./services/request-router");
+const locale_service_1 = require("./services/locale-service");
+const auth_controller_1 = require("../security/auth.controller");
+const storage_1 = require("../storage");
+const jobs_controller_1 = require("../jobs/jobs.controller");
+const workers_controller_1 = require("../workers/workers.controller");
+const encode_message_1 = require("../workers/functions/encode-message");
+const interfaces_1 = require("../workers/interfaces");
+const decode_message_1 = require("../workers/functions/decode-message");
+const node_control_service_1 = require("./services/node-control.service");
+const translations_controller_1 = require("../translations/translations.controller");
+const forms_controller_1 = require("../forms/forms.controller");
+const tasks_controller_1 = require("../tasks/tasks.controller");
+const class_injector_1 = require("@rockster/class-injector");
+const global_1 = require("../global");
+const worker_threads_1 = require("worker_threads");
+const radash_1 = require("radash");
+let CoreController = class CoreController {
+    constructor(moduleController, databaseController, cacheController, httpController, webSocketController, actionRouter, authController, storageController, jobsController, workersController, nodeControlService, translationsController, formsController, tasksController) {
+        this.moduleController = moduleController;
+        this.databaseController = databaseController;
+        this.cacheController = cacheController;
+        this.httpController = httpController;
+        this.webSocketController = webSocketController;
+        this.actionRouter = actionRouter;
+        this.authController = authController;
+        this.storageController = storageController;
+        this.jobsController = jobsController;
+        this.workersController = workersController;
+        this.nodeControlService = nodeControlService;
+        this.translationsController = translationsController;
+        this.formsController = formsController;
+        this.tasksController = tasksController;
+        this.logger = new logger_1.Logger('Core');
+    }
+    async init(module, options) {
+        core.options = options;
+        core.locale = await (0, class_injector_1.createInstance)(locale_service_1.LocaleService);
+        if (!worker_threads_1.isMainThread) {
+            return this.initAsWorker(module);
+        }
+        if (!core.options.port) {
+            core.options.port = 4000;
+        }
+        if (options.workers) {
+            await this
+                .workersController
+                .init(options.workers);
+        }
+        return this.initAsMain(module, core.options.port);
+    }
+    async initAsMain(module, port) {
+        // Vars
+        const protocols = ['http'];
+        // Load Modules
+        const events = await this.moduleController.load(module);
+        await Promise.all(Object
+            .getOwnPropertyNames(core.interceptors)
+            .map(async (property) => {
+            const interceptor = core.interceptors[property];
+            interceptor.instance = await (0, class_injector_1.createInstance)(interceptor.executor);
+        }));
+        // Init storage, translations and forms
+        await this.storageController.start();
+        await this.translationsController.start();
+        await this.formsController.start();
+        await this.tasksController.start();
+        // Init dabatase and cache connection
+        await this.databaseController.initialize();
+        await this.cacheController.initialize();
+        for (const event of events) {
+            await event.onAfterDatabaseInit();
+        }
+        // Auth
+        if (core.options.security?.controller) {
+            const controller = core
+                .options
+                .security
+                .controller;
+            await this
+                .authController
+                .active(controller);
+        }
+        if (core.isAuthRequired && !core.isAuthEnabled) {
+            this.logger.throw(new Error('To use entities protector you need active authentication with @Authentication'));
+        }
+        // Init jobs
+        await this.jobsController.init();
+        // Http service
+        await this.actionRouter.start(this.httpController);
+        const server = await this.httpController.listen(port);
+        // WebSocket service
+        if (core.options.router) {
+        }
+        else {
+            protocols.push('webSocket');
+            await this.enableWebSocket(server);
+        }
+        for (const event of events) {
+            await event.onAfterAppStart();
+        }
+        await this
+            .nodeControlService
+            .registerNode();
+        const actions = {};
+        core.actions.forEach((action) => {
+            const name = (0, radash_1.camel)(action
+                .objectClass
+                .name
+                .replace(/request/gi, '')
+                .replace(/controller/gi, ''));
+            if (!actions[name])
+                actions[name] = [];
+            actions[name].push(action);
+        });
+        Object.getOwnPropertyNames(actions).forEach((objectKey) => {
+            this.logger.log(`Actions $${objectKey}.{${actions[objectKey].map((action) => action.name).join(',')}} loaded`);
+        });
+        this.logger.log(`Application started [${protocols}] on port {${port}}`);
+    }
+    async initAsWorker(module) {
+        // Load Modules
+        await this.moduleController.load(module, false);
+        await Promise.all(Object
+            .getOwnPropertyNames(core.interceptors)
+            .map(async (property) => {
+            const interceptor = core.interceptors[property];
+            const executor = interceptor.executor;
+            interceptor.instance = await (0, class_injector_1.createInstance)(executor);
+        }));
+        // Init dabatase and cache connection
+        await this.databaseController.initialize();
+        await this.cacheController.initialize();
+        // Config jobs
+        await this.jobsController.configJobs();
+        await this.tasksController.start();
+        worker_threads_1.parentPort.postMessage((0, encode_message_1.encodeMessage)({
+            type: interfaces_1.WorkerMessageType.done
+        }));
+        // Try messages
+        worker_threads_1.parentPort.on('message', async (value) => {
+            const message = (0, decode_message_1.decodeMessage)(value);
+            switch (message.type) {
+                case interfaces_1.WorkerMessageType.initRun:
+                    const error = await this
+                        .jobsController
+                        .execute(message.jobName);
+                    worker_threads_1.parentPort.postMessage((0, encode_message_1.encodeMessage)({
+                        type: interfaces_1.WorkerMessageType.finishRun,
+                        jobName: message.jobName,
+                        error: error
+                    }));
+                    break;
+            }
+        });
+    }
+    async enableWebSocket(server) {
+        await this.webSocketController.start(server);
+    }
+};
+exports.CoreController = CoreController;
+__decorate([
+    (0, class_injector_1.OnCreate)(),
+    __param(0, (0, class_injector_1.Inject)(global_1.MAIN_MODULE)),
+    __param(1, (0, class_injector_1.Inject)(global_1.CORE_OPTIONS)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], CoreController.prototype, "init", null);
+exports.CoreController = CoreController = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [module_controller_1.ModuleController,
+        database_controller_1.DatabaseController,
+        cache_controller_1.CacheController,
+        http_controller_1.HttpController,
+        web_socket_1.WebSocketController,
+        request_router_1.RequestRouter,
+        auth_controller_1.AuthController,
+        storage_1.StorageController,
+        jobs_controller_1.JobsController,
+        workers_controller_1.WorkersController,
+        node_control_service_1.NodeControlService,
+        translations_controller_1.TranslationsController,
+        forms_controller_1.FormsController,
+        tasks_controller_1.TasksController])
+], CoreController);

package/core/functions/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { Instantiable } from '@rockster/common';
+import { CoreOptions } from '../interfaces/core-options';
+export declare const bootstrap: (module: Instantiable, options: CoreOptions) => Promise<void>;

package/core/functions/bootstrap.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrap = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const core_controller_1 = require("../core.controller");
+const global_1 = require("../../global");
+const bootstrap = async (module, options) => {
+    await (0, class_injector_1.createInstance)(core_controller_1.CoreController, {
+        [global_1.CORE_OPTIONS]: options,
+        [global_1.MAIN_MODULE]: module
+    });
+};
+exports.bootstrap = bootstrap;

package/core/functions/create-action.d.ts

@@ -0,0 +1,2 @@
+import { ActionDef } from "../interfaces";
+export declare const createAction: (action: ActionDef) => ActionDef;

package/core/functions/create-action.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAction = void 0;
+const logger_1 = require("@rockster/logger");
+const createAction = (action) => {
+    const logger = new logger_1.Logger(action
+        .objectClass
+        .name);
+    const exists = core
+        .actionsByPath[action.path];
+    if (exists) {
+        logger.throw(new Error(`Action [${action.name}] already exists in [${exists.objectClass.name}]`));
+    }
+    core.actions.push(action);
+    core.actionsByPath[action.path] = action;
+    return action;
+};
+exports.createAction = createAction;

package/core/functions/create-interceptor.d.ts

@@ -0,0 +1,12 @@
+import { ExecuteInterceptorHandle, IObject, IProperty, Interceptor } from "../interfaces";
+type Decorator = {
+    (interceptor: Interceptor, params?: any): (target: any, propertyKey?: string) => void;
+};
+export declare const createInterceptor: {
+    only: (interceptor: Interceptor) => () => (target: any, propertyKey?: string) => void;
+    withParams: <T>(interceptor: Interceptor) => (params: T) => (target: any, propertyKey?: string) => void;
+    withOptionalParams: <T>(interceptor: Interceptor) => (params?: T) => (target: any, propertyKey?: string) => void;
+    custom: <T>(interceptor: Interceptor, callback: (decorator: Decorator, interceptor: Interceptor) => T) => T;
+};
+export declare const createExecuteInterceptors: (filters: string[], object: IObject, property?: IProperty) => ExecuteInterceptorHandle;
+export {};

package/core/functions/create-interceptor.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecuteInterceptors = exports.createInterceptor = void 0;
+const decorator = (interceptor, params) => {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            const property = core
+                .storage
+                .createProperty(target, propertyKey);
+            property.interceptors.push({
+                name: interceptor.name,
+                params
+            });
+        }
+        else {
+            const object = core
+                .storage
+                .createObject(target);
+            object.interceptors.push({
+                name: interceptor.name,
+                params
+            });
+        }
+    };
+};
+const registerInterceptor = (interceptor) => {
+    core.interceptors[interceptor.name] = interceptor;
+};
+exports.createInterceptor = {
+    only: (interceptor) => {
+        registerInterceptor(interceptor);
+        return () => decorator(interceptor);
+    },
+    withParams: (interceptor) => {
+        registerInterceptor(interceptor);
+        return (params) => decorator(interceptor, params);
+    },
+    withOptionalParams: (interceptor) => {
+        registerInterceptor(interceptor);
+        return (params) => decorator(interceptor, params);
+    },
+    custom: (interceptor, callback) => {
+        registerInterceptor(interceptor);
+        return callback(decorator, interceptor);
+    }
+};
+const createExecuteInterceptors = (filters, object, property) => {
+    const filter = (interceptorToExecute) => {
+        const interceptor = core
+            .interceptors[interceptorToExecute.name];
+        const isExists = filters
+            .filter((search) => {
+            return interceptor
+                .filters
+                .find((filter) => search === filter);
+        });
+        return isExists.length > 0;
+    };
+    const executes = [
+        ...object.interceptors.filter(filter),
+        ...property ? property.interceptors.filter(filter) : []
+    ];
+    return async (args, isAfter = false) => {
+        for (const execute of executes) {
+            const currentArgs = {
+                ...args,
+                params: execute.params
+            };
+            const interceptor = core.interceptors[execute.name];
+            (isAfter && interceptor.waitWhenIsAfter) || !isAfter
+                ? await interceptor.instance.intercept(currentArgs)
+                : interceptor.instance.intercept(currentArgs);
+        }
+    };
+};
+exports.createExecuteInterceptors = createExecuteInterceptors;

package/core/functions/format-message.d.ts

@@ -0,0 +1,2 @@
+import { FormatMessageOptions } from "../interfaces";
+export declare const formatMessage: (options: FormatMessageOptions) => string;

package/core/functions/format-message.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMessage = void 0;
+const formatMessage = (options) => {
+    return core.locale.formatMessage(options);
+};
+exports.formatMessage = formatMessage;

package/core/functions/get-action-path.d.ts

@@ -0,0 +1 @@
+export declare const getActionPath: (target: string, property: string) => string;

package/core/functions/get-action-path.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActionPath = void 0;
+const getActionPath = (target, property) => {
+    return `$${target}.${property}`;
+};
+exports.getActionPath = getActionPath;

package/core/functions/get-env.d.ts

@@ -0,0 +1,11 @@
+export type EnvConfig<T> = {
+    [key in keyof T]: {
+        isOptional?: boolean;
+        getValue?: (value: string) => any;
+        errorMessage: string;
+    };
+};
+export type Env<T> = {
+    [key in keyof EnvConfig<T>]?: any;
+};
+export declare const getEnv: <T>(config: EnvConfig<T>) => Env<T>;

package/core/functions/get-env.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnv = void 0;
+const getEnv = (config) => {
+    const env = {};
+    const keys = Object.getOwnPropertyNames(config);
+    keys.forEach((key) => {
+        const value = process.env[key];
+        const propConfig = config[key];
+        if (!value && !propConfig.isOptional) {
+            throw new Error(`process.env [${key}] ${propConfig.errorMessage}`);
+        }
+        env[key] = propConfig.getValue
+            ? propConfig.getValue(value)
+            : value;
+    });
+    return env;
+};
+exports.getEnv = getEnv;

package/core/functions/get-node-key.d.ts

@@ -0,0 +1 @@
+export declare const getNodeKey: () => string;

package/core/functions/get-node-key.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeKey = void 0;
+const getNodeKey = () => {
+    return core.nodeKey;
+};
+exports.getNodeKey = getNodeKey;

package/core/functions/get-other-types.d.ts

@@ -0,0 +1,2 @@
+import { IValidatorPropertyDoc } from "@rockster/class-pipe";
+export declare const getOtherTypes: (mainType: string, propertyValidators: IValidatorPropertyDoc) => string[];

package/core/functions/get-other-types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOtherTypes = void 0;
+const removeIs = (value) => {
+    return value.replace(/is/gi, '');
+};
+const getOtherTypes = (mainType, propertyValidators) => {
+    const validators = propertyValidators
+        ?.validators;
+    return validators?.length > 0
+        ? validators
+            .filter((validator) => {
+            return removeIs(validator.name)
+                .toLowerCase() !== mainType;
+        })
+            .map((validator) => (removeIs(validator.name)))
+        : [];
+};
+exports.getOtherTypes = getOtherTypes;

package/core/index.d.ts

@@ -0,0 +1,10 @@
+export * from './functions/bootstrap';
+export * from './functions/get-action-path';
+export * from './functions/create-action';
+export * from './interfaces';
+export * from './core.controller';
+export * from './services/object-loader';
+export * from './services/locale-service';
+export * from './functions/get-other-types';
+export * from './functions/get-env';
+export * from './functions/create-interceptor';

package/core/index.js

@@ -0,0 +1,26 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./functions/bootstrap"), exports);
+__exportStar(require("./functions/get-action-path"), exports);
+__exportStar(require("./functions/create-action"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./core.controller"), exports);
+__exportStar(require("./services/object-loader"), exports);
+__exportStar(require("./services/locale-service"), exports);
+__exportStar(require("./functions/get-other-types"), exports);
+__exportStar(require("./functions/get-env"), exports);
+__exportStar(require("./functions/create-interceptor"), exports);