refactor: drop orphaned sync loader chain; guard dist against stale artifacts

Two follow-ups from PR #784 review:

1. Remove `loadSync`, `_loadUserAppSync`, `_tryRequireSync`. Deleting
   `src/handler.cjs` in the previous commit removed the only consumers of
   the synchronous loader chain. `loadSync` was never re-exported from the
   public `src/index.ts` entry point, no tests reference it, and the only
   internal import (`src/handler.mjs`) uses the async `load()`. The three
   functions and the `loadSync` re-export in `src/runtime/index.ts` are
   now dead code, so drop them.

2. Defensive cleanup in `scripts/update_dist_version.sh`: explicitly
   `rm -f dist/handler.js dist/handler.cjs` before copying handler.mjs.
   `tsc` does not clean stale files in `dist/` between incremental
   builds, so a leftover `handler.js` from a prior build of an earlier
   ref could resurface and silently re-introduce the resolver bug this
   PR is fixing. The publish scripts already do `rm -rf ./dist` before
   `yarn build`, so this is purely a guard for local dev builds.

Author: zarirhamza

scripts/update_dist_version.sh

@@ -20,6 +20,11 @@ echo "Copying handler files"
 # `dist/handler.handler` to handler.mjs (it falls through `.js` -> `.mjs`),
 # and handler.mjs's async `load()` handles both CJS and ESM user modules, so
 # a separate `.js` / `.cjs` variant is no longer needed.
+#
+# Remove any stale `dist/handler.js` / `dist/handler.cjs` left over from prior
+# builds — tsc doesn't clean dist between incremental compiles, and shipping
+# either of those files would re-introduce the resolver bug this PR fixes.
+rm -f dist/handler.js dist/handler.cjs
 cp src/handler.mjs dist/
 cp src/init.js dist/init.js
 cp src/runtime/module_importer.js dist/runtime/

src/runtime/index.ts

@@ -1,2 +1,2 @@
-export { load, loadSync } from "./user-function";
+export { load } from "./user-function";
 export { subscribeToDC, getTraceTree, clearTraceTree, RequireNode } from "./require-tracer"

src/runtime/user-function.ts

@@ -156,45 +156,6 @@ async function _tryRequire(appRoot: string, moduleRoot: string, module: string):
   return require(nodeStylePath);
 }
 
-/**
- * Attempt to load the user's module.
- * Attempts to directly resolve the module relative to the application root,
- * then falls back to the more general require().
- */
-function _tryRequireSync(appRoot: string, moduleRoot: string, module: string): Promise<any> {
-  const lambdaStylePath = path.resolve(appRoot, moduleRoot, module);
-  // Extensionless files are loaded via require.
-  const extensionless = _tryRequireFile(lambdaStylePath);
-  if (extensionless) {
-    return extensionless;
-  }
-  // If package.json type != module, .js files are loaded via require.
-  const pjHasModule = _hasPackageJsonTypeModule(lambdaStylePath);
-  if (!pjHasModule) {
-    const loaded = _tryRequireFile(lambdaStylePath, ".js");
-    if (loaded) {
-      return loaded;
-    }
-  }
-  // If still not loaded, try .js, .mjs, and .cjs in that order.
-  // Files ending with .js are loaded as ES modules when the nearest parent package.json
-  // file contains a top-level field "type" with a value of "module".
-  // https://nodejs.org/api/packages.html#packages_type
-  const loaded = _tryRequireFile(lambdaStylePath, ".cjs");
-  if (loaded) {
-    return loaded;
-  }
-  // Why not just require(module)?
-  // Because require() is relative to __dirname, not process.cwd(). And the
-  // runtime implementation is not located in /var/task
-  // This won't work (yet) for esModules as import.meta.resolve is still experimental
-  // See: https://nodejs.org/api/esm.html#esm_import_meta_resolve_specifier_parent
-  const nodeStylePath = require.resolve(module, {
-    paths: [appRoot, moduleRoot],
-  });
-  return require(nodeStylePath);
-}
-
 /**
  * Load the user's application or throw a descriptive error.
  * @throws Runtime errors in two cases
@@ -221,26 +182,6 @@ async function _loadUserApp(
   }
 }
 
-function _loadUserAppSync(
-  appRoot: string,
-  moduleRoot: string,
-  module: string
-): Promise<any> {
-  try {
-    return _tryRequireSync(appRoot, moduleRoot, module);
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      throw new UserCodeSyntaxError(<any>e);
-      // @ts-ignore
-    } else if (e.code !== undefined && e.code === "MODULE_NOT_FOUND") {
-      // @ts-ignore
-      throw new ImportModuleError(e);
-    } else {
-      throw e;
-    }
-  }
-}
-
 function _throwIfInvalidHandler(fullHandlerString: string): void {
   if (fullHandlerString.includes(RELATIVE_PATH_SUBSTRING)) {
     throw new MalformedHandlerName(
@@ -294,49 +235,3 @@ export const load = async function (
 
   return handlerFunc;
 };
-
-/**
- * Load the user's function with the approot and the handler string.
- * @param appRoot {string}
- *   The path to the application root.
- * @param handlerString {string}
- *   The user-provided handler function in the form 'module.function'.
- * @return userFuction {function}
- *   The user's handler function. This function will be passed the event body,
- *   the context object, and the callback function.
- * @throws In five cases:-
- *   1 - if the handler string is incorrectly formatted an error is thrown
- *   2 - if the module referenced by the handler cannot be loaded
- *   3 - if the function in the handler does not exist in the module
- *   4 - if a property with the same name, but isn't a function, exists on the
- *       module
- *   5 - the handler includes illegal character sequences (like relative paths
- *       for traversing up the filesystem '..')
- *   Errors for scenarios known by the runtime, will be wrapped by Runtime.* errors.
- */
-export const loadSync = function (
-  appRoot: string,
-  fullHandlerString: string
-) {
-  _throwIfInvalidHandler(fullHandlerString);
-
-  const [moduleRoot, moduleAndHandler] = _moduleRootAndHandler(
-    fullHandlerString
-  );
-  const [module, handlerPath] = _splitHandlerString(moduleAndHandler);
-
-  const userApp = _loadUserAppSync(appRoot, moduleRoot, module);
-  const handlerFunc = _resolveHandler(userApp, handlerPath);
-
-  if (!handlerFunc) {
-    throw new HandlerNotFound(
-      `${fullHandlerString} is undefined or not exported`
-    );
-  }
-
-  if (typeof handlerFunc !== "function") {
-    throw new HandlerNotFound(`${fullHandlerString} is not a function`);
-  }
-
-  return handlerFunc;
-};