@smythos/sre 1.5.50 → 1.5.52

package/src/subsystems/ComputeManager/Code.service/connectors/ECMASandbox.class.ts

@@ -1,131 +1,131 @@
-import { IAccessCandidate, TAccessLevel } from '@sre/types/ACL.types';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { Logger } from '@sre/helpers/Log.helper';
-import axios from 'axios';
-import { generateExecutableCode, runJs } from '@sre/helpers/ECMASandbox.helper';
-import { validateAsyncMainFunction } from '@sre/helpers/AWSLambdaCode.helper';
-
-const console = Logger('ECMASandbox');
-export class ECMASandbox extends CodeConnector {
-    public name = 'ECMASandbox';
-    private sandboxUrl: string;
-
-    constructor(config: { sandboxUrl: string }) {
-        super(config);
-        this.sandboxUrl = config.sandboxUrl;
-    }
-    public async prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult> {
-        return {
-            prepared: true,
-            errors: [],
-            warnings: [],
-        };
-    }
-
-    public async deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment> {
-        return {
-            id: codeUID,
-            runtime: config.runtime,
-            createdAt: new Date(),
-            status: 'Deployed',
-        };
-    }
-
-    public async execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult> {
-        try {
-            const { isValid, error, parameters } = validateAsyncMainFunction(inputs.code);
-            if (!isValid) {
-                return {
-                    output: undefined,
-                    executionTime: 0,
-                    success: false,
-                    errors: [error],
-                };
-            }
-            const executableCode = generateExecutableCode(inputs.code, parameters, inputs.inputs);
-            if (!this.sandboxUrl) {
-                //Temporarily disable the builtin ECMASandbox
-
-                // run js code in isolated vm
-
-                console.debug('Running code in isolated vm');
-                const executionStartTime = Date.now();
-                const result = await runJs(executableCode);
-                const executionTime = Date.now() - executionStartTime;
-                console.debug(`Code result: ${result}`);
-                return {
-                    output: result,
-                    executionTime,
-                    success: true,
-                    errors: [],
-
-                };
-            } else {
-                console.debug('Running code in remote sandbox');
-                const executionStartTime = Date.now();
-                const result: any = await axios.post(this.sandboxUrl, { code: executableCode }).catch((error) => ({ error }));
-                const executionTime = Date.now() - executionStartTime;
-                if (result.error) {
-                    const error = result.error?.response?.data || result.error?.message || result.error.toString() || 'Unknown error';
-                    console.error(`Error running code: ${JSON.stringify(error, null, 2)}`);
-                    return {
-                        output: undefined,
-                        executionTime,
-                        success: false,
-                        errors: [error],
-                    };
-                } else {
-                    console.debug(`Code result: ${result?.data?.Output}`);
-                    return {
-                        output: result.data?.Output,
-                        executionTime,
-                        success: true,
-                        errors: [],
-                    };
-                }
-            }
-        } catch (error) {
-            console.error(`Error running code: ${error}`);
-            return {
-                output: undefined,
-                executionTime: 0,
-                success: false,
-                errors: [error],
-            };
-        }
-    }
-    public async executeDeployment(
-        acRequest: AccessRequest,
-        codeUID: string,
-        deploymentId: string,
-        inputs: Record<string, any>,
-        config: CodeConfig
-    ): Promise<CodeExecutionResult> {
-        const result = await this.execute(acRequest, codeUID, inputs, config);
-        return result;
-    }
-
-    public async listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]> {
-        return [];
-    }
-
-    public async getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null> {
-        return null;
-    }
-
-    public async deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string): Promise<void> {
-        return;
-    }
-
-    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
-        const acl = new ACL();
-
-        //give Read access everytime
-        //FIXME: !!!!!! IMPORTANT !!!!!!  this implementation have to be changed in order to reflect the security model of AWS Lambda
-        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
-
-        return acl;
-    }
-}
+import { IAccessCandidate, TAccessLevel } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { Logger } from '@sre/helpers/Log.helper';
+import axios from 'axios';
+import { generateExecutableCode, runJs } from '@sre/helpers/ECMASandbox.helper';
+import { validateAsyncMainFunction } from '@sre/helpers/AWSLambdaCode.helper';
+
+const console = Logger('ECMASandbox');
+export class ECMASandbox extends CodeConnector {
+    public name = 'ECMASandbox';
+    private sandboxUrl: string;
+
+    constructor(config: { sandboxUrl: string }) {
+        super(config);
+        this.sandboxUrl = config.sandboxUrl;
+    }
+    public async prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult> {
+        return {
+            prepared: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+
+    public async deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment> {
+        return {
+            id: codeUID,
+            runtime: config.runtime,
+            createdAt: new Date(),
+            status: 'Deployed',
+        };
+    }
+
+    public async execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult> {
+        try {
+            const { isValid, error, parameters } = validateAsyncMainFunction(inputs.code);
+            if (!isValid) {
+                return {
+                    output: undefined,
+                    executionTime: 0,
+                    success: false,
+                    errors: [error],
+                };
+            }
+            const executableCode = generateExecutableCode(inputs.code, parameters, inputs.inputs);
+            if (!this.sandboxUrl) {
+                //Temporarily disable the builtin ECMASandbox
+
+                // run js code in isolated vm
+
+                console.debug('Running code in isolated vm');
+                const executionStartTime = Date.now();
+                const result = await runJs(executableCode);
+                const executionTime = Date.now() - executionStartTime;
+                console.debug(`Code result: ${result}`);
+                return {
+                    output: result,
+                    executionTime,
+                    success: true,
+                    errors: [],
+
+                };
+            } else {
+                console.debug('Running code in remote sandbox');
+                const executionStartTime = Date.now();
+                const result: any = await axios.post(this.sandboxUrl, { code: executableCode }).catch((error) => ({ error }));
+                const executionTime = Date.now() - executionStartTime;
+                if (result.error) {
+                    const error = result.error?.response?.data || result.error?.message || result.error.toString() || 'Unknown error';
+                    console.error(`Error running code: ${JSON.stringify(error, null, 2)}`);
+                    return {
+                        output: undefined,
+                        executionTime,
+                        success: false,
+                        errors: [error],
+                    };
+                } else {
+                    console.debug(`Code result: ${result?.data?.Output}`);
+                    return {
+                        output: result.data?.Output,
+                        executionTime,
+                        success: true,
+                        errors: [],
+                    };
+                }
+            }
+        } catch (error) {
+            console.error(`Error running code: ${error}`);
+            return {
+                output: undefined,
+                executionTime: 0,
+                success: false,
+                errors: [error],
+            };
+        }
+    }
+    public async executeDeployment(
+        acRequest: AccessRequest,
+        codeUID: string,
+        deploymentId: string,
+        inputs: Record<string, any>,
+        config: CodeConfig
+    ): Promise<CodeExecutionResult> {
+        const result = await this.execute(acRequest, codeUID, inputs, config);
+        return result;
+    }
+
+    public async listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]> {
+        return [];
+    }
+
+    public async getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null> {
+        return null;
+    }
+
+    public async deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string): Promise<void> {
+        return;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        const acl = new ACL();
+
+        //give Read access everytime
+        //FIXME: !!!!!! IMPORTANT !!!!!!  this implementation have to be changed in order to reflect the security model of AWS Lambda
+        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+
+        return acl;
+    }
+}

package/src/subsystems/ComputeManager/Code.service/index.ts

@@ -1,13 +1,13 @@
-//==[ SRE: Storage ]======================
-
-import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { AWSLambdaCode } from './connectors/AWSLambdaCode.class';
-import { ECMASandbox } from './connectors/ECMASandbox.class';
-
-export class CodeService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.Code, 'AWSLambda', AWSLambdaCode);
-        ConnectorService.register(TConnectorService.Code, 'ECMASandbox', ECMASandbox);
-    }
-}
+//==[ SRE: Storage ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { AWSLambdaCode } from './connectors/AWSLambdaCode.class';
+import { ECMASandbox } from './connectors/ECMASandbox.class';
+
+export class CodeService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Code, 'AWSLambda', AWSLambdaCode);
+        ConnectorService.register(TConnectorService.Code, 'ECMASandbox', ECMASandbox);
+    }
+}

package/src/subsystems/IO/CLI.service/CLIConnector.ts

@@ -1,47 +1,47 @@
-import { Connector } from '@sre/Core/Connector.class';
-import { getMainArgs, parseCLIArgs } from '@sre/utils/cli.utils';
-
-export class CLIConnector extends Connector {
-    public name = 'CLI';
-    public params: any;
-    constructor(protected _settings?: any) {
-        super(_settings);
-        this.params = this.parse(process.argv);
-    }
-
-    /**
-     * Parses the command line arguments, and returns the parsed arguments object
-     * if args is provided, it will only parse the provided args
-     * @param argv The command line arguments, usually process.argv
-     * @param args The arguments to parse
-     * @returns
-     */
-    public parse(argv: string[], args?: string | string[]) {
-        let _keys = args;
-        if (_keys && !Array.isArray(_keys)) _keys = [_keys];
-
-        const argsList = _keys || getMainArgs(argv);
-        const params = parseCLIArgs(argsList, argv);
-
-        return params;
-    }
-
-    /**
-     * Get the parsed arguments as an object
-     * @param args The arguments to get
-     * @returns
-     */
-    public get(args: string | string[]) {
-        let _keys = args;
-        if (!Array.isArray(_keys)) _keys = [_keys];
-
-        const result = {};
-        _keys.forEach((key) => {
-            if (this.params[key]) {
-                result[key] = this.params[key];
-            }
-        });
-
-        return result;
-    }
-}
+import { Connector } from '@sre/Core/Connector.class';
+import { getMainArgs, parseCLIArgs } from '@sre/utils/cli.utils';
+
+export class CLIConnector extends Connector {
+    public name = 'CLI';
+    public params: any;
+    constructor(protected _settings?: any) {
+        super(_settings);
+        this.params = this.parse(process.argv);
+    }
+
+    /**
+     * Parses the command line arguments, and returns the parsed arguments object
+     * if args is provided, it will only parse the provided args
+     * @param argv The command line arguments, usually process.argv
+     * @param args The arguments to parse
+     * @returns
+     */
+    public parse(argv: string[], args?: string | string[]) {
+        let _keys = args;
+        if (_keys && !Array.isArray(_keys)) _keys = [_keys];
+
+        const argsList = _keys || getMainArgs(argv);
+        const params = parseCLIArgs(argsList, argv);
+
+        return params;
+    }
+
+    /**
+     * Get the parsed arguments as an object
+     * @param args The arguments to get
+     * @returns
+     */
+    public get(args: string | string[]) {
+        let _keys = args;
+        if (!Array.isArray(_keys)) _keys = [_keys];
+
+        const result = {};
+        _keys.forEach((key) => {
+            if (this.params[key]) {
+                result[key] = this.params[key];
+            }
+        });
+
+        return result;
+    }
+}

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

@@ -1,9 +1,9 @@
-import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { CLIConnector } from './CLIConnector';
-
-export class CLIService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.CLI, 'CLI', CLIConnector);
-    }
-}
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { CLIConnector } from './CLIConnector';
+
+export class CLIService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.CLI, 'CLI', CLIConnector);
+    }
+}

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

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

@@ -1,28 +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 name: string = 'ConsoleLog';
-    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();
-    }
-}
+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 name: string = 'ConsoleLog';
+    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();
+    }
+}

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

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

@@ -1,43 +1,43 @@
-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
- * The NKV Connectors are used to store and retrieve data in a namespace-key-value format.
- * It is generally used by internal connectors to index data : for example, some vectorDB providers may use it to keep track of inserted vectors.
- */
-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 }[]>;
-}
+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
+ * The NKV Connectors are used to store and retrieve data in a namespace-key-value format.
+ * It is generally used by internal connectors to index data : for example, some vectorDB providers may use it to keep track of inserted vectors.
+ */
+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 }[]>;
+}