@smythos/sre 1.5.1 → 1.5.4

package/src/subsystems/IO/Log.service/LogConnector.ts

@@ -0,0 +1,32 @@
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { AgentCallLog } from '@sre/types/AgentLogger.types';
+
+export interface ILogRequest {
+    log(logData: AgentCallLog, callId?: string): Promise<any>;
+    logTask(tasks: number, isUsingTestDomain: boolean): Promise<void>;
+}
+
+export abstract class LogConnector extends SecureConnector {
+    public abstract id: string;
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+
+    public requester(candidate: AccessCandidate): ILogRequest {
+        if (candidate.role !== 'agent') throw new Error('Only agents can use Log connector');
+
+        return {
+            log: async (logData: AgentCallLog, callId?: string) => {
+                return await this.log(candidate.writeRequest, logData, callId);
+            },
+            logTask: async (tasks: number, isUsingTestDomain: boolean) => {
+                await this.logTask(candidate.writeRequest, tasks, isUsingTestDomain);
+            },
+        };
+    }
+
+    protected abstract log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any>;
+    protected abstract logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void>;
+}

package/src/subsystems/IO/Log.service/connectors/ConsoleLog.class.ts

@@ -0,0 +1,28 @@
+import { Logger } from '@sre/helpers/Log.helper';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { LogConnector } from '../LogConnector';
+import { AgentCallLog } from '@sre/types/AgentLogger.types';
+
+const console = Logger('SmythLog');
+
+export class ConsoleLog extends LogConnector {
+    public id: string;
+    public getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        return Promise.resolve(new ACL());
+    }
+    protected log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any> {
+        console.debug(`Log for agent ${acRequest.candidate.id}: ${typeof logData === 'string' ? logData : JSON.stringify(logData)}`);
+
+        return Promise.resolve();
+    }
+    protected logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void> {
+        console.debug(
+            `${tasks} Task(s) Consumed by agent ${acRequest.candidate.id}: ${isUsingTestDomain ? 'Using Test Domain' : 'Using Production Domain'}`
+        );
+
+        return Promise.resolve();
+    }
+    public name: string;
+}

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

@@ -0,0 +1,13 @@
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { Logger } from '@sre/helpers/Log.helper';
+
+import { ConsoleLog } from './connectors/ConsoleLog.class';
+
+const console = Logger('LogService');
+
+export class LogService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Log, 'ConsoleLog', ConsoleLog);
+    }
+}

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

@@ -0,0 +1,41 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
+
+export interface INKVRequest {
+    get(namespace: string, key: string): Promise<StorageData>;
+    set(namespace: string, key: string, value: StorageData): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    exists(namespace: string, key: string): Promise<boolean>;
+    deleteAll(namespace: string): Promise<void>;
+    list(namespace: string): Promise<{ key: string; data: StorageData }[]>;
+}
+
+/**
+ * NKV = Namespace-Key-Value Connector
+ */
+export abstract class NKVConnector extends SecureConnector {
+    public requester(candidate: AccessCandidate): INKVRequest {
+        return {
+            get: async (namespace: string, key: string) => this.get(candidate.readRequest, namespace, key),
+            set: async (namespace: string, key: string, value: StorageData) => this.set(candidate.writeRequest, namespace, key, value),
+            delete: async (namespace: string, key: string) => this.delete(candidate.writeRequest, namespace, key),
+            exists: async (namespace: string, key: string) => this.exists(candidate.readRequest, namespace, key),
+            deleteAll: async (namespace: string) => this.deleteAll(candidate.writeRequest, namespace),
+            list: async (namespace: string) => this.list(candidate.readRequest, namespace),
+        };
+    }
+
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+
+    protected abstract get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData>;
+    protected abstract set(acRequest: AccessRequest, namespace: string, key: string, value: StorageData): Promise<void>;
+
+    protected abstract delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void>;
+    protected abstract exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean>;
+    protected abstract deleteAll(acRequest: AccessRequest, namespace: string): Promise<void>;
+    protected abstract list(acRequest: AccessRequest, namespace: string): Promise<{ key: string; data: StorageData }[]>;
+}

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

@@ -0,0 +1,204 @@
+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 { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
+import Joi from 'joi';
+
+export class NKVRAM extends NKVConnector {
+    public name = 'RAM';
+    private storage: Map<string, any> = new Map();
+    private namespaces: Set<string> = new Set();
+    private accountConnector: AccountConnector;
+    private cacheConnector: CacheConnector;
+
+    constructor(protected _settings?: any) {
+        super(_settings);
+        this.accountConnector = ConnectorService.getAccountConnector();
+        this.cacheConnector = ConnectorService.getCacheConnector('RAM');
+    }
+
+    public key(...parts: string[]) {
+        return parts.join(':');
+    }
+
+    public mdKey(...parts: string[]) {
+        return parts.join(':');
+    }
+
+    @NKVRAM.Validate
+    @NKVRAM.NamespaceAccessControl
+    protected async get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const storageKey = this.key(`team_${teamId}`, namespace, key);
+        return this.storage.get(storageKey) || null;
+    }
+
+    @NKVRAM.Validate
+    @NKVRAM.NamespaceAccessControl
+    protected async set(acRequest: AccessRequest, namespace: string, key: string, value: any): Promise<void> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const storageKey = this.key(`team_${teamId}`, namespace, key);
+
+        // Store the value
+        this.storage.set(storageKey, value);
+
+        // Track namespace
+        const nsKey = this.key(`team_${teamId}`, namespace);
+        if (!this.namespaces.has(nsKey)) {
+            this.namespaces.add(nsKey);
+            this.storage.set(nsKey, ''); // Namespace sentinel
+        }
+    }
+
+    @NKVRAM.Validate
+    @NKVRAM.NamespaceAccessControl
+    protected async delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const storageKey = this.key(`team_${teamId}`, namespace, key);
+        this.storage.delete(storageKey);
+    }
+
+    @NKVRAM.Validate
+    @NKVRAM.NamespaceAccessControl
+    protected async exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const storageKey = this.key(`team_${teamId}`, namespace, key);
+        return this.storage.has(storageKey);
+    }
+
+    @NKVRAM.NamespaceAccessControl
+    public async list(acRequest: AccessRequest, namespace: string): Promise<{ key: string; data: StorageData }[]> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const prefix = this.key(`team_${teamId}`, namespace);
+        const results: { key: string; data: StorageData }[] = [];
+
+        // Find all keys that start with the prefix
+        for (const [storageKey, value] of this.storage.entries()) {
+            if (storageKey.startsWith(prefix + ':')) {
+                // Extract the actual key (remove prefix and separator)
+                const actualKey = storageKey.substring(prefix.length + 1);
+                results.push({
+                    key: actualKey,
+                    data: value as StorageData,
+                });
+            }
+        }
+
+        return results;
+    }
+
+    @NKVRAM.NamespaceAccessControl
+    public async deleteAll(acRequest: AccessRequest, namespace: string): Promise<void> {
+        const teamId = await this.accountConnector.getCandidateTeam(acRequest.candidate);
+        const prefix = this.key(`team_${teamId}`, namespace);
+        const keysToDelete: string[] = [];
+
+        // Find all keys that start with the prefix (excluding the namespace sentinel)
+        for (const storageKey of this.storage.keys()) {
+            if (storageKey.startsWith(prefix + ':')) {
+                keysToDelete.push(storageKey);
+            }
+        }
+
+        // Delete all found keys
+        for (const key of keysToDelete) {
+            this.storage.delete(key);
+        }
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        // Delegate ACL management to the cache connector (Redis)
+        return this.cacheConnector.getResourceACL(resourceId, candidate);
+    }
+
+    /**
+     * Get all keys matching a prefix (for internal use)
+     */
+    private getKeysByPrefix(prefix: string): string[] {
+        const keys: string[] = [];
+        for (const key of this.storage.keys()) {
+            if (key.startsWith(prefix)) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+
+    /**
+     * Clear all data (useful for testing)
+     */
+    public clearAll(): void {
+        this.storage.clear();
+        this.namespaces.clear();
+    }
+
+    /**
+     * Get storage statistics
+     */
+    public getStats(): { totalKeys: number; totalNamespaces: number } {
+        return {
+            totalKeys: this.storage.size,
+            totalNamespaces: this.namespaces.size,
+        };
+    }
+
+    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(`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/connectors/NKVRedis.class.ts

@@ -0,0 +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;
+    }
+}

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

@@ -0,0 +1,12 @@
+//==[ 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';
+export class NKVService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.NKV, 'Redis', NKVRedis);
+        ConnectorService.register(TConnectorService.NKV, 'RAM', NKVRAM);
+    }
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+    }
+}

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

@@ -0,0 +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;
+    }
+}

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

@@ -0,0 +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);
+    }
+}