@emarketeer/ts-microservice-commons 10.0.0 → 10.2.0

package/dist/cdk/cjs/index.js

@@ -9,6 +9,8 @@ var awsLogs = require('aws-cdk-lib/aws-logs');
 var constructs = require('constructs');
 var awsSsm = require('aws-cdk-lib/aws-ssm');
 var path = require('path');
+var fs = require('fs');
+var child_process = require('child_process');
 var awsDynamodb = require('aws-cdk-lib/aws-dynamodb');
 var awsApigateway = require('aws-cdk-lib/aws-apigateway');
 var awsApigatewayv2 = require('aws-cdk-lib/aws-apigatewayv2');
@@ -46,6 +48,7 @@ function _interopNamespace(e) {
 
 var cdk__namespace = /*#__PURE__*/_interopNamespace(cdk);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var ec2__namespace = /*#__PURE__*/_interopNamespace(ec2);
 
 /**
@@ -458,29 +461,30 @@ const resolveRecapDevEndpoint = (scope) => {
 const DEFAULT_LAMBDA_RUNTIME = awsLambda.Runtime.NODEJS_24_X;
 
 const DEFAULT_HANDLERS_DIR = 'src/handlers';
-const DEFAULT_OUT_DIR = 'dist/handlers';
 /**
- * Resolve `handlerPath` into `codePath`, `handler`, and optionally `functionName`.
+ * Resolve `handlerPath` into `entryFile`, `handler`, and optionally `functionName`.
  *
  * Given `handlerPath: 'src/handlers/capture-screenshot/capture-screenshot-from-url'`:
- * - `codePath` → `'dist/handlers/capture-screenshot/capture-screenshot-from-url'`
+ * - `entryFile` → `'src/handlers/capture-screenshot/capture-screenshot-from-url.ts'`
  * - `handler` → `'index.handler'`
  * - `functionName` → `'capture-screenshot-from-url'` (only when not explicitly provided)
  *
+ * When `codePath` is provided, `entryFile` is left unset — the construct will
+ * package `codePath` directly (no bundling).
+ *
  * When `handlerPath` is not provided, `functionName` is required.
- * `handler` and `codePath` may remain undefined if the caller has its own defaults.
  */
 function resolveHandlerPath(config) {
     const { handlerPath } = config;
     if (handlerPath) {
         const normalised = handlerPath.replace(/\.ts$/, '');
-        const startsWithHandlersDir = normalised.startsWith(DEFAULT_HANDLERS_DIR + '/');
+        const startsWithHandlersDir = normalised.startsWith(`${DEFAULT_HANDLERS_DIR}/`);
         const containsSeparator = normalised.includes('/') || normalised.includes(path__namespace.sep);
         if (!startsWithHandlersDir && (path__namespace.isAbsolute(normalised) || containsSeparator)) {
             // A bare basename like 'get-data' is fine (treated as relative to
             // src/handlers). Anything with directory components must be rooted at
             // DEFAULT_HANDLERS_DIR — otherwise we'd silently produce e.g.
-            // 'dist/handlers/src/lambdas/foo' and fail at synth with an opaque
+            // 'src/lambdas/foo.ts' and fail at synth with an opaque
             // Code.fromAsset error far from the call site.
             throw new Error(`resolveHandlerPath: handlerPath "${handlerPath}" must either be a bare basename or start with "${DEFAULT_HANDLERS_DIR}/".`);
         }
@@ -490,7 +494,8 @@ function resolveHandlerPath(config) {
         return {
             functionName: config.functionName ?? path__namespace.basename(relative),
             handler: config.handler ?? 'index.handler',
-            codePath: config.codePath ?? path__namespace.join(DEFAULT_OUT_DIR, relative)
+            entryFile: config.codePath ? undefined : path__namespace.join(DEFAULT_HANDLERS_DIR, `${relative}.ts`),
+            codePath: config.codePath
         };
     }
     if (!config.functionName) {
@@ -503,6 +508,70 @@ function resolveHandlerPath(config) {
     };
 }
 
+const HANDLER_BUNDLER_RELATIVE_PATH = path__namespace.join('dist', 'handler-bundler.js');
+const PACKAGE_NAME = '@emarketeer/ts-microservice-commons';
+let cachedBundlerPath;
+function getHandlerBundlerPath() {
+    if (cachedBundlerPath) {
+        return cachedBundlerPath;
+    }
+    const cwd = process.cwd();
+    const candidates = [
+        path__namespace.join(cwd, 'node_modules', PACKAGE_NAME, HANDLER_BUNDLER_RELATIVE_PATH),
+        path__namespace.join(cwd, HANDLER_BUNDLER_RELATIVE_PATH)
+    ];
+    for (const candidate of candidates) {
+        if (fs__namespace.existsSync(candidate)) {
+            cachedBundlerPath = candidate;
+            return candidate;
+        }
+    }
+    throw new Error(`Could not locate the handler bundler. Searched:\n${candidates.map((c) => `  - ${c}`).join('\n')}\n`
+        + `Ensure ${PACKAGE_NAME} is installed.`);
+}
+/**
+ * Build the `Code` asset for a Lambda function.
+ *
+ * - When `codePath` is set, packages that directory directly (no bundling).
+ * - Otherwise bundles `entryFile` via the project handler bundler at synth
+ *   time, with overrides applied on top of the defaults.
+ *
+ * Bundling uses `assetHashType: OUTPUT` so the asset hash is computed from
+ * the bundled output rather than from the (transitive) source tree.
+ */
+function resolveLambdaCode(options) {
+    if (options.codePath) {
+        return awsLambda.Code.fromAsset(options.codePath);
+    }
+    if (!options.entryFile) {
+        throw new Error('resolveLambdaCode: either `entryFile` or `codePath` is required.');
+    }
+    const entry = path__namespace.resolve(options.entryFile);
+    if (!fs__namespace.existsSync(entry)) {
+        throw new Error(`resolveLambdaCode: entry file not found: ${entry}`);
+    }
+    const overrides = options.bundling;
+    const bundlerPath = getHandlerBundlerPath();
+    return awsLambda.Code.fromAsset(path__namespace.dirname(entry), {
+        assetHashType: cdk.AssetHashType.OUTPUT,
+        bundling: {
+            // CDK requires `image` even when local bundling succeeds. We never use
+            // the Docker fallback — `tryBundle` always returns true.
+            image: cdk.DockerImage.fromRegistry('node:24'),
+            local: {
+                tryBundle(outputDir) {
+                    const stdin = JSON.stringify({ entry, outDir: outputDir, overrides });
+                    child_process.execFileSync('node', [bundlerPath], {
+                        input: stdin,
+                        stdio: ['pipe', 'inherit', 'inherit']
+                    });
+                    return true;
+                }
+            }
+        }
+    });
+}
+
 class EmLambdaFunction extends constructs.Construct {
     constructor(scope, id, config) {
         super(scope, id);
@@ -539,14 +608,22 @@ class EmLambdaFunction extends constructs.Construct {
             });
         const handler = resolved.handler ?? config.handler;
         const codePath = resolved.codePath ?? config.codePath;
-        if (!handler || !codePath) {
-            throw new Error(`EmLambdaFunction requires either \`handlerPath\` or both \`handler\` and \`codePath\` for "${resolved.functionName}".`);
+        if (!handler) {
+            throw new Error(`EmLambdaFunction requires either \`handlerPath\` or \`handler\` for "${resolved.functionName}".`);
+        }
+        if (!resolved.entryFile && !codePath) {
+            throw new Error(`EmLambdaFunction requires either \`handlerPath\` or \`codePath\` for "${resolved.functionName}".`);
         }
+        const code = resolveLambdaCode({
+            entryFile: resolved.entryFile,
+            codePath,
+            bundling: config.bundling
+        });
         this.function = new awsLambda.Function(this, 'Function', {
             functionName,
             runtime: config.runtime ?? DEFAULT_LAMBDA_RUNTIME,
             handler,
-            code: awsLambda.Code.fromAsset(codePath),
+            code,
             memorySize: config.memorySize ?? 1024,
             timeout: config.timeout ?? cdk.Duration.seconds(15),
             environment: {
@@ -1827,7 +1904,15 @@ class LambdaWithQueue extends constructs.Construct {
         const resourceName = props.resourceName ?? shortName;
         const functionName = props.physicalName ?? generateLambdaName(props.stage, props.serviceName, shortName);
         const handler = resolved.handler ?? props.handler ?? 'index.handler';
-        const codePath = resolved.codePath ?? props.codePath ?? `./dist/handlers/${resourceName}`;
+        const codePath = resolved.codePath ?? props.codePath;
+        if (!resolved.entryFile && !codePath) {
+            throw new Error(`LambdaWithQueue requires either \`handlerPath\` or \`codePath\` for "${shortName}".`);
+        }
+        const code = resolveLambdaCode({
+            entryFile: resolved.entryFile,
+            codePath,
+            bundling: props.bundling
+        });
         if (props.reservedConcurrency === 0) {
             throw new Error(`reservedConcurrency:0 disables the Lambda entirely for ${shortName}. Omit the prop to use account-level concurrency.`);
         }
@@ -1860,7 +1945,7 @@ class LambdaWithQueue extends constructs.Construct {
             functionName,
             runtime: props.runtime ?? DEFAULT_LAMBDA_RUNTIME,
             handler,
-            code: awsLambda.Code.fromAsset(codePath),
+            code,
             architecture: props.architecture ?? awsLambda.Architecture.ARM_64,
             memorySize,
             timeout,
@@ -2165,16 +2250,9 @@ class EmStack extends cdk__namespace.Stack {
         const merged = this.mergeConfig(config);
         const resolved = resolveHandlerPath(merged);
         const functionName = resolved.functionName;
-        const handler = resolved.handler ?? merged.handler;
-        const codePath = resolved.codePath ?? merged.codePath;
-        if (!handler || !codePath) {
-            throw new Error(`createFunction() requires either \`handlerPath\` or all of \`functionName\`, \`handler\`, and \`codePath\` for "${functionName}".`);
-        }
         const fn = new EmLambdaFunction(this, id, {
             ...merged,
             functionName,
-            handler,
-            codePath,
             stage: merged.stage ?? this.stage,
             serviceName: merged.serviceName ?? this.serviceName,
             role: merged.role ?? this.sharedRole
@@ -2805,6 +2883,7 @@ exports.overrideFunctionLogicalIds = overrideFunctionLogicalIds;
 exports.overrideLayerLogicalId = overrideLayerLogicalId;
 exports.overrideRoleLogicalId = overrideRoleLogicalId;
 exports.resolveHandlerPath = resolveHandlerPath;
+exports.resolveLambdaCode = resolveLambdaCode;
 exports.resolveRecapDevEndpoint = resolveRecapDevEndpoint;
 exports.stageToUpperCase = stageToUpperCase;
 exports.toServerlessLogicalIdPrefix = toServerlessLogicalIdPrefix;