feat(package): include additional files into the final function package

Author: Inqnuam

README.md

@@ -100,13 +100,18 @@ client
   });
 ```
 
+---
+
 ### Environment variable
 
 Lambdas are executed in worker threads. Only variables declared in your `serverless.yml` are injected into `process.env` except `IS_LOCAL`, `LOCAL_PORT` and `NODE_ENV`.
 
-### Disable functions
+---
+
+### Extended properties
 
-Adding the param `online: false` will omit the deployement of your Lambda.
+- `online`  
+  Adding the param `online: false` will omit the deployement of your Lambda.
 
 ```yaml
 functions:
@@ -115,9 +120,25 @@ functions:
     online: false
 ```
 
+- `files`  
+  include additionnal files into the package.
+
+```yaml
+functions:
+  myAwsomeLambda:
+    handler: src/handlers/awsomeLambda.default
+    files:
+      - ./resources/some/file.png
+      - ./resources/anotherFile.pdf
+```
+
+- `virtualEnvs`  
+  on key-value object which will only be available inside [defineConfig](resources/defineConfig.md).  
+  by default virtualEnvs are inherited from custom > virtualEnvs if exists.
+
 ---
 
-## Advanced configuration:
+### Advanced configuration:
 
 To have more control over the plugin you can passe a config file via `configPath` param in plugin options:
 
@@ -138,7 +159,7 @@ See [defineConfig](resources/defineConfig.md) for advanced configuration.
 
 ---
 
-## Plugins:
+### Plugins:
 
 - [AWS Local S3](resources/s3.md)
 - [AWS Local SNS](resources/sns.md)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-aws-lambda",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "description": "AWS Application Load Balancer and API Gateway - Lambda dev tool for Serverless. Allows Express synthax in handlers. Supports packaging, local invoking and offline real ALB and APG lambda server mocking.",
   "author": "Inqnuam",
   "license": "MIT",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@types/serverless": "^3.12.10",
     "archiver": "^5.3.1",
-    "esbuild": "0.17.10",
+    "esbuild": "0.17.11",
     "serve-static": "^1.15.0"
   },
   "devDependencies": {

src/index.ts

@@ -50,9 +50,12 @@ class ServerlessAwsLambda extends Daemon {
     // @ts-ignore
     this.isDeploying = this.serverless.processedInput.commands.includes("deploy");
 
-    this.nodeVersion = this.serverless.service.provider.runtime?.replace(/[^0-9]/g, "");
-    if (!this.nodeVersion) {
-      throw new Error("Please provide NodeJS runtime version inside your serverless.yml > provider > runtime");
+    if (!this.serverless.service.provider.runtime) {
+      throw new Error("Please provide 'runtime' inside your serverless.yml > provider > runtime");
+    } else if (this.serverless.service.provider.runtime.startsWith("node")) {
+      this.nodeVersion = this.serverless.service.provider.runtime?.replace(/[^0-9]/g, "");
+    } else {
+      this.nodeVersion = "14";
     }
     this.watch = !this.isPackaging && !this.isDeploying;
     if (!this.watch) {
@@ -64,6 +67,7 @@ class ServerlessAwsLambda extends Daemon {
       properties: {
         virtualEnvs: { type: "object" },
         online: { type: "boolean" },
+        files: { type: "array" },
       },
     });
 
@@ -223,8 +227,14 @@ class ServerlessAwsLambda extends Daemon {
         for (const l of packageLambdas.filter((x) => x.online)) {
           const slsDeclaration = this.serverless.service.getFunction(l.name) as Serverless.FunctionDefinitionHandler;
 
+          if (typeof slsDeclaration.package?.artifact == "string") {
+            continue;
+          }
+
+          // @ts-ignore
+          const filesToInclude = slsDeclaration.files;
           const zipableBundledFilePath = l.esOutputPath.slice(0, -3);
-          const zipOutputPath = await zip(zipableBundledFilePath, l.outName);
+          const zipOutputPath = await zip(zipableBundledFilePath, l.outName, filesToInclude);
 
           // @ts-ignore
           slsDeclaration.package = { ...slsDeclaration.package, disable: true, artifact: zipOutputPath };
@@ -278,16 +288,23 @@ class ServerlessAwsLambda extends Daemon {
     if (this.invokeName) {
       functionsNames = functionsNames.filter((x) => x == this.invokeName);
     }
+    const defaultRuntime = this.serverless.service.provider.runtime;
     const resources = getResources(this.serverless);
     // @ts-ignore
     const Outputs = this.serverless.service.resources?.Outputs;
     const lambdas = functionsNames.reduce((accum: any[], funcName: string) => {
       const lambda = funcs[funcName];
 
+      if (lambda.runtime && !lambda.runtime.startsWith("node")) {
+        return accum;
+      } else if (!defaultRuntime?.startsWith("node") && (!lambda.runtime || !lambda.runtime.startsWith("node"))) {
+        return accum;
+      }
       const handlerPath = (lambda as Serverless.FunctionDefinitionHandler).handler;
-      const lastPointIndex = handlerPath.lastIndexOf(".");
-      const handlerName = handlerPath.slice(lastPointIndex + 1);
-      const esEntryPoint = path.join(cwd, handlerPath.slice(0, lastPointIndex));
+      const ext = path.extname(handlerPath);
+      const handlerName = ext.slice(1);
+      const esEntryPoint = path.posix.resolve(handlerPath.replace(ext, ""));
+
       const region = this.runtimeConfig.environment.AWS_REGION ?? this.runtimeConfig.environment.REGION;
 
       const slsDeclaration: any = this.serverless.service.getFunction(funcName);

src/lib/parseEvents/ddbStream.ts

@@ -1,6 +1,11 @@
 import { log } from "../utils/colorize";
 import { parseDestination } from "./index";
 
+enum StreamProps {
+  batchSize = 100,
+  minRecordAge = 60,
+  maxRecordAge = 604800,
+}
 const getTableNameFromResources = (ddbStreamTables: any, Outputs: any, obj: any) => {
   const [key, value] = Object.entries(obj)?.[0];
 
@@ -74,7 +79,31 @@ export const parseDdbStreamDefinitions = (Outputs: any, resources: any, event: a
     }
 
     if (parsedEvent.TableName) {
-      parsedEvent.batchSize = val.batchSize ?? 100;
+      if (!isNaN(val.batchSize) && val.batchSize > 0) {
+        parsedEvent.batchSize = val.batchSize;
+      } else {
+        parsedEvent.batchSize = StreamProps.batchSize;
+      }
+
+      if (!isNaN(val.batchWindow) && val.batchWindow > 0) {
+        parsedEvent.batchWindow = val.batchWindow;
+      }
+
+      if (
+        !isNaN(val.maximumRecordAgeInSeconds) &&
+        parsedEvent.maximumRecordAgeInSeconds >= StreamProps.minRecordAge &&
+        parsedEvent.maximumRecordAgeInSeconds <= StreamProps.maxRecordAge
+      ) {
+        parsedEvent.maximumRecordAgeInSeconds = val.maximumRecordAgeInSeconds;
+      }
+
+      if (!isNaN(val.maximumRetryAttempts) && val.maximumRetryAttempts > 0) {
+        parsedEvent.maximumRetryAttempts = val.maximumRetryAttempts;
+      }
+
+      if ("bisectBatchOnFunctionError" in val) {
+        parsedEvent.bisectBatchOnFunctionError = val.bisectBatchOnFunctionError;
+      }
 
       if (val.functionResponseType) {
         parsedEvent.functionResponseType = val.functionResponseType;

src/lib/runtime/lambdaMock.ts

@@ -29,6 +29,10 @@ export interface IDdbEvent {
   StreamEnabled: boolean;
   StreamViewType?: string;
   batchSize?: number;
+  batchWindow?: number;
+  maximumRecordAgeInSeconds?: number;
+  maximumRetryAttempts?: number;
+  bisectBatchOnFunctionError?: boolean;
   functionResponseType?: string;
   filterPatterns?: any;
   onFailure?: IDestination;

src/lib/utils/zip.ts

@@ -1,31 +1,36 @@
 import archiver from "archiver";
 import { createReadStream, createWriteStream } from "fs";
 import { access } from "fs/promises";
-import { basename, dirname } from "path";
+import path from "path";
 
-export const zip = (filePath: string, zipName: string) => {
-  return new Promise((resolve) => {
+export const zip = (filePath: string, zipName: string, include?: string[]) => {
+  return new Promise(async (resolve) => {
     const archive = archiver("zip", {
       zlib: { level: 9 },
     });
 
-    const zipOutputPath = `${dirname(filePath)}/${zipName}.zip`;
+    const zipOutputPath = `${path.dirname(filePath)}/${zipName}.zip`;
     const output = createWriteStream(zipOutputPath);
 
     archive.on("finish", () => {
       resolve(zipOutputPath);
     });
     archive.pipe(output);
 
-    const fileName = basename(filePath) + ".js";
+    const fileName = path.basename(filePath) + ".js";
     archive.append(createReadStream(`${filePath}.js`), { name: fileName });
 
-    // NOTE: do we really need sourcemaps in AWS ?
-    // const sourceMapPath = filePath + ".js.map";
-    // try {
-    //   await access(sourceMapPath);
-    //   archive.append(createReadStream(`${filePath}.js.map`), { name: fileName + ".map" });
-    // } catch (error) {}
+    if (include && include.every((x) => typeof x == "string")) {
+      for (const file of include) {
+        const includPath = path.resolve(file);
+        try {
+          await access(includPath);
+          archive.append(createReadStream(includPath), { name: file });
+        } catch (error) {
+          console.error(error);
+        }
+      }
+    }
 
     archive.finalize();
   });