@smythos/sre 1.6.1 → 1.6.8

package/src/subsystems/IO/NKV.service/connectors/NKVRedis.class.ts

@@ -1,182 +1,182 @@
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { INKVRequest, NKVConnector } from '../NKVConnector';
-import { ACLAccessDeniedError, IAccessCandidate, TAccessLevel, TAccessResult } from '@sre/types/ACL.types';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { CacheConnector } from '@sre/MemoryManager/Cache.service/CacheConnector';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { SecureConnector } from '@sre/Security/SecureConnector.class';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { StorageData } from '@sre/types/Storage.types';
-import { RedisCache } from '@sre/MemoryManager/Cache.service/connectors/RedisCache.class';
-import { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
-import Joi from 'joi';
-
-export class NKVRedis extends NKVConnector {
-    public name = 'Redis';
-    private redisCacheConnector: RedisCache;
-    private accountConnector: AccountConnector;
-    constructor(protected _settings?: any) {
-        super(_settings);
-        this.redisCacheConnector = ConnectorService.getCacheConnector('Redis') as RedisCache;
-        this.accountConnector = ConnectorService.getAccountConnector();
-    }
-
-    public key(...parts: string[]) {
-        return parts.join(':');
-    }
-
-    public mdKey(...parts: string[]) {
-        return parts.join(':');
-    }
-
-    @NKVRedis.Validate
-    @NKVRedis.NamespaceAccessControl
-    protected async get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData> {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-        return await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).get(this.key(`team_${teamId}`, namespace, key));
-    }
-
-    @NKVRedis.Validate
-    @NKVRedis.NamespaceAccessControl
-    protected async set(acRequest: AccessRequest, namespace: string, key: string, value: any) {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-
-        const setKey = this.key(`team_${teamId}`, namespace, key);
-        await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).set(setKey, value);
-        // to set namespace ownership
-        const isNewNs = !(await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).exists(namespace));
-        if (isNewNs) {
-            await this.redisCacheConnector
-                .requester(AccessCandidate.team(teamId))
-                .set(this.key(`team_${teamId}`, namespace), '', undefined, { ns: true });
-        }
-    }
-
-    @NKVRedis.Validate
-    @NKVRedis.NamespaceAccessControl
-    protected async delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void> {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-        await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).delete(this.key(`team_${teamId}`, namespace, key));
-    }
-
-    @NKVRedis.Validate
-    @NKVRedis.NamespaceAccessControl
-    protected async exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean> {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-        return await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).exists(this.key(`team_${teamId}`, namespace, key));
-    }
-
-    @NKVRedis.NamespaceAccessControl
-    public async list(acRequest: AccessRequest, namespace: string): Promise<{ key: string; data: StorageData }[]> {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-        let keys = await this.fetchKeysByPrefix(this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace));
-
-        // filter out metadata keys & namespace sentinel keys
-        keys = keys.filter(
-            (key) => key !== this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace) // if not the namespace sentinel key
-        );
-
-        if (keys.length <= 0) return [];
-        // Start a transaction
-        const pipeline = this.redisCacheConnector.client.pipeline();
-
-        // Add get commands for all keys to the transaction
-        keys.forEach((key) => {
-            pipeline.get(key);
-        });
-
-        // Execute the transaction
-        const results = await pipeline.exec();
-
-        // Combine the keys and their corresponding values
-        return keys.map((key, index) => {
-            return {
-                key: key.replace(`${this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace)}:`, ''),
-                data: results[index][1] as StorageData,
-            };
-        });
-    }
-
-    @NKVRedis.NamespaceAccessControl
-    public async deleteAll(acRequest: AccessRequest, namespace: string): Promise<void> {
-        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-        let keys = await this.fetchKeysByPrefix(this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace));
-        // filter out namespace sentinel key + namespace metadata key metadata key
-        keys = keys.filter((key) => {
-            return ![this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace)].includes(key);
-        });
-        await this.redisCacheConnector.client.del(keys);
-    }
-
-    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
-        return this.redisCacheConnector.getResourceACL(resourceId, candidate);
-    }
-
-    private async fetchKeysByPrefix(prefix: string): Promise<string[]> {
-        let cursor = '0';
-        const keys = [];
-
-        do {
-            // SCAN with match for the prefix and count for batch size (optional)
-            const result = await this.redisCacheConnector.client.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 10000);
-            cursor = result[0];
-            keys.push(...result[1]);
-        } while (cursor !== '0');
-
-        return keys;
-    }
-
-    static NamespaceAccessControl(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        // Store the original method in a variable
-        const originalMethod = descriptor.value;
-
-        // Modify the descriptor's value to wrap the original method
-        descriptor.value = async function (...args: any[]) {
-            // Extract the method arguments
-            let [acRequest, namespace, key] = args;
-            const isNamespaceSearch = key === undefined;
-
-            // Inject the access control logic
-            const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
-            const resourceId = isNamespaceSearch ? namespace : `${namespace}:${key}`;
-            const finalKey = this.key(this.redisCacheConnector.prefix, `team_${teamId}`, resourceId);
-            const accessTicket = await this.getAccessTicket(finalKey, acRequest);
-
-            if (accessTicket.access !== TAccessResult.Granted) throw new ACLAccessDeniedError('Access Denied');
-
-            // Call the original method with the original arguments
-            return originalMethod.apply(this, args);
-        };
-
-        // Return the modified descriptor
-        return descriptor;
-    }
-
-    static Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        // Store the original method in a variable
-        const originalMethod = descriptor.value;
-
-        // Modify the descriptor's value to wrap the original method
-        descriptor.value = async function (...args: any[]) {
-            // Extract the method arguments
-            let [acRequest, namespace, key] = args;
-
-            // Validate the arguments
-            const schemaValidator = Joi.object().keys({
-                namespace: Joi.string().min(1).required(),
-                key: Joi.string().min(1).required(),
-            });
-            const validationResult = schemaValidator.validate({ namespace, key });
-
-            if (validationResult.error) {
-                throw new Error(`Validation Error: ${validationResult.error.message}`);
-            }
-
-            // Call the original method with the original arguments
-            return originalMethod.apply(this, args);
-        };
-
-        // Return the modified descriptor
-        return descriptor;
-    }
-}
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { INKVRequest, NKVConnector } from '../NKVConnector';
+import { ACLAccessDeniedError, IAccessCandidate, TAccessLevel, TAccessResult } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CacheConnector } from '@sre/MemoryManager/Cache.service/CacheConnector';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { StorageData } from '@sre/types/Storage.types';
+import { RedisCache } from '@sre/MemoryManager/Cache.service/connectors/RedisCache.class';
+import { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
+import Joi from 'joi';
+
+export class NKVRedis extends NKVConnector {
+    public name = 'Redis';
+    private redisCacheConnector: RedisCache;
+    private accountConnector: AccountConnector;
+    constructor(protected _settings?: any) {
+        super(_settings);
+        this.redisCacheConnector = ConnectorService.getCacheConnector('Redis') as RedisCache;
+        this.accountConnector = ConnectorService.getAccountConnector();
+    }
+
+    public key(...parts: string[]) {
+        return parts.join(':');
+    }
+
+    public mdKey(...parts: string[]) {
+        return parts.join(':');
+    }
+
+    @NKVRedis.Validate
+    @NKVRedis.NamespaceAccessControl
+    protected async get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        return await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).get(this.key(`team_${teamId}`, namespace, key));
+    }
+
+    @NKVRedis.Validate
+    @NKVRedis.NamespaceAccessControl
+    protected async set(acRequest: AccessRequest, namespace: string, key: string, value: any) {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+
+        const setKey = this.key(`team_${teamId}`, namespace, key);
+        await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).set(setKey, value);
+        // to set namespace ownership
+        const isNewNs = !(await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).exists(namespace));
+        if (isNewNs) {
+            await this.redisCacheConnector
+                .requester(AccessCandidate.team(teamId))
+                .set(this.key(`team_${teamId}`, namespace), '', undefined, { ns: true });
+        }
+    }
+
+    @NKVRedis.Validate
+    @NKVRedis.NamespaceAccessControl
+    protected async delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).delete(this.key(`team_${teamId}`, namespace, key));
+    }
+
+    @NKVRedis.Validate
+    @NKVRedis.NamespaceAccessControl
+    protected async exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        return await this.redisCacheConnector.requester(AccessCandidate.team(teamId)).exists(this.key(`team_${teamId}`, namespace, key));
+    }
+
+    @NKVRedis.NamespaceAccessControl
+    public async list(acRequest: AccessRequest, namespace: string): Promise<{ key: string; data: StorageData }[]> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        let keys = await this.fetchKeysByPrefix(this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace));
+
+        // filter out metadata keys & namespace sentinel keys
+        keys = keys.filter(
+            (key) => key !== this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace) // if not the namespace sentinel key
+        );
+
+        if (keys.length <= 0) return [];
+        // Start a transaction
+        const pipeline = this.redisCacheConnector.client.pipeline();
+
+        // Add get commands for all keys to the transaction
+        keys.forEach((key) => {
+            pipeline.get(key);
+        });
+
+        // Execute the transaction
+        const results = await pipeline.exec();
+
+        // Combine the keys and their corresponding values
+        return keys.map((key, index) => {
+            return {
+                key: key.replace(`${this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace)}:`, ''),
+                data: results[index][1] as StorageData,
+            };
+        });
+    }
+
+    @NKVRedis.NamespaceAccessControl
+    public async deleteAll(acRequest: AccessRequest, namespace: string): Promise<void> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        let keys = await this.fetchKeysByPrefix(this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace));
+        // filter out namespace sentinel key + namespace metadata key metadata key
+        keys = keys.filter((key) => {
+            return ![this.key(this.redisCacheConnector.prefix, `team_${teamId}`, namespace)].includes(key);
+        });
+        await this.redisCacheConnector.client.del(keys);
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        return this.redisCacheConnector.getResourceACL(resourceId, candidate);
+    }
+
+    private async fetchKeysByPrefix(prefix: string): Promise<string[]> {
+        let cursor = '0';
+        const keys = [];
+
+        do {
+            // SCAN with match for the prefix and count for batch size (optional)
+            const result = await this.redisCacheConnector.client.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 10000);
+            cursor = result[0];
+            keys.push(...result[1]);
+        } while (cursor !== '0');
+
+        return keys;
+    }
+
+    static NamespaceAccessControl(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        // Store the original method in a variable
+        const originalMethod = descriptor.value;
+
+        // Modify the descriptor's value to wrap the original method
+        descriptor.value = async function (...args: any[]) {
+            // Extract the method arguments
+            let [acRequest, namespace, key] = args;
+            const isNamespaceSearch = key === undefined;
+
+            // Inject the access control logic
+            const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+            const resourceId = isNamespaceSearch ? namespace : `${namespace}:${key}`;
+            const finalKey = this.key(this.redisCacheConnector.prefix, `team_${teamId}`, resourceId);
+            const accessTicket = await this.getAccessTicket(finalKey, acRequest);
+
+            if (accessTicket.access !== TAccessResult.Granted) throw new ACLAccessDeniedError('Access Denied');
+
+            // Call the original method with the original arguments
+            return originalMethod.apply(this, args);
+        };
+
+        // Return the modified descriptor
+        return descriptor;
+    }
+
+    static Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        // Store the original method in a variable
+        const originalMethod = descriptor.value;
+
+        // Modify the descriptor's value to wrap the original method
+        descriptor.value = async function (...args: any[]) {
+            // Extract the method arguments
+            let [acRequest, namespace, key] = args;
+
+            // Validate the arguments
+            const schemaValidator = Joi.object().keys({
+                namespace: Joi.string().min(1).required(),
+                key: Joi.string().min(1).required(),
+            });
+            const validationResult = schemaValidator.validate({ namespace, key });
+
+            if (validationResult.error) {
+                throw new Error(`Validation Error: ${validationResult.error.message}`);
+            }
+
+            // Call the original method with the original arguments
+            return originalMethod.apply(this, args);
+        };
+
+        // Return the modified descriptor
+        return descriptor;
+    }
+}

package/src/subsystems/IO/NKV.service/index.ts

@@ -1,14 +1,14 @@
-//==[ SRE: Storage ]======================
-
-import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { NKVRedis } from './connectors/NKVRedis.class';
-import { NKVRAM } from './connectors/NKVRAM.class';
-import { NKVLocalStorage } from './connectors/NKVLocalStorage.class';
-export class NKVService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.NKV, 'Redis', NKVRedis);
-        ConnectorService.register(TConnectorService.NKV, 'RAM', NKVRAM);
-        ConnectorService.register(TConnectorService.NKV, 'LocalStorage', NKVLocalStorage);
-    }
-}
+//==[ SRE: Storage ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { NKVRedis } from './connectors/NKVRedis.class';
+import { NKVRAM } from './connectors/NKVRAM.class';
+import { NKVLocalStorage } from './connectors/NKVLocalStorage.class';
+export class NKVService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.NKV, 'Redis', NKVRedis);
+        ConnectorService.register(TConnectorService.NKV, 'RAM', NKVRAM);
+        ConnectorService.register(TConnectorService.NKV, 'LocalStorage', NKVLocalStorage);
+    }
+}

package/src/subsystems/IO/Router.service/RouterConnector.ts

@@ -1,21 +1,21 @@
-import { Connector } from '@sre/Core/Connector.class';
-import { SmythFS } from '../Storage.service/SmythFS.class';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export type GenericRequestHandler = (...args: any[]) => void | Promise<void>;
-
-/*
-This Connector is highly discouraged to be used because by design, SRE should not handle any kind of HTTP requests
-Currently it is only used to serve the temp files for external services to retrieve them.
-*/
-
-export abstract class RouterConnector extends Connector {
-    public abstract baseUrl: string;
-
-    abstract get(path: string, ...handlers: GenericRequestHandler[]): this;
-    abstract post(path: string, ...handlers: GenericRequestHandler[]): this;
-    abstract put(path: string, ...handlers: GenericRequestHandler[]): this;
-    abstract delete(path: string, ...handlers: GenericRequestHandler[]): this;
-    abstract useFn(...handlers: GenericRequestHandler[]): this;
-    abstract use(path: string, ...handlers: GenericRequestHandler[]): this;
-}
+import { Connector } from '@sre/Core/Connector.class';
+import { SmythFS } from '../Storage.service/SmythFS.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export type GenericRequestHandler = (...args: any[]) => void | Promise<void>;
+
+/*
+This Connector is highly discouraged to be used because by design, SRE should not handle any kind of HTTP requests
+Currently it is only used to serve the temp files for external services to retrieve them.
+*/
+
+export abstract class RouterConnector extends Connector {
+    public abstract baseUrl: string;
+
+    abstract get(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract post(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract put(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract delete(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract useFn(...handlers: GenericRequestHandler[]): this;
+    abstract use(path: string, ...handlers: GenericRequestHandler[]): this;
+}

package/src/subsystems/IO/Router.service/connectors/ExpressRouter.class.ts

@@ -1,48 +1,48 @@
-import { Router } from 'express';
-import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
-
-export class ExpressRouter extends RouterConnector {
-    private router: Router;
-    public baseUrl: string;
-
-    constructor(protected _settings?: { router: Router; baseUrl: string }) {
-        super(_settings);
-        this.name = 'ExpressRouter';
-        this.router = _settings.router;
-        this.baseUrl = _settings.baseUrl;
-    }
-
-    get(path: string, ...handlers: GenericRequestHandler[]): this {
-        this.router.get(path, ...handlers);
-        return this;
-    }
-
-    post(path: string, ...handlers: GenericRequestHandler[]): this {
-        this.router.post(path, ...handlers);
-        return this;
-    }
-
-    put(path: string, ...handlers: GenericRequestHandler[]): this {
-        this.router.put(path, ...handlers);
-        return this;
-    }
-
-    delete(path: string, ...handlers: GenericRequestHandler[]): this {
-        this.router.delete(path, ...handlers);
-        return this;
-    }
-
-    useFn(...handlers: GenericRequestHandler[]): this {
-        this.router.use(...handlers);
-        return this;
-    }
-
-    use(path: string, ...handlers: GenericRequestHandler[]): this {
-        this.router.use(path, ...handlers);
-        return this;
-    }
-
-    getRouter(): Router {
-        return this.router;
-    }
-}
+import { Router } from 'express';
+import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
+
+export class ExpressRouter extends RouterConnector {
+    private router: Router;
+    public baseUrl: string;
+
+    constructor(protected _settings?: { router: Router; baseUrl: string }) {
+        super(_settings);
+        this.name = 'ExpressRouter';
+        this.router = _settings.router;
+        this.baseUrl = _settings.baseUrl;
+    }
+
+    get(path: string, ...handlers: GenericRequestHandler[]): this {
+        this.router.get(path, ...handlers);
+        return this;
+    }
+
+    post(path: string, ...handlers: GenericRequestHandler[]): this {
+        this.router.post(path, ...handlers);
+        return this;
+    }
+
+    put(path: string, ...handlers: GenericRequestHandler[]): this {
+        this.router.put(path, ...handlers);
+        return this;
+    }
+
+    delete(path: string, ...handlers: GenericRequestHandler[]): this {
+        this.router.delete(path, ...handlers);
+        return this;
+    }
+
+    useFn(...handlers: GenericRequestHandler[]): this {
+        this.router.use(...handlers);
+        return this;
+    }
+
+    use(path: string, ...handlers: GenericRequestHandler[]): this {
+        this.router.use(path, ...handlers);
+        return this;
+    }
+
+    getRouter(): Router {
+        return this.router;
+    }
+}

package/src/subsystems/IO/Router.service/connectors/NullRouter.class.ts

@@ -1,40 +1,40 @@
-import { Logger } from '@sre/helpers/Log.helper';
-import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
-
-const console = Logger('NullRouter');
-export class NullRouter extends RouterConnector {
-    public baseUrl: string;
-    constructor(protected _settings?: any) {
-        super(_settings);
-        this.baseUrl = 'http://nullrouter.local';
-    }
-
-    get(path: string, ...handlers: GenericRequestHandler[]): this {
-        console.debug(`Ignored operation:NullRouter.get: ${path}`);
-        return this;
-    }
-
-    post(path: string, ...handlers: GenericRequestHandler[]): this {
-        console.debug(`Ignored operation:NullRouter.post: ${path}`);
-        return this;
-    }
-
-    put(path: string, ...handlers: GenericRequestHandler[]): this {
-        console.debug(`Ignored operation:NullRouter.put: ${path}`);
-        return this;
-    }
-
-    delete(path: string, ...handlers: GenericRequestHandler[]): this {
-        console.debug(`Ignored operation:NullRouter.delete: ${path}`);
-        return this;
-    }
-
-    useFn(...handlers: GenericRequestHandler[]): this {
-        console.debug(`Ignored operation:NullRouter.useFn`);
-        return this;
-    }
-
-    use(path: string, ...handlers: GenericRequestHandler[]): this {
-        return this;
-    }
-}
+import { Logger } from '@sre/helpers/Log.helper';
+import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
+
+const console = Logger('NullRouter');
+export class NullRouter extends RouterConnector {
+    public baseUrl: string;
+    constructor(protected _settings?: any) {
+        super(_settings);
+        this.baseUrl = 'http://nullrouter.local';
+    }
+
+    get(path: string, ...handlers: GenericRequestHandler[]): this {
+        console.debug(`Ignored operation:NullRouter.get: ${path}`);
+        return this;
+    }
+
+    post(path: string, ...handlers: GenericRequestHandler[]): this {
+        console.debug(`Ignored operation:NullRouter.post: ${path}`);
+        return this;
+    }
+
+    put(path: string, ...handlers: GenericRequestHandler[]): this {
+        console.debug(`Ignored operation:NullRouter.put: ${path}`);
+        return this;
+    }
+
+    delete(path: string, ...handlers: GenericRequestHandler[]): this {
+        console.debug(`Ignored operation:NullRouter.delete: ${path}`);
+        return this;
+    }
+
+    useFn(...handlers: GenericRequestHandler[]): this {
+        console.debug(`Ignored operation:NullRouter.useFn`);
+        return this;
+    }
+
+    use(path: string, ...handlers: GenericRequestHandler[]): this {
+        return this;
+    }
+}

package/src/subsystems/IO/Router.service/index.ts

@@ -1,11 +1,11 @@
-import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { ExpressRouter } from './connectors/ExpressRouter.class';
-import { NullRouter } from './connectors/NullRouter.class';
-
-export class RouterService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.Router, 'ExpressRouter', ExpressRouter);
-        ConnectorService.register(TConnectorService.Router, 'NullRouter', NullRouter);
-    }
-}
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { ExpressRouter } from './connectors/ExpressRouter.class';
+import { NullRouter } from './connectors/NullRouter.class';
+
+export class RouterService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Router, 'ExpressRouter', ExpressRouter);
+        ConnectorService.register(TConnectorService.Router, 'NullRouter', NullRouter);
+    }
+}