terraconstructs 0.0.25 → 0.1.0

package/lib/aws/compute/function-nodejs/function.d.ts

@@ -0,0 +1,99 @@
+import { Construct } from "constructs";
+import { BundlingOptions } from "./types";
+import { Code } from "../code";
+import { FunctionOptions, LambdaFunction } from "../function";
+import { Runtime } from "../runtime";
+/**
+ * Properties for a NodejsFunction
+ */
+export interface NodejsFunctionProps extends FunctionOptions {
+    /**
+     * Path to the entry file (JavaScript or TypeScript).
+     *
+     * @default - Derived from the name of the defining file and the construct's id.
+     * If the `NodejsFunction` is defined in `stack.ts` with `my-handler` as id
+     * (`new NodejsFunction(this, 'my-handler')`), the construct will look at `stack.my-handler.ts`
+     * and `stack.my-handler.js`.
+     */
+    readonly entry?: string;
+    /**
+     * The name of the exported handler in the entry file.
+     *
+     * * If the `code` property is supplied, then you must include the `handler` property. The handler should be the name of the file
+     * that contains the exported handler and the function that should be called when the AWS Lambda is invoked. For example, if
+     * you had a file called `myLambda.js` and the function to be invoked was `myHandler`, then you should input `handler` property as `myLambda.myHandler`.
+     *
+     * * If the `code` property is not supplied and the handler input does not contain a `.`, then the handler is prefixed with `index.` (index period). Otherwise,
+     * the handler property is not modified.
+     *
+     * @default handler
+     */
+    readonly handler?: string;
+    /**
+     * The runtime environment. Only runtimes of the Node.js family are
+     * supported.
+     *
+     * @default `Runtime.NODEJS_LATEST`
+     */
+    readonly runtime?: Runtime;
+    /**
+     * The `AWS_NODEJS_CONNECTION_REUSE_ENABLED` environment variable does not exist in the AWS SDK for JavaScript v3.
+     *
+     * This prop will be deprecated when the Lambda Node16 runtime is deprecated on June 12, 2024.
+     * See https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy
+     *
+     * Info for Node 16 runtimes / SDK v2 users:
+     *
+     * Whether to automatically reuse TCP connections when working with the AWS
+     * SDK for JavaScript v2.
+     *
+     * This sets the `AWS_NODEJS_CONNECTION_REUSE_ENABLED` environment variable
+     * to `1`.
+     *
+     * @see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html
+     *
+     * @default - false (obsolete) for runtimes >= Node 18, true for runtimes <= Node 16.
+     */
+    readonly awsSdkConnectionReuse?: boolean;
+    /**
+     * The path to the dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or `package-lock.json`).
+     *
+     * This will be used as the source for the volume mounted in the Docker
+     * container.
+     *
+     * Modules specified in `nodeModules` will be installed using the right
+     * installer (`yarn`, `pnpm`, `bun` or `npm`) along with this lock file.
+     *
+     * @default - the path is found by walking up parent directories searching for
+     *   a `yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or `package-lock.json` file
+     */
+    readonly depsLockFilePath?: string;
+    /**
+     * Bundling options
+     *
+     * @default - use default bundling options: no minify, no sourcemap, all
+     *   modules are bundled.
+     */
+    readonly bundling?: BundlingOptions;
+    /**
+     * The path to the directory containing project config files (`package.json` or `tsconfig.json`)
+     *
+     * @default - the directory containing the `depsLockFilePath`
+     */
+    readonly projectRoot?: string;
+    /**
+     * The code that will be deployed to the Lambda Handler. If included, then properties related to
+     * bundling of the code are ignored.
+     *
+     * * If the `code` field is specified, then you must include the `handler` property.
+     *
+     * @default - the code is bundled by esbuild
+     */
+    readonly code?: Code;
+}
+/**
+ * A Node.js Lambda function bundled using esbuild
+ */
+export declare class NodejsFunction extends LambdaFunction {
+    constructor(scope: Construct, id: string, props?: NodejsFunctionProps);
+}

package/lib/aws/compute/function-nodejs/function.js

@@ -0,0 +1,175 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodejsFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = require("fs");
+const path = require("path");
+const cdktf_1 = require("cdktf");
+const bundling_1 = require("./bundling");
+const package_manager_1 = require("./package-manager");
+const util_1 = require("./util");
+const architecture_1 = require("../architecture");
+const function_1 = require("../function");
+const runtime_1 = require("../runtime");
+/**
+ * A Node.js Lambda function bundled using esbuild
+ */
+class NodejsFunction extends function_1.LambdaFunction {
+    constructor(scope, id, props = {}) {
+        if (props.runtime && props.runtime.family !== runtime_1.RuntimeFamily.NODEJS) {
+            throw new Error("Only `NODEJS` runtimes are supported.");
+        }
+        const runtime = getRuntime(props);
+        if (props.code !== undefined) {
+            if (props.handler === undefined) {
+                throw new Error("Cannot determine handler when `code` property is specified. Use `handler` property to specify a handler.\n" +
+                    "The handler should be the name of the exported function to be invoked and the file containing that function.\n" +
+                    "For example, handler should be specified in the form `myFile.myFunction`");
+            }
+            super(scope, id, {
+                ...props,
+                runtime,
+                code: props.code,
+                handler: props.handler,
+            });
+        }
+        else {
+            // Entry and defaults
+            const entry = path.resolve(findEntry(id, props.entry));
+            const architecture = props.architecture ?? architecture_1.Architecture.X86_64;
+            const depsLockFilePath = findLockFile(props.depsLockFilePath);
+            const projectRoot = props.projectRoot ?? path.dirname(depsLockFilePath);
+            const handler = props.handler ?? "handler";
+            super(scope, id, {
+                ...props,
+                runtime,
+                code: bundling_1.Bundling.bundle(scope, {
+                    ...(props.bundling ?? {}),
+                    entry,
+                    runtime,
+                    architecture,
+                    depsLockFilePath,
+                    projectRoot,
+                }),
+                handler: handler.indexOf(".") !== -1 ? `${handler}` : `index.${handler}`,
+            });
+        }
+        // Enable connection reuse for aws-sdk v2, do not set for sdk v3
+        if ((0, util_1.isSdkV2Runtime)(runtime)) {
+            if (props.awsSdkConnectionReuse ?? true) {
+                this.addEnvironment("AWS_NODEJS_CONNECTION_REUSE_ENABLED", "1");
+            }
+        }
+        else {
+            if (props.awsSdkConnectionReuse) {
+                // "aws-cdk-lib/aws-lambda-nodejs:unusedSdkEvironmentVariable",
+                cdktf_1.Annotations.of(scope).addWarning("The AWS_NODEJS_CONNECTION_REUSE_ENABLED environment variable does not exist in SDK v3. You have explicitly set `awsSdkConnectionReuse`; please make sure this is intentional.");
+                this.addEnvironment("AWS_NODEJS_CONNECTION_REUSE_ENABLED", "1");
+            }
+        }
+    }
+}
+exports.NodejsFunction = NodejsFunction;
+_a = JSII_RTTI_SYMBOL_1;
+NodejsFunction[_a] = { fqn: "terraconstructs.aws.compute.NodejsFunction", version: "0.1.0" };
+/**
+ * default to NODEJS_LATEST.
+ */
+function getRuntime(props) {
+    return props.runtime ?? runtime_1.Runtime.NODEJS_LATEST;
+}
+/**
+ * Checks given lock file or searches for a lock file
+ */
+function findLockFile(depsLockFilePath) {
+    if (depsLockFilePath) {
+        if (!fs.existsSync(depsLockFilePath)) {
+            throw new Error(`Lock file at ${depsLockFilePath} doesn't exist`);
+        }
+        if (!fs.statSync(depsLockFilePath).isFile()) {
+            throw new Error("`depsLockFilePath` should point to a file");
+        }
+        return path.resolve(depsLockFilePath);
+    }
+    const lockFiles = (0, util_1.findUpMultiple)([
+        package_manager_1.LockFile.PNPM,
+        package_manager_1.LockFile.YARN,
+        package_manager_1.LockFile.BUN,
+        package_manager_1.LockFile.NPM,
+    ]);
+    if (lockFiles.length === 0) {
+        throw new Error("Cannot find a package lock file (`pnpm-lock.yaml`, `yarn.lock`, `bun.lockb` or `package-lock.json`). Please specify it with `depsLockFilePath`.");
+    }
+    if (lockFiles.length > 1) {
+        throw new Error(`Multiple package lock files found: ${lockFiles.join(", ")}. Please specify the desired one with \`depsLockFilePath\`.`);
+    }
+    return lockFiles[0];
+}
+/**
+ * Searches for an entry file. Preference order is the following:
+ * 1. Given entry file
+ * 2. A .ts file named as the defining file with id as suffix (defining-file.id.ts)
+ * 3. A .js file name as the defining file with id as suffix (defining-file.id.js)
+ * 4. A .mjs file name as the defining file with id as suffix (defining-file.id.mjs)
+ * 5. A .mts file name as the defining file with id as suffix (defining-file.id.mts)
+ * 6. A .cts file name as the defining file with id as suffix (defining-file.id.cts)
+ * 7. A .cjs file name as the defining file with id as suffix (defining-file.id.cjs)
+ */
+function findEntry(id, entry) {
+    if (entry) {
+        if (!/\.(jsx?|tsx?|cjs|cts|mjs|mts)$/.test(entry)) {
+            throw new Error("Only JavaScript or TypeScript entry files are supported.");
+        }
+        if (!fs.existsSync(entry)) {
+            throw new Error(`Cannot find entry file at ${entry}`);
+        }
+        return entry;
+    }
+    const definingFile = findDefiningFile();
+    const extname = path.extname(definingFile);
+    const tsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.ts`);
+    if (fs.existsSync(tsHandlerFile)) {
+        return tsHandlerFile;
+    }
+    const jsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.js`);
+    if (fs.existsSync(jsHandlerFile)) {
+        return jsHandlerFile;
+    }
+    const mjsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.mjs`);
+    if (fs.existsSync(mjsHandlerFile)) {
+        return mjsHandlerFile;
+    }
+    const mtsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.mts`);
+    if (fs.existsSync(mtsHandlerFile)) {
+        return mtsHandlerFile;
+    }
+    const ctsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.cts`);
+    if (fs.existsSync(ctsHandlerFile)) {
+        return ctsHandlerFile;
+    }
+    const cjsHandlerFile = definingFile.replace(new RegExp(`${extname}$`), `.${id}.cjs`);
+    if (fs.existsSync(cjsHandlerFile)) {
+        return cjsHandlerFile;
+    }
+    throw new Error(`Cannot find handler file ${tsHandlerFile}, ${jsHandlerFile}, ${mjsHandlerFile}, ${mtsHandlerFile}, ${ctsHandlerFile} or ${cjsHandlerFile}`);
+}
+/**
+ * Finds the name of the file where the `NodejsFunction` is defined
+ */
+function findDefiningFile() {
+    let definingIndex;
+    const sites = (0, util_1.callsites)();
+    for (const [index, site] of sites.entries()) {
+        if (site.getFunctionName() === "NodejsFunction") {
+            // The next site is the site where the NodejsFunction was created
+            definingIndex = index + 1;
+            break;
+        }
+    }
+    if (!definingIndex || !sites[definingIndex]) {
+        throw new Error("Cannot find defining file.");
+    }
+    return sites[definingIndex].getFileName();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.js","sourceRoot":"","sources":["../../../../src/aws/compute/function-nodejs/function.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Bundling } from \"./bundling\";\nimport { LockFile } from \"./package-manager\";\nimport { BundlingOptions } from \"./types\";\nimport { callsites, findUpMultiple, isSdkV2Runtime } from \"./util\";\nimport { Architecture } from \"../architecture\";\nimport { Code } from \"../code\";\nimport { FunctionOptions, LambdaFunction } from \"../function\";\nimport { Runtime, RuntimeFamily } from \"../runtime\";\n\n/**\n * Properties for a NodejsFunction\n */\nexport interface NodejsFunctionProps extends FunctionOptions {\n  /**\n   * Path to the entry file (JavaScript or TypeScript).\n   *\n   * @default - Derived from the name of the defining file and the construct's id.\n   * If the `NodejsFunction` is defined in `stack.ts` with `my-handler` as id\n   * (`new NodejsFunction(this, 'my-handler')`), the construct will look at `stack.my-handler.ts`\n   * and `stack.my-handler.js`.\n   */\n  readonly entry?: string;\n\n  /**\n   * The name of the exported handler in the entry file.\n   *\n   * * If the `code` property is supplied, then you must include the `handler` property. The handler should be the name of the file\n   * that contains the exported handler and the function that should be called when the AWS Lambda is invoked. For example, if\n   * you had a file called `myLambda.js` and the function to be invoked was `myHandler`, then you should input `handler` property as `myLambda.myHandler`.\n   *\n   * * If the `code` property is not supplied and the handler input does not contain a `.`, then the handler is prefixed with `index.` (index period). Otherwise,\n   * the handler property is not modified.\n   *\n   * @default handler\n   */\n  readonly handler?: string;\n\n  /**\n   * The runtime environment. Only runtimes of the Node.js family are\n   * supported.\n   *\n   * @default `Runtime.NODEJS_LATEST`\n   */\n  readonly runtime?: Runtime;\n\n  /**\n   * The `AWS_NODEJS_CONNECTION_REUSE_ENABLED` environment variable does not exist in the AWS SDK for JavaScript v3.\n   *\n   * This prop will be deprecated when the Lambda Node16 runtime is deprecated on June 12, 2024.\n   * See https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy\n   *\n   * Info for Node 16 runtimes / SDK v2 users:\n   *\n   * Whether to automatically reuse TCP connections when working with the AWS\n   * SDK for JavaScript v2.\n   *\n   * This sets the `AWS_NODEJS_CONNECTION_REUSE_ENABLED` environment variable\n   * to `1`.\n   *\n   * @see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html\n   *\n   * @default - false (obsolete) for runtimes >= Node 18, true for runtimes <= Node 16.\n   */\n  readonly awsSdkConnectionReuse?: boolean;\n\n  /**\n   * The path to the dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or `package-lock.json`).\n   *\n   * This will be used as the source for the volume mounted in the Docker\n   * container.\n   *\n   * Modules specified in `nodeModules` will be installed using the right\n   * installer (`yarn`, `pnpm`, `bun` or `npm`) along with this lock file.\n   *\n   * @default - the path is found by walking up parent directories searching for\n   *   a `yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or `package-lock.json` file\n   */\n  readonly depsLockFilePath?: string;\n\n  /**\n   * Bundling options\n   *\n   * @default - use default bundling options: no minify, no sourcemap, all\n   *   modules are bundled.\n   */\n  readonly bundling?: BundlingOptions;\n\n  /**\n   * The path to the directory containing project config files (`package.json` or `tsconfig.json`)\n   *\n   * @default - the directory containing the `depsLockFilePath`\n   */\n  readonly projectRoot?: string;\n\n  /**\n   * The code that will be deployed to the Lambda Handler. If included, then properties related to\n   * bundling of the code are ignored.\n   *\n   * * If the `code` field is specified, then you must include the `handler` property.\n   *\n   * @default - the code is bundled by esbuild\n   */\n  readonly code?: Code;\n}\n\n/**\n * A Node.js Lambda function bundled using esbuild\n */\nexport class NodejsFunction extends LambdaFunction {\n  constructor(scope: Construct, id: string, props: NodejsFunctionProps = {}) {\n    if (props.runtime && props.runtime.family !== RuntimeFamily.NODEJS) {\n      throw new Error(\"Only `NODEJS` runtimes are supported.\");\n    }\n\n    const runtime = getRuntime(props);\n\n    if (props.code !== undefined) {\n      if (props.handler === undefined) {\n        throw new Error(\n          \"Cannot determine handler when `code` property is specified. Use `handler` property to specify a handler.\\n\" +\n            \"The handler should be the name of the exported function to be invoked and the file containing that function.\\n\" +\n            \"For example, handler should be specified in the form `myFile.myFunction`\",\n        );\n      }\n\n      super(scope, id, {\n        ...props,\n        runtime,\n        code: props.code,\n        handler: props.handler,\n      });\n    } else {\n      // Entry and defaults\n      const entry = path.resolve(findEntry(id, props.entry));\n      const architecture = props.architecture ?? Architecture.X86_64;\n      const depsLockFilePath = findLockFile(props.depsLockFilePath);\n      const projectRoot = props.projectRoot ?? path.dirname(depsLockFilePath);\n      const handler = props.handler ?? \"handler\";\n\n      super(scope, id, {\n        ...props,\n        runtime,\n        code: Bundling.bundle(scope, {\n          ...(props.bundling ?? {}),\n          entry,\n          runtime,\n          architecture,\n          depsLockFilePath,\n          projectRoot,\n        }),\n        handler:\n          handler.indexOf(\".\") !== -1 ? `${handler}` : `index.${handler}`,\n      });\n    }\n\n    // Enable connection reuse for aws-sdk v2, do not set for sdk v3\n    if (isSdkV2Runtime(runtime)) {\n      if (props.awsSdkConnectionReuse ?? true) {\n        this.addEnvironment(\"AWS_NODEJS_CONNECTION_REUSE_ENABLED\", \"1\");\n      }\n    } else {\n      if (props.awsSdkConnectionReuse) {\n        // \"aws-cdk-lib/aws-lambda-nodejs:unusedSdkEvironmentVariable\",\n        Annotations.of(scope).addWarning(\n          \"The AWS_NODEJS_CONNECTION_REUSE_ENABLED environment variable does not exist in SDK v3. You have explicitly set `awsSdkConnectionReuse`; please make sure this is intentional.\",\n        );\n        this.addEnvironment(\"AWS_NODEJS_CONNECTION_REUSE_ENABLED\", \"1\");\n      }\n    }\n  }\n}\n\n/**\n * default to NODEJS_LATEST.\n */\nfunction getRuntime(props: NodejsFunctionProps): Runtime {\n  return props.runtime ?? Runtime.NODEJS_LATEST;\n}\n\n/**\n * Checks given lock file or searches for a lock file\n */\nfunction findLockFile(depsLockFilePath?: string): string {\n  if (depsLockFilePath) {\n    if (!fs.existsSync(depsLockFilePath)) {\n      throw new Error(`Lock file at ${depsLockFilePath} doesn't exist`);\n    }\n\n    if (!fs.statSync(depsLockFilePath).isFile()) {\n      throw new Error(\"`depsLockFilePath` should point to a file\");\n    }\n\n    return path.resolve(depsLockFilePath);\n  }\n\n  const lockFiles = findUpMultiple([\n    LockFile.PNPM,\n    LockFile.YARN,\n    LockFile.BUN,\n    LockFile.NPM,\n  ]);\n\n  if (lockFiles.length === 0) {\n    throw new Error(\n      \"Cannot find a package lock file (`pnpm-lock.yaml`, `yarn.lock`, `bun.lockb` or `package-lock.json`). Please specify it with `depsLockFilePath`.\",\n    );\n  }\n  if (lockFiles.length > 1) {\n    throw new Error(\n      `Multiple package lock files found: ${lockFiles.join(\", \")}. Please specify the desired one with \\`depsLockFilePath\\`.`,\n    );\n  }\n\n  return lockFiles[0];\n}\n\n/**\n * Searches for an entry file. Preference order is the following:\n * 1. Given entry file\n * 2. A .ts file named as the defining file with id as suffix (defining-file.id.ts)\n * 3. A .js file name as the defining file with id as suffix (defining-file.id.js)\n * 4. A .mjs file name as the defining file with id as suffix (defining-file.id.mjs)\n * 5. A .mts file name as the defining file with id as suffix (defining-file.id.mts)\n * 6. A .cts file name as the defining file with id as suffix (defining-file.id.cts)\n * 7. A .cjs file name as the defining file with id as suffix (defining-file.id.cjs)\n */\nfunction findEntry(id: string, entry?: string): string {\n  if (entry) {\n    if (!/\\.(jsx?|tsx?|cjs|cts|mjs|mts)$/.test(entry)) {\n      throw new Error(\n        \"Only JavaScript or TypeScript entry files are supported.\",\n      );\n    }\n    if (!fs.existsSync(entry)) {\n      throw new Error(`Cannot find entry file at ${entry}`);\n    }\n    return entry;\n  }\n\n  const definingFile = findDefiningFile();\n  const extname = path.extname(definingFile);\n\n  const tsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.ts`,\n  );\n  if (fs.existsSync(tsHandlerFile)) {\n    return tsHandlerFile;\n  }\n\n  const jsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.js`,\n  );\n  if (fs.existsSync(jsHandlerFile)) {\n    return jsHandlerFile;\n  }\n\n  const mjsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.mjs`,\n  );\n  if (fs.existsSync(mjsHandlerFile)) {\n    return mjsHandlerFile;\n  }\n\n  const mtsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.mts`,\n  );\n  if (fs.existsSync(mtsHandlerFile)) {\n    return mtsHandlerFile;\n  }\n\n  const ctsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.cts`,\n  );\n  if (fs.existsSync(ctsHandlerFile)) {\n    return ctsHandlerFile;\n  }\n\n  const cjsHandlerFile = definingFile.replace(\n    new RegExp(`${extname}$`),\n    `.${id}.cjs`,\n  );\n  if (fs.existsSync(cjsHandlerFile)) {\n    return cjsHandlerFile;\n  }\n\n  throw new Error(\n    `Cannot find handler file ${tsHandlerFile}, ${jsHandlerFile}, ${mjsHandlerFile}, ${mtsHandlerFile}, ${ctsHandlerFile} or ${cjsHandlerFile}`,\n  );\n}\n\n/**\n * Finds the name of the file where the `NodejsFunction` is defined\n */\nfunction findDefiningFile(): string {\n  let definingIndex: number | undefined;\n  const sites = callsites();\n  for (const [index, site] of sites.entries()) {\n    if (site.getFunctionName() === \"NodejsFunction\") {\n      // The next site is the site where the NodejsFunction was created\n      definingIndex = index + 1;\n      break;\n    }\n  }\n\n  if (!definingIndex || !sites[definingIndex]) {\n    throw new Error(\"Cannot find defining file.\");\n  }\n\n  return sites[definingIndex].getFileName();\n}\n"]}

package/lib/aws/compute/function-nodejs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./function";
+export * from "./types";

package/lib/aws/compute/function-nodejs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./function"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvZnVuY3Rpb24tbm9kZWpzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0IsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZnVuY3Rpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4iXX0=

package/lib/aws/compute/function-nodejs/package-installation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Package installation
+ */
+export declare abstract class PackageInstallation {
+    static detect(module: string): PackageInstallation | undefined;
+    abstract readonly isLocal: boolean;
+    abstract readonly version: string;
+}

package/lib/aws/compute/function-nodejs/package-installation.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageInstallation = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("./util");
+/**
+ * Package installation
+ */
+class PackageInstallation {
+    static detect(module) {
+        try {
+            // Check local version first
+            const version = (0, util_1.tryGetModuleVersionFromRequire)(module);
+            if (version) {
+                return {
+                    isLocal: true,
+                    version,
+                };
+            }
+            // Fallback to a global version
+            const proc = (0, child_process_1.spawnSync)(module, ["--version"]);
+            if (proc.status === 0 && !proc.error) {
+                return {
+                    isLocal: false,
+                    version: proc.stdout.toString().trim(),
+                };
+            }
+            return undefined;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+}
+exports.PackageInstallation = PackageInstallation;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/function-nodejs/package-manager.d.ts

@@ -0,0 +1,33 @@
+import { EsbuildLogLevel } from "./types";
+interface PackageManagerProps {
+    readonly lockFile: string;
+    readonly installCommand: string[];
+    readonly runCommand: string[];
+    readonly argsSeparator?: string;
+}
+export declare enum LockFile {
+    NPM = "package-lock.json",
+    YARN = "yarn.lock",
+    BUN = "bun.lockb",
+    PNPM = "pnpm-lock.yaml"
+}
+/**
+ * A node package manager
+ */
+export declare class PackageManager {
+    /**
+     * Use a lock file path to determine the package manager to use. Optionally, specify a log level to
+     * control its verbosity.
+     * @param lockFilePath Path of the lock file
+     * @param logLevel optional log level @default LogLevel.INFO
+     * @returns the right PackageManager for that lock file
+     */
+    static fromLockFile(lockFilePath: string, logLevel?: EsbuildLogLevel): PackageManager;
+    readonly lockFile: string;
+    readonly installCommand: string[];
+    readonly runCommand: string[];
+    readonly argsSeparator?: string;
+    constructor(props: PackageManagerProps);
+    runBinCommand(bin: string): string;
+}
+export {};

package/lib/aws/compute/function-nodejs/package-manager.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManager = exports.LockFile = void 0;
+const os = require("os");
+const path = require("path");
+const types_1 = require("./types");
+var LockFile;
+(function (LockFile) {
+    LockFile["NPM"] = "package-lock.json";
+    LockFile["YARN"] = "yarn.lock";
+    LockFile["BUN"] = "bun.lockb";
+    LockFile["PNPM"] = "pnpm-lock.yaml";
+})(LockFile || (exports.LockFile = LockFile = {}));
+/**
+ * A node package manager
+ */
+class PackageManager {
+    /**
+     * Use a lock file path to determine the package manager to use. Optionally, specify a log level to
+     * control its verbosity.
+     * @param lockFilePath Path of the lock file
+     * @param logLevel optional log level @default LogLevel.INFO
+     * @returns the right PackageManager for that lock file
+     */
+    static fromLockFile(lockFilePath, logLevel) {
+        const lockFile = path.basename(lockFilePath);
+        switch (lockFile) {
+            case LockFile.YARN:
+                return new PackageManager({
+                    lockFile: LockFile.YARN,
+                    installCommand: logLevel && logLevel !== types_1.EsbuildLogLevel.INFO
+                        ? ["yarn", "install", "--no-immutable", "--silent"]
+                        : ["yarn", "install", "--no-immutable"],
+                    runCommand: ["yarn", "run"],
+                });
+            case LockFile.PNPM:
+                return new PackageManager({
+                    lockFile: LockFile.PNPM,
+                    installCommand: logLevel && logLevel !== types_1.EsbuildLogLevel.INFO
+                        ? [
+                            "pnpm",
+                            "install",
+                            "--reporter",
+                            "silent",
+                            "--config.node-linker=hoisted",
+                            "--config.package-import-method=clone-or-copy",
+                            "--no-prefer-frozen-lockfile",
+                        ]
+                        : [
+                            "pnpm",
+                            "install",
+                            "--config.node-linker=hoisted",
+                            "--config.package-import-method=clone-or-copy",
+                            "--no-prefer-frozen-lockfile",
+                        ],
+                    // --config.node-linker=hoisted to create flat node_modules without symlinks
+                    // --config.package-import-method=clone-or-copy to avoid hardlinking packages from the store
+                    // --no-prefer-frozen-lockfile (works the same as yarn's --no-immutable) Disable --frozen-lockfile that is enabled by default in CI environments (https://github.com/pnpm/pnpm/issues/1994).
+                    runCommand: ["pnpm", "exec"],
+                    argsSeparator: "--",
+                });
+            case LockFile.BUN:
+                return new PackageManager({
+                    lockFile: LockFile.BUN,
+                    // Bun's default is to not force `--frozen-lockfile`, so it's not specified here. If they ever add a
+                    // flag to explicitly disable it, we should add it here. https://github.com/oven-sh/bun/issues/16387
+                    installCommand: logLevel && logLevel !== types_1.EsbuildLogLevel.INFO
+                        ? ["bun", "install", "--backend", "copyfile", "--silent"]
+                        : ["bun", "install", "--backend", "copyfile"],
+                    runCommand: ["bun", "run"],
+                });
+            default:
+                return new PackageManager({
+                    lockFile: LockFile.NPM,
+                    installCommand: logLevel
+                        ? ["npm", "ci", "--loglevel", logLevel]
+                        : ["npm", "ci"],
+                    runCommand: ["npx", "--no-install"],
+                });
+        }
+    }
+    constructor(props) {
+        this.lockFile = props.lockFile;
+        this.installCommand = props.installCommand;
+        this.runCommand = props.runCommand;
+        this.argsSeparator = props.argsSeparator;
+    }
+    runBinCommand(bin) {
+        const [runCommand, ...runArgs] = this.runCommand;
+        return [
+            os.platform() === "win32" ? `${runCommand}.cmd` : runCommand,
+            ...runArgs,
+            ...(this.argsSeparator ? [this.argsSeparator] : []),
+            bin,
+        ].join(" ");
+    }
+}
+exports.PackageManager = PackageManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"package-manager.js","sourceRoot":"","sources":["../../../../src/aws/compute/function-nodejs/package-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from \"os\";\nimport * as path from \"path\";\nimport { EsbuildLogLevel } from \"./types\";\n\ninterface PackageManagerProps {\n  readonly lockFile: string;\n  readonly installCommand: string[];\n  readonly runCommand: string[];\n  readonly argsSeparator?: string;\n}\n\nexport enum LockFile {\n  NPM = \"package-lock.json\",\n  YARN = \"yarn.lock\",\n  BUN = \"bun.lockb\",\n  PNPM = \"pnpm-lock.yaml\",\n}\n\n/**\n * A node package manager\n */\nexport class PackageManager {\n  /**\n   * Use a lock file path to determine the package manager to use. Optionally, specify a log level to\n   * control its verbosity.\n   * @param lockFilePath Path of the lock file\n   * @param logLevel optional log level @default LogLevel.INFO\n   * @returns the right PackageManager for that lock file\n   */\n  public static fromLockFile(\n    lockFilePath: string,\n    logLevel?: EsbuildLogLevel,\n  ): PackageManager {\n    const lockFile = path.basename(lockFilePath);\n\n    switch (lockFile) {\n      case LockFile.YARN:\n        return new PackageManager({\n          lockFile: LockFile.YARN,\n          installCommand:\n            logLevel && logLevel !== EsbuildLogLevel.INFO\n              ? [\"yarn\", \"install\", \"--no-immutable\", \"--silent\"]\n              : [\"yarn\", \"install\", \"--no-immutable\"],\n          runCommand: [\"yarn\", \"run\"],\n        });\n      case LockFile.PNPM:\n        return new PackageManager({\n          lockFile: LockFile.PNPM,\n          installCommand:\n            logLevel && logLevel !== EsbuildLogLevel.INFO\n              ? [\n                  \"pnpm\",\n                  \"install\",\n                  \"--reporter\",\n                  \"silent\",\n                  \"--config.node-linker=hoisted\",\n                  \"--config.package-import-method=clone-or-copy\",\n                  \"--no-prefer-frozen-lockfile\",\n                ]\n              : [\n                  \"pnpm\",\n                  \"install\",\n                  \"--config.node-linker=hoisted\",\n                  \"--config.package-import-method=clone-or-copy\",\n                  \"--no-prefer-frozen-lockfile\",\n                ],\n          // --config.node-linker=hoisted to create flat node_modules without symlinks\n          // --config.package-import-method=clone-or-copy to avoid hardlinking packages from the store\n          // --no-prefer-frozen-lockfile (works the same as yarn's --no-immutable) Disable --frozen-lockfile that is enabled by default in CI environments (https://github.com/pnpm/pnpm/issues/1994).\n          runCommand: [\"pnpm\", \"exec\"],\n          argsSeparator: \"--\",\n        });\n      case LockFile.BUN:\n        return new PackageManager({\n          lockFile: LockFile.BUN,\n          // Bun's default is to not force `--frozen-lockfile`, so it's not specified here. If they ever add a\n          // flag to explicitly disable it, we should add it here. https://github.com/oven-sh/bun/issues/16387\n          installCommand:\n            logLevel && logLevel !== EsbuildLogLevel.INFO\n              ? [\"bun\", \"install\", \"--backend\", \"copyfile\", \"--silent\"]\n              : [\"bun\", \"install\", \"--backend\", \"copyfile\"],\n          runCommand: [\"bun\", \"run\"],\n        });\n      default:\n        return new PackageManager({\n          lockFile: LockFile.NPM,\n          installCommand: logLevel\n            ? [\"npm\", \"ci\", \"--loglevel\", logLevel]\n            : [\"npm\", \"ci\"],\n          runCommand: [\"npx\", \"--no-install\"],\n        });\n    }\n  }\n\n  public readonly lockFile: string;\n  public readonly installCommand: string[];\n  public readonly runCommand: string[];\n  public readonly argsSeparator?: string;\n\n  constructor(props: PackageManagerProps) {\n    this.lockFile = props.lockFile;\n    this.installCommand = props.installCommand;\n    this.runCommand = props.runCommand;\n    this.argsSeparator = props.argsSeparator;\n  }\n\n  public runBinCommand(bin: string): string {\n    const [runCommand, ...runArgs] = this.runCommand;\n    return [\n      os.platform() === \"win32\" ? `${runCommand}.cmd` : runCommand,\n      ...runArgs,\n      ...(this.argsSeparator ? [this.argsSeparator] : []),\n      bin,\n    ].join(\" \");\n  }\n}\n"]}