@smythos/sre 1.6.1 → 1.6.8

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

@@ -1,98 +1,98 @@
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
-import { SecureConnector } from '@sre/Security/SecureConnector.class';
-
-export interface CodeInput {
-    code: string; // Main code to execute
-    dependencies?: string; // Dependencies/imports/packages
-    files?: Record<string, string>; // Additional files (filename -> content)
-    inputs?: Record<string, any>; // Runtime input parameters
-}
-
-export interface CodeConfig {
-    runtime: string; // 'nodejs', 'python', 'java', etc.
-    timeout?: number; // Execution timeout in milliseconds
-    memoryLimit?: number; // Memory allocation in MB
-    environment?: Record<string, string>; // Environment variables
-    // Platform-specific settings
-    platformConfig?: Record<string, any>;
-}
-
-export interface CodeExecutionResult {
-    output: any; // The execution result/return value
-    executionTime: number; // Execution time in milliseconds
-    logs?: string[]; // Execution logs
-    errors?: string[]; // Error messages
-    success: boolean; // Whether execution succeeded
-}
-
-export interface CodePreparationResult {
-    prepared: boolean; // Whether preparation succeeded
-    errors?: string[]; // Preparation errors
-    warnings?: string[]; // Preparation warnings
-    metadata?: Record<string, any>; // Platform-specific preparation data
-}
-
-export interface CodeDeployment {
-    id: string; // Deployment identifier
-    status: string;
-    runtime: string;
-    createdAt: Date;
-    lastUsed?: Date;
-    lastUpdated?: Date;
-}
-
-export interface ICodeRequest {
-    // Core workflow
-    prepare(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
-    deploy(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
-    execute(codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
-
-    // Execute with existing deployment (for platforms that support it)
-    executeDeployment(codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
-
-    // Deployment management
-    listDeployments(codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
-    getDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
-    deleteDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
-}
-
-export abstract class CodeConnector extends SecureConnector {
-    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    // Abstract methods that concrete connectors must implement
-    protected abstract prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
-    protected abstract deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
-    protected abstract execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
-    protected abstract executeDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
-    protected abstract listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
-    protected abstract getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
-    protected abstract deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
-
-    public requester(candidate: AccessCandidate): ICodeRequest {
-        return {
-            prepare: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
-                return await this.prepare(candidate.readRequest, codeUID, input, config);
-            },
-            deploy: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
-                return await this.deploy(candidate.writeRequest, codeUID, input, config);
-            },
-            execute: async (codeUID: string, inputs: Record<string, any>, config: CodeConfig) => {
-                return await this.execute(candidate.readRequest, codeUID, inputs, config);
-            },
-            executeDeployment: async (codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig) => {
-                return await this.executeDeployment(candidate.readRequest, codeUID, deploymentId, inputs, config);
-            },
-            listDeployments: async (codeUID: string, config: CodeConfig) => {
-                return await this.listDeployments(candidate.readRequest, codeUID, config);
-            },
-            getDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
-                return await this.getDeployment(candidate.readRequest, codeUID, deploymentId, config);
-            },
-            deleteDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
-                await this.deleteDeployment(candidate.writeRequest, codeUID, deploymentId, config);
-            },
-        } as ICodeRequest;
-    }
-}
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+
+export interface CodeInput {
+    code: string; // Main code to execute
+    dependencies?: string; // Dependencies/imports/packages
+    files?: Record<string, string>; // Additional files (filename -> content)
+    inputs?: Record<string, any>; // Runtime input parameters
+}
+
+export interface CodeConfig {
+    runtime: string; // 'nodejs', 'python', 'java', etc.
+    timeout?: number; // Execution timeout in milliseconds
+    memoryLimit?: number; // Memory allocation in MB
+    environment?: Record<string, string>; // Environment variables
+    // Platform-specific settings
+    platformConfig?: Record<string, any>;
+}
+
+export interface CodeExecutionResult {
+    output: any; // The execution result/return value
+    executionTime: number; // Execution time in milliseconds
+    logs?: string[]; // Execution logs
+    errors?: string[]; // Error messages
+    success: boolean; // Whether execution succeeded
+}
+
+export interface CodePreparationResult {
+    prepared: boolean; // Whether preparation succeeded
+    errors?: string[]; // Preparation errors
+    warnings?: string[]; // Preparation warnings
+    metadata?: Record<string, any>; // Platform-specific preparation data
+}
+
+export interface CodeDeployment {
+    id: string; // Deployment identifier
+    status: string;
+    runtime: string;
+    createdAt: Date;
+    lastUsed?: Date;
+    lastUpdated?: Date;
+}
+
+export interface ICodeRequest {
+    // Core workflow
+    prepare(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+
+    // Execute with existing deployment (for platforms that support it)
+    executeDeployment(codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+
+    // Deployment management
+    listDeployments(codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
+    getDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
+    deleteDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
+}
+
+export abstract class CodeConnector extends SecureConnector {
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    // Abstract methods that concrete connectors must implement
+    protected abstract prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    protected abstract deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    protected abstract execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract executeDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
+    protected abstract getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
+    protected abstract deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
+
+    public requester(candidate: AccessCandidate): ICodeRequest {
+        return {
+            prepare: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
+                return await this.prepare(candidate.readRequest, codeUID, input, config);
+            },
+            deploy: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
+                return await this.deploy(candidate.writeRequest, codeUID, input, config);
+            },
+            execute: async (codeUID: string, inputs: Record<string, any>, config: CodeConfig) => {
+                return await this.execute(candidate.readRequest, codeUID, inputs, config);
+            },
+            executeDeployment: async (codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig) => {
+                return await this.executeDeployment(candidate.readRequest, codeUID, deploymentId, inputs, config);
+            },
+            listDeployments: async (codeUID: string, config: CodeConfig) => {
+                return await this.listDeployments(candidate.readRequest, codeUID, config);
+            },
+            getDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
+                return await this.getDeployment(candidate.readRequest, codeUID, deploymentId, config);
+            },
+            deleteDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
+                await this.deleteDeployment(candidate.writeRequest, codeUID, deploymentId, config);
+            },
+        } as ICodeRequest;
+    }
+}

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

@@ -1,172 +1,171 @@
-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 fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import { cacheTTL, createOrUpdateLambdaFunction, generateCodeHash, generateLambdaCode, getCurrentEnvironmentVariables, getDeployedCodeHash, getDeployedFunction, getLambdaFunctionName, getSortedObjectValues, invokeLambdaFunction, setDeployedCodeHash, updateDeployedCodeTTL, validateAsyncMainFunction, zipCode } from '@sre/helpers/AWSLambdaCode.helper';
-import { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
-import { Logger } from '@sre/helpers/Log.helper';
-
-const console = Logger('AWSLambda');
-
-export class AWSLambdaCode extends CodeConnector {
-    public name = 'AWSLambda';
-    private awsConfigs: AWSCredentials & AWSRegionConfig;
-
-    constructor(config: { region: string, accessKeyId: string, secretAccessKey: string }) {
-        super(config);
-        //if (!SmythRuntime.Instance) throw new Error('SRE not initialized');
-        this.awsConfigs = config;
-    }
-    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> {
-        const agentId = acRequest.candidate.id;
-        const functionName = getLambdaFunctionName(agentId, codeUID);
-        const [isLambdaExists, exisitingCodeHash, currentEnvVariables] = await Promise.all([
-            getDeployedFunction(functionName, this.awsConfigs),
-            getDeployedCodeHash(agentId, codeUID),
-            getCurrentEnvironmentVariables(acRequest.candidate.id, input.code),
-        ]);
-
-        // sorting values to get the same hash for the same env variables
-        const envValues = getSortedObjectValues(currentEnvVariables);
-
-        const codeHash = generateCodeHash(input.code, Object.keys(input.inputs), envValues);
-        if (isLambdaExists && exisitingCodeHash === codeHash) {
-            return {
-                id: functionName,
-                runtime: config.runtime,
-                createdAt: new Date(),
-                status: 'deployed',
-            };
-        }
-        const baseFolder = `${process.cwd()}/lambda_archives`;
-        if (!fs.existsSync(baseFolder)) {
-            fs.mkdirSync(baseFolder);
-        }
-        const directory = `${baseFolder}/${functionName}__${Date.now()}`;
-        try {
-            const { isValid, parameters, error, dependencies } = validateAsyncMainFunction(input.code);
-            if (!isValid) {
-                throw new Error(error || 'Invalid Code')
-            }
-            const lambdaCode = generateLambdaCode(input.code, parameters, currentEnvVariables);
-            // create folder
-            fs.mkdirSync(directory);
-            // create index.js file
-            fs.writeFileSync(path.join(directory, 'index.mjs'), lambdaCode);
-            // run command npm init
-            execSync('npm init -y', { cwd: directory });
-            // run command npm install
-            execSync(`npm install ${dependencies.join(' ')}`, { cwd: directory });
-
-            const zipFilePath = await zipCode(directory);
-            await createOrUpdateLambdaFunction(functionName, zipFilePath, this.awsConfigs, currentEnvVariables);
-            await setDeployedCodeHash(agentId, codeUID, codeHash);
-            console.debug('Lambda function updated successfully!');
-            return {
-                id: functionName,
-                runtime: config.runtime,
-                createdAt: new Date(),
-                status: 'deploying',
-            };
-        } catch (error) {
-            throw error;
-        } finally {
-            try {
-                fs.rmSync(`${directory}`, { recursive: true, force: true });
-                fs.unlinkSync(`${directory}.zip`);
-            } catch (error) { }
-        }
-
-    }
-
-    public async execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult> {
-        try {
-            const agentId = acRequest.candidate.id;
-            const functionName = getLambdaFunctionName(agentId, codeUID);
-
-            const lambdaResponse = JSON.parse(await invokeLambdaFunction(functionName, inputs, this.awsConfigs));
-            const executionTime = lambdaResponse.executionTime;
-            await updateDeployedCodeTTL(agentId, codeUID, cacheTTL);
-            console.debug(
-                `Code result:\n ${typeof lambdaResponse.result === 'object' ? JSON.stringify(lambdaResponse.result, null, 2) : lambdaResponse.result
-                }\n`,
-            );
-            console.debug(`Execution time: ${executionTime}ms\n`);
-
-            const Output = lambdaResponse.result;
-            return {
-                output: Output,
-                executionTime: executionTime,
-                success: true,
-            };
-        } catch (error: any) {
-            console.error(`Error running code \n${error}\n`);
-            const _error = error?.response?.data || error?.message || error.toString();
-            const output = undefined; //prevents running next component if the code execution failed
-            return { output, 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[]> {
-        const agentId = acRequest.candidate.id;
-        const lambdaFunction = await getDeployedFunction(getLambdaFunctionName(agentId, codeUID), config.platformConfig as AWSCredentials & AWSRegionConfig);
-        if (lambdaFunction) {
-            return [
-                {
-                    id: lambdaFunction.functionName,
-                    runtime: lambdaFunction.runtime,
-                    createdAt: new Date(lambdaFunction.updatedAt),
-                    status: lambdaFunction.status,
-                    lastUpdated: new Date(lambdaFunction.updatedAt),
-                }
-            ]
-        }
-
-        return [];
-    }
-
-    public async getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null> {
-        const agentId = acRequest.candidate.id;
-        const lambdaFunction = await getDeployedFunction(getLambdaFunctionName(agentId, codeUID), config.platformConfig as AWSCredentials & AWSRegionConfig);
-        if (lambdaFunction) {
-            return {
-                id: lambdaFunction.functionName,
-                runtime: lambdaFunction.runtime,
-                createdAt: new Date(lambdaFunction.updatedAt),
-                status: lambdaFunction.status,
-                lastUpdated: new Date(lambdaFunction.updatedAt),
-            }
-        }
-        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 fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { cacheTTL, createOrUpdateLambdaFunction, generateCodeHash, generateLambdaCode, getCurrentEnvironmentVariables, getDeployedCodeHash, getDeployedFunction, getLambdaFunctionName, getSortedObjectValues, invokeLambdaFunction, setDeployedCodeHash, updateDeployedCodeTTL, validateAsyncMainFunction, zipCode } from '@sre/helpers/AWSLambdaCode.helper';
+import { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
+import { Logger } from '@sre/helpers/Log.helper';
+const console = Logger('AWSLambda');
+
+export class AWSLambdaCode extends CodeConnector {
+    public name = 'AWSLambda';
+    private awsConfigs: AWSCredentials & AWSRegionConfig;
+
+    constructor(config: { region: string, accessKeyId: string, secretAccessKey: string }) {
+        super(config);
+        //if (!SmythRuntime.Instance) throw new Error('SRE not initialized');
+        this.awsConfigs = config;
+    }
+    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> {
+        const agentId = acRequest.candidate.id;
+        const functionName = getLambdaFunctionName(agentId, codeUID);
+        const [isLambdaExists, exisitingCodeHash, currentEnvVariables] = await Promise.all([
+            getDeployedFunction(functionName, this.awsConfigs),
+            getDeployedCodeHash(agentId, codeUID),
+            getCurrentEnvironmentVariables(acRequest.candidate.id, input.code),
+        ]);
+
+        // sorting values to get the same hash for the same env variables
+        const envValues = getSortedObjectValues(currentEnvVariables);
+
+        const codeHash = generateCodeHash(input.code, Object.keys(input.inputs), envValues);
+        if (isLambdaExists && exisitingCodeHash === codeHash) {
+            return {
+                id: functionName,
+                runtime: config.runtime,
+                createdAt: new Date(),
+                status: 'deployed',
+            };
+        }
+        const baseFolder = `${process.cwd()}/lambda_archives`;
+        if (!fs.existsSync(baseFolder)) {
+            fs.mkdirSync(baseFolder);
+        }
+        const directory = `${baseFolder}/${functionName}__${Date.now()}`;
+        try {
+            const { isValid, parameters, error, dependencies } = validateAsyncMainFunction(input.code);
+            if (!isValid) {
+                throw new Error(error || 'Invalid Code')
+            }
+            const lambdaCode = generateLambdaCode(input.code, parameters, currentEnvVariables);
+            // create folder
+            fs.mkdirSync(directory);
+            // create index.js file
+            fs.writeFileSync(path.join(directory, 'index.mjs'), lambdaCode);
+            // run command npm init
+            execSync('npm init -y', { cwd: directory });
+            // run command npm install
+            execSync(`npm install ${dependencies.join(' ')}`, { cwd: directory });
+
+            const zipFilePath = await zipCode(directory);
+            await createOrUpdateLambdaFunction(functionName, zipFilePath, this.awsConfigs, currentEnvVariables);
+            await setDeployedCodeHash(agentId, codeUID, codeHash);
+            console.debug('Lambda function updated successfully!');
+            return {
+                id: functionName,
+                runtime: config.runtime,
+                createdAt: new Date(),
+                status: 'deploying',
+            };
+        } catch (error) {
+            throw error;
+        } finally {
+            try {
+                fs.rmSync(`${directory}`, { recursive: true, force: true });
+                fs.unlinkSync(`${directory}.zip`);
+            } catch (error) { }
+        }
+
+    }
+
+    public async execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult> {
+        try {
+            const agentId = acRequest.candidate.id;
+            const functionName = getLambdaFunctionName(agentId, codeUID);
+            
+            const lambdaResponse = JSON.parse(await invokeLambdaFunction(functionName, inputs, this.awsConfigs));
+            const executionTime = lambdaResponse.executionTime;
+            await updateDeployedCodeTTL(agentId, codeUID, cacheTTL);
+            console.debug(
+                `Code result:\n ${typeof lambdaResponse.result === 'object' ? JSON.stringify(lambdaResponse.result, null, 2) : lambdaResponse.result
+                }\n`,
+            );
+            console.debug(`Execution time: ${executionTime}ms\n`);
+
+            const Output = lambdaResponse.result;
+            return {
+                output: Output,
+                executionTime: executionTime,
+                success: true,
+            };
+        } catch (error: any) {
+            console.error(`Error running code \n${error}\n`);
+            const _error = error?.response?.data || error?.message || error.toString();
+            const output = undefined; //prevents running next component if the code execution failed
+            return { output, 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[]> {
+        const agentId = acRequest.candidate.id;
+        const lambdaFunction = await getDeployedFunction(getLambdaFunctionName(agentId, codeUID), config.platformConfig as AWSCredentials & AWSRegionConfig);
+        if (lambdaFunction) {
+            return [
+                {
+                    id: lambdaFunction.functionName,
+                    runtime: lambdaFunction.runtime,
+                    createdAt: new Date(lambdaFunction.updatedAt),
+                    status: lambdaFunction.status,
+                    lastUpdated: new Date(lambdaFunction.updatedAt),
+                }
+            ]
+        }
+
+        return [];
+    }
+
+    public async getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null> {
+        const agentId = acRequest.candidate.id;
+        const lambdaFunction = await getDeployedFunction(getLambdaFunctionName(agentId, codeUID), config.platformConfig as AWSCredentials & AWSRegionConfig);
+        if (lambdaFunction) {
+            return {
+                id: lambdaFunction.functionName,
+                runtime: lambdaFunction.runtime,
+                createdAt: new Date(lambdaFunction.updatedAt),
+                status: lambdaFunction.status,
+                lastUpdated: new Date(lambdaFunction.updatedAt),
+            }
+        }
+        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;
+    }
+}