@emarketeer/ts-microservice-commons 8.2.2 → 9.0.0

package/dist/build-handlers.js

@@ -4,11 +4,108 @@ var path = require('path');
 var esbuild = require('esbuild');
 var fs = require('fs');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+/**
+ * Patterns that indicate a file exports a Lambda handler named `handler`.
+ *
+ * Covers:
+ *   export const/let/var handler = ...
+ *   export function handler / export async function handler
+ *   export { handler } and export { foo as handler } (the export *name* is
+ *     `handler`; the negative lookahead excludes `handler as somethingElse`
+ *     where `handler` is only the source identifier)
+ *   module.exports.handler = ... / exports.handler = ... (CJS interop)
+ *
+ * Intentionally excludes `export default function handler` — the esbuild wrapper
+ * accesses `unwrappedHandler.handler` (named export). Default exports compile to
+ * `module.exports.default`, so `.handler` is `undefined` at runtime.
+ *
+ * Not covered: `export * from './impl'` — resolving re-exports would require
+ * following the import graph. Files that match the source-naming convention
+ * but contain no recognised pattern produce a `console.warn` from
+ * `findEntryPoints`.
+ */
+const HANDLER_EXPORT_PATTERNS = [
+    /export\s+(const|let|var|function|async\s+function)\s+handler\b/,
+    /export\s*\{[^}]*\bhandler\b(?!\s*as\b)[^}]*\}/,
+    /(?:module\.)?exports\.handler\s*=/,
+];
+function containsHandlerExport(content) {
+    return HANDLER_EXPORT_PATTERNS.some(pattern => pattern.test(content));
+}
+/**
+ * Scans `handlersDir` recursively for TypeScript source files that export a
+ * Lambda handler. Returns esbuild-compatible `{ in, out }` entry point pairs.
+ *
+ * `in` is the absolute file path. `out` is relative to `handlersDir`:
+ * a file at `<handlersDir>/subdir/my-handler.ts` produces `out: 'subdir/my-handler/index'`.
+ * esbuild combines this with its `outdir` to produce the final path.
+ *
+ * Files matching the handler-source naming convention but containing no handler
+ * export (e.g. `export * from './impl'` re-exports, which cannot be detected
+ * without resolving the import graph) emit a `console.warn` so the omission
+ * surfaces in CI rather than being discovered at deploy time.
+ *
+ * Throws if a file cannot be read, with the full path included in the error message.
+ */
+async function findEntryPoints(handlersDir) {
+    // Explicit { encoding: 'utf8' } selects the string[] overload of readdir
+    // (the recursive overload otherwise has an ambiguous return type).
+    const files = (await fs__namespace.promises.readdir(handlersDir, { recursive: true, encoding: 'utf8' })).filter(f => f.endsWith('.ts') && !f.endsWith('.d.ts') && !f.includes('.test.') && !f.includes('.spec.'));
+    const results = await Promise.all(files.map(async (f) => {
+        const fullPath = path__namespace.join(handlersDir, f);
+        let content;
+        try {
+            content = await fs__namespace.promises.readFile(fullPath, 'utf8');
+        }
+        catch (err) {
+            throw new Error(`findEntryPoints: could not read ${fullPath}: ${err.message}`);
+        }
+        if (!containsHandlerExport(content)) {
+            console.warn(`findEntryPoints: skipping ${fullPath} — no recognised handler export found. `
+                + 'Supported shapes: export const/let/var/function handler, export { handler } / { foo as handler }, '
+                + '(module.)exports.handler = …. Re-exports (export * from …) are not detected.');
+            return undefined;
+        }
+        return {
+            in: fullPath,
+            out: path__namespace.join(path__namespace.dirname(f), path__namespace.basename(f, '.ts'), 'index'),
+        };
+    }));
+    return results.filter((entry) => entry !== undefined);
+}
+
 const { recapDevHandlerWrapper, defaultPlugins } = require('./esbuild-plugins');
 const args = process.argv.slice(2);
 const handlersDirIndex = args.indexOf('--handlers-dir');
 const outDirIndex = args.indexOf('--out-dir');
 const targetIndex = args.indexOf('--target');
+// --allow-empty: exit 0 instead of 1 when no handlers are found. Used by
+// services that may legitimately have zero Lambda handlers (libraries,
+// infra-only packages) so a shared `em-commons build-handlers` step can be
+// run unconditionally in their CI without breaking the pipeline.
+const allowEmpty = args.includes('--allow-empty');
 function resolveArg(index, flag, fallback) {
     if (index === -1) {
         return fallback;
@@ -24,63 +121,65 @@ const handlersDir = resolveArg(handlersDirIndex, '--handlers-dir', 'src/handlers
 const outDir = resolveArg(outDirIndex, '--out-dir', 'dist/handlers');
 const target = resolveArg(targetIndex, '--target', 'node24');
 const rootDir = process.cwd();
-const absoluteHandlersDir = path.resolve(rootDir, handlersDir);
-const absoluteOutDir = path.resolve(rootDir, outDir);
-if (!absoluteHandlersDir.startsWith(rootDir + path.sep)) {
+const absoluteHandlersDir = path__namespace.resolve(rootDir, handlersDir);
+const absoluteOutDir = path__namespace.resolve(rootDir, outDir);
+if (!absoluteHandlersDir.startsWith(rootDir + path__namespace.sep)) {
     console.error(`--handlers-dir must be inside the project root: ${absoluteHandlersDir}`);
     process.exit(1);
 }
-if (!absoluteOutDir.startsWith(rootDir + path.sep)) {
+if (!absoluteOutDir.startsWith(rootDir + path__namespace.sep)) {
     console.error(`--out-dir must be inside the project root: ${absoluteOutDir}`);
     process.exit(1);
 }
-if (!fs.existsSync(absoluteHandlersDir)) {
+if (!fs__namespace.existsSync(absoluteHandlersDir)) {
     console.error(`Handlers directory not found: ${absoluteHandlersDir}`);
     process.exit(1);
 }
-const entryPoints = fs.readdirSync(absoluteHandlersDir, { recursive: true })
-    .filter(f => f.endsWith('.ts') && !f.endsWith('.d.ts') && !f.includes('.test.') && !f.includes('.spec.'))
-    .map(f => ({
-    in: path.join(absoluteHandlersDir, f),
-    out: path.join(path.dirname(f), path.basename(f, '.ts'), 'index')
-}));
-if (entryPoints.length === 0) {
-    console.log(`No handlers found in ${handlersDir}`);
-    process.exit(0);
-}
-console.log(`Building ${entryPoints.length} handler(s) from ${handlersDir}...`);
-esbuild.build({
-    entryPoints,
-    outdir: absoluteOutDir,
-    bundle: true,
-    platform: 'node',
-    target,
-    format: 'cjs',
-    sourcemap: false,
-    minify: true,
-    external: [
-        '@aws-sdk/*',
-        'aws-sdk',
-        // Unused Knex/DB drivers — matches serverless-esbuild external list
-        'mysql',
-        'pg',
-        'pg-native',
-        'sqlite3',
-        'mssql',
-        'oracledb',
-        'better-sqlite3',
-        'pg-sqlite3',
-        'tedious',
-        'pg-query-stream',
-        'libsql',
-        'mariadb'
-    ],
-    plugins: [recapDevHandlerWrapper, ...defaultPlugins]
-})
-    .then(() => {
+async function main() {
+    const entryPoints = await findEntryPoints(absoluteHandlersDir);
+    if (entryPoints.length === 0) {
+        if (allowEmpty) {
+            // Log the resolved absolute path so a misrouted --handlers-dir (typo'd
+            // to a real-but-empty sibling directory) is visible in CI output.
+            console.warn(`No handlers found in ${handlersDir} (resolved: ${absoluteHandlersDir}), `
+                + 'skipping build (--allow-empty)');
+            return;
+        }
+        console.error(`No handlers found in ${handlersDir}. Pass --allow-empty to suppress this error.`);
+        process.exit(1);
+    }
+    console.log(`Building ${entryPoints.length} handler(s) from ${handlersDir}...`);
+    await esbuild__namespace.build({
+        entryPoints,
+        outdir: absoluteOutDir,
+        bundle: true,
+        platform: 'node',
+        target,
+        format: 'cjs',
+        sourcemap: false,
+        minify: true,
+        external: [
+            '@aws-sdk/*',
+            'aws-sdk',
+            // Unused Knex/DB drivers — matches serverless-esbuild external list
+            'mysql',
+            'pg',
+            'pg-native',
+            'sqlite3',
+            'mssql',
+            'oracledb',
+            'better-sqlite3',
+            'pg-sqlite3',
+            'tedious',
+            'pg-query-stream',
+            'libsql',
+            'mariadb'
+        ],
+        plugins: [recapDevHandlerWrapper, ...defaultPlugins]
+    });
     entryPoints.forEach(({ out }) => console.log(`  ${outDir}/${out}.js`));
-})
-    .catch(err => {
+}
+main().catch(err => {
     if (err?.errors?.length) {
         err.errors.forEach((e) => {
             const loc = e.location
@@ -90,7 +189,9 @@ esbuild.build({
         });
     }
     else {
-        console.error(err);
+        // Print the full stack (and `cause` chain) so non-esbuild errors are
+        // diagnosable in CI output rather than being collapsed to the message.
+        console.error(err instanceof Error ? (err.stack ?? err) : err);
     }
     process.exit(1);
 });