1+ /**
2+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3+ * Modifications copyright 2021 Datadog, Inc.
4+ *
5+ * The original file was part of aws-lambda-nodejs-runtime-interface-client
6+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/main/src/utils/UserFunction.ts
7+ *
8+ * This module defines the functions for loading the user's code as specified
9+ * in a handler string.
10+ */
11+
12+ "use strict" ;
13+
14+ import path from "path" ;
15+ import fs from "fs" ;
16+ import {
17+ HandlerNotFound ,
18+ MalformedHandlerName ,
19+ ImportModuleError ,
20+ UserCodeSyntaxError ,
21+ ExtendedError ,
22+ } from "./errors" ;
23+
24+ const FUNCTION_EXPR = / ^ ( [ ^ . ] * ) \. ( .* ) $ / ;
25+ const RELATIVE_PATH_SUBSTRING = ".." ;
26+
27+ /**
28+ * Break the full handler string into two pieces, the module root and the actual
29+ * handler string.
30+ * Given './somepath/something/module.nestedobj.handler' this returns
31+ * ['./somepath/something', 'module.nestedobj.handler']
32+ */
33+ function _moduleRootAndHandler ( fullHandlerString : string ) : [ string , string ] {
34+ const handlerString = path . basename ( fullHandlerString ) ;
35+ const moduleRoot = fullHandlerString . substring (
36+ 0 ,
37+ fullHandlerString . indexOf ( handlerString )
38+ ) ;
39+ return [ moduleRoot , handlerString ] ;
40+ }
41+
42+ /**
43+ * Split the handler string into two pieces: the module name and the path to
44+ * the handler function.
45+ */
46+ function _splitHandlerString ( handler : string ) : [ string , string ] {
47+ const match = handler . match ( FUNCTION_EXPR ) ;
48+ if ( ! match || match . length != 3 ) {
49+ throw new MalformedHandlerName ( "Bad handler" ) ;
50+ }
51+ return [ match [ 1 ] , match [ 2 ] ] ; // [module, function-path]
52+ }
53+
54+ /**
55+ * Resolve the user's handler function from the module.
56+ */
57+ function _resolveHandler ( object : any , nestedProperty : string ) : any {
58+ return nestedProperty . split ( "." ) . reduce ( ( nested , key ) => {
59+ return nested && nested [ key ] ;
60+ } , object ) ;
61+ }
62+
63+ /**
64+ * Verify that the provided path can be loaded as a file per:
65+ * https://nodejs.org/dist/latest-v10.x/docs/api/modules.html#modules_all_together
66+ * @param string - the fully resolved file path to the module
67+ * @return bool
68+ */
69+ function _canLoadAsFile ( modulePath : string ) : boolean {
70+ return fs . existsSync ( modulePath ) || fs . existsSync ( modulePath + ".js" ) ;
71+ }
72+
73+ /**
74+ * Attempt to load the user's module.
75+ * Attempts to directly resolve the module relative to the application root,
76+ * then falls back to the more general require().
77+ */
78+ function _tryRequire ( appRoot : string , moduleRoot : string , module : string ) : any {
79+ const lambdaStylePath = path . resolve ( appRoot , moduleRoot , module ) ;
80+ if ( _canLoadAsFile ( lambdaStylePath ) ) {
81+ return require ( lambdaStylePath ) ;
82+ } else {
83+ // Why not just require(module)?
84+ // Because require() is relative to __dirname, not process.cwd()
85+ const nodeStylePath = require . resolve ( module , {
86+ paths : [ appRoot , moduleRoot ] ,
87+ } ) ;
88+ return require ( nodeStylePath ) ;
89+ }
90+ }
91+
92+ /**
93+ * Load the user's application or throw a descriptive error.
94+ * @throws Runtime errors in two cases
95+ * 1 - UserCodeSyntaxError if there's a syntax error while loading the module
96+ * 2 - ImportModuleError if the module cannot be found
97+ */
98+ function _loadUserApp (
99+ appRoot : string ,
100+ moduleRoot : string ,
101+ module : string
102+ ) : any {
103+ try {
104+ return _tryRequire ( appRoot , moduleRoot , module ) ;
105+ } catch ( e ) {
106+ if ( e instanceof SyntaxError ) {
107+ throw new UserCodeSyntaxError ( < any > e ) ;
108+ // @ts -ignore
109+ } else if ( e . code !== undefined && e . code === "MODULE_NOT_FOUND" ) {
110+ // @ts -ignore
111+ throw new ImportModuleError ( e ) ;
112+ } else {
113+ throw e ;
114+ }
115+ }
116+ }
117+
118+ function _throwIfInvalidHandler ( fullHandlerString : string ) : void {
119+ if ( fullHandlerString . includes ( RELATIVE_PATH_SUBSTRING ) ) {
120+ throw new MalformedHandlerName (
121+ `'${ fullHandlerString }
122+ ) ;
123+ }
124+ }
125+
126+ /**
127+ * Load the user's function with the approot and the handler string.
128+ * @param appRoot {string}
129+ * The path to the application root.
130+ * @param handlerString {string}
131+ * The user-provided handler function in the form 'module.function'.
132+ * @return userFuction {function}
133+ * The user's handler function. This function will be passed the event body,
134+ * the context object, and the callback function.
135+ * @throws In five cases:-
136+ * 1 - if the handler string is incorrectly formatted an error is thrown
137+ * 2 - if the module referenced by the handler cannot be loaded
138+ * 3 - if the function in the handler does not exist in the module
139+ * 4 - if a property with the same name, but isn't a function, exists on the
140+ * module
141+ * 5 - the handler includes illegal character sequences (like relative paths
142+ * for traversing up the filesystem '..')
143+ * Errors for scenarios known by the runtime, will be wrapped by Runtime.* errors.
144+ */
145+ export const load = function (
146+ appRoot : string ,
147+ fullHandlerString : string
148+ ) {
149+ _throwIfInvalidHandler ( fullHandlerString ) ;
150+
151+ const [ moduleRoot , moduleAndHandler ] = _moduleRootAndHandler (
152+ fullHandlerString
153+ ) ;
154+ const [ module , handlerPath ] = _splitHandlerString ( moduleAndHandler ) ;
155+
156+ const userApp = _loadUserApp ( appRoot , moduleRoot , module ) ;
157+ const handlerFunc = _resolveHandler ( userApp , handlerPath ) ;
158+
159+ if ( ! handlerFunc ) {
160+ throw new HandlerNotFound (
161+ `${ fullHandlerString }
162+ ) ;
163+ }
164+
165+ if ( typeof handlerFunc !== "function" ) {
166+ throw new HandlerNotFound ( `${ fullHandlerString } ) ;
167+ }
168+
169+ return handlerFunc ;
170+ } ;
0 commit comments