@whook/gcp-functions 8.5.0 → 9.0.1

package/src/services/_autoload.ts

@@ -16,6 +16,7 @@ import type {
   Initializer,
   Dependencies,
   Service,
+  ServiceInitializerWrapper,
 } from 'knifecycle';
 import type { WhookBuildConstantsService } from '@whook/whook';
 import type { WhookRawOperation } from '@whook/http-router';
@@ -23,6 +24,127 @@ import type { LogService } from 'common-services';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { WhookAPIOperationGCPFunctionConfig } from '..';
 
+const initializerWrapper: ServiceInitializerWrapper<
+  Autoloader<Initializer<Dependencies, Service>>,
+  Dependencies
+> = (async (
+  {
+    BUILD_CONSTANTS = {},
+    $injector,
+    $instance,
+    log = noop,
+  }: {
+    BUILD_CONSTANTS?: WhookBuildConstantsService;
+    $injector: Injector<Service>;
+    $instance: Knifecycle;
+    log: LogService;
+  },
+  $autoload: Autoloader<Initializer<Dependencies, Service>>,
+): Promise<
+  (serviceName: string) => Promise<{
+    initializer: Initializer<Dependencies, Service>;
+    path: string;
+  }>
+> => {
+  let API: OpenAPIV3.Document;
+  let OPERATION_APIS: WhookRawOperation<WhookAPIOperationGCPFunctionConfig>[];
+  const getAPIOperation = (() => {
+    return async (serviceName) => {
+      // eslint-disable-next-line
+      API = API || (await $injector(['API'])).API;
+      // eslint-disable-next-line
+      OPERATION_APIS =
+        OPERATION_APIS ||
+        getOpenAPIOperations<WhookAPIOperationGCPFunctionConfig>(API);
+
+      const OPERATION = OPERATION_APIS.find(
+        (operation) =>
+          serviceName ===
+          (((operation['x-whook'] || {}).sourceOperationId &&
+            'OPERATION_API_' +
+              (operation['x-whook'] || {}).sourceOperationId) ||
+            'OPERATION_API_' + operation.operationId) +
+            ((operation['x-whook'] || {}).suffix || ''),
+      );
+
+      if (!OPERATION) {
+        log('error', '💥 - Unable to find a lambda operation definition!');
+        throw new YError('E_OPERATION_NOT_FOUND', serviceName);
+      }
+
+      // eslint-disable-next-line
+      const OPERATION_API = cleanupOpenAPI({
+        ...API,
+        paths: {
+          [OPERATION.path]: {
+            [OPERATION.method]: API.paths[OPERATION.path]?.[OPERATION.method],
+          },
+        },
+      });
+
+      return {
+        ...OPERATION_API,
+        paths: {
+          [OPERATION.path]: {
+            [OPERATION.method]: (
+              await dereferenceOpenAPIOperations(OPERATION_API, [
+                {
+                  path: OPERATION.path,
+                  method: OPERATION.method,
+                  ...OPERATION_API.paths[OPERATION.path]?.[OPERATION.method],
+                  parameters: OPERATION.parameters,
+                },
+              ])
+            )[0],
+          },
+        },
+      };
+    };
+  })();
+
+  log('debug', '🤖 - Initializing the `$autoload` build wrapper.');
+
+  return async (serviceName) => {
+    try {
+      // TODO: add initializer map to knifecycle public API
+      const initializer = ($instance as any)._initializers.get(serviceName);
+
+      if (initializer && initializer[SPECIAL_PROPS.TYPE] === 'constant') {
+        log(
+          'debug',
+          `🤖 - Reusing a constant initializer directly from the Knifecycle instance: "${serviceName}".`,
+        );
+        return {
+          initializer,
+          path: `instance://${serviceName}`,
+        };
+      }
+
+      if (serviceName.startsWith('OPERATION_API_')) {
+        const OPERATION_API = await getAPIOperation(serviceName);
+
+        return {
+          initializer: constant(serviceName, OPERATION_API),
+          path: `api://${serviceName}`,
+        };
+      }
+
+      if (BUILD_CONSTANTS[serviceName]) {
+        return {
+          initializer: constant(serviceName, BUILD_CONSTANTS[serviceName]),
+          path: `constant://${serviceName}`,
+        };
+      }
+
+      return $autoload(serviceName);
+    } catch (err) {
+      log('error', `Build error while loading "${serviceName}".`);
+      log('error-stack', (err as Error).stack || 'no_stack_trace');
+      throw err;
+    }
+  };
+}) as any;
+
 /**
  * Wrap the _autoload service in order to build AWS
  *  Lambda compatible code.
@@ -39,123 +161,5 @@ import type { WhookAPIOperationGCPFunctionConfig } from '..';
  */
 export default alsoInject(
   ['?BUILD_CONSTANTS', '$instance', '$injector', '?log'],
-  wrapInitializer(
-    async (
-      {
-        BUILD_CONSTANTS = {},
-        $injector,
-        $instance,
-        log = noop,
-      }: {
-        BUILD_CONSTANTS?: WhookBuildConstantsService;
-        $injector: Injector<Service>;
-        $instance: Knifecycle<Dependencies>;
-        log: LogService;
-      },
-      $autoload: Autoloader,
-    ): Promise<
-      (serviceName: string) => Promise<{
-        initializer: Initializer<Dependencies, Service>;
-        path: string;
-      }>
-    > => {
-      let API: OpenAPIV3.Document;
-      let OPERATION_APIS: WhookRawOperation<WhookAPIOperationGCPFunctionConfig>[];
-      const getAPIOperation = (() => {
-        return async (serviceName) => {
-          // eslint-disable-next-line
-          API = API || (await $injector(['API'])).API;
-          // eslint-disable-next-line
-          OPERATION_APIS =
-            OPERATION_APIS ||
-            getOpenAPIOperations<WhookAPIOperationGCPFunctionConfig>(API);
-
-          const OPERATION = OPERATION_APIS.find(
-            (operation) =>
-              serviceName ===
-              (((operation['x-whook'] || {}).sourceOperationId &&
-                'OPERATION_API_' +
-                  (operation['x-whook'] || {}).sourceOperationId) ||
-                'OPERATION_API_' + operation.operationId) +
-                ((operation['x-whook'] || {}).suffix || ''),
-          );
-
-          if (!OPERATION) {
-            log('error', '💥 - Unable to find a lambda operation definition!');
-            throw new YError('E_OPERATION_NOT_FOUND', serviceName);
-          }
-
-          // eslint-disable-next-line
-          const OPERATION_API = cleanupOpenAPI({
-            ...API,
-            paths: {
-              [OPERATION.path]: {
-                [OPERATION.method]: API.paths[OPERATION.path][OPERATION.method],
-              },
-            },
-          });
-
-          return {
-            ...OPERATION_API,
-            paths: {
-              [OPERATION.path]: {
-                [OPERATION.method]: (
-                  await dereferenceOpenAPIOperations(OPERATION_API, [
-                    {
-                      path: OPERATION.path,
-                      method: OPERATION.method,
-                      ...OPERATION_API.paths[OPERATION.path][OPERATION.method],
-                      parameters: OPERATION.parameters,
-                    },
-                  ])
-                )[0],
-              },
-            },
-          };
-        };
-      })();
-
-      log('debug', '🤖 - Initializing the `$autoload` build wrapper.');
-
-      return async (serviceName) => {
-        try {
-          // TODO: add initializer map to knifecycle public API
-          const initializer = ($instance as any)._initializers.get(serviceName);
-
-          if (initializer && initializer[SPECIAL_PROPS.TYPE] === 'constant') {
-            log(
-              'debug',
-              `🤖 - Reusing a constant initializer directly from the Knifecycle instance: "${serviceName}".`,
-            );
-            return {
-              initializer,
-              path: `instance://${serviceName}`,
-            };
-          }
-
-          if (serviceName.startsWith('OPERATION_API_')) {
-            const OPERATION_API = await getAPIOperation(serviceName);
-
-            return {
-              initializer: constant(serviceName, OPERATION_API),
-              path: `api://${serviceName}`,
-            };
-          }
-
-          if (BUILD_CONSTANTS[serviceName]) {
-            return {
-              initializer: constant(serviceName, BUILD_CONSTANTS[serviceName]),
-              path: `constant://${serviceName}`,
-            };
-          }
-
-          return $autoload(serviceName);
-        } catch (err) {
-          log('error', `Build error while loading "${serviceName}".`);
-          log('stack', err.stack);
-        }
-      };
-    },
-    initAutoload,
-  ),
+  wrapInitializer(initializerWrapper as any, initAutoload),
 );

package/src/services/log.test.ts

@@ -2,6 +2,6 @@ import initLogService from './log';
 
 describe('initLogService', () => {
   it('should work', async () => {
-    await initLogService();
+    await initLogService({});
   });
 });

package/src/wrappers/googleHTTPFunction.ts

@@ -88,7 +88,7 @@ export default function wrapHandlerForAWSHTTPFunction<
     ],
     reuseSpecialProps(
       initHandler,
-      initHandlerForAWSHTTPFunction.bind(
+      (initHandlerForAWSHTTPFunction as any).bind(
         null,
         initHandler,
       ) as ServiceInitializer<D, S>,
@@ -97,7 +97,7 @@ export default function wrapHandlerForAWSHTTPFunction<
 }
 
 async function initHandlerForAWSHTTPFunction(
-  initHandler: ServiceInitializer<unknown, WhookHandler>,
+  initHandler: ServiceInitializer<Dependencies<any>, WhookHandler>,
   {
     OPERATION_API,
     WRAPPERS,
@@ -125,9 +125,9 @@ async function initHandlerForAWSHTTPFunction(
     verbose: DEBUG_NODE_ENVS.includes(NODE_ENV),
     strict: true,
     logger: {
-      log: (...args) => log('debug', ...args),
-      warn: (...args) => log('warning', ...args),
-      error: (...args) => log('error', ...args),
+      log: (...args) => log?.('debug', ...args),
+      warn: (...args) => log?.('warning', ...args),
+      error: (...args) => log?.('error', ...args),
     },
     useDefaults: true,
     coerceTypes: true,
@@ -213,10 +213,10 @@ async function handleForAWSHTTPFunction(
   req,
   res,
 ) {
-  const debugging = DEBUG_NODE_ENVS.includes(NODE_ENV);
+  const debugging = (DEBUG_NODE_ENVS || []).includes(NODE_ENV);
   const bufferLimit = bytes.parse(BUFFER_LIMIT);
 
-  log(
+  log?.(
     'info',
     'GCP_FUNCTIONS_REQUEST',
     JSON.stringify({
@@ -234,7 +234,7 @@ async function handleForAWSHTTPFunction(
   let responseLog;
   let responseSpec;
 
-  log(
+  log?.(
     'debug',
     'REQUEST',
     JSON.stringify({
@@ -276,19 +276,21 @@ async function handleForAWSHTTPFunction(
         request.url.split(SEARCH_SEPARATOR)[0].length,
       );
 
-      const pathParameters = OPERATION.path
-        .split(PATH_SEPARATOR)
-        .filter(identity)
-        .map((part, index) => {
-          const matches = /^\{([\d\w]+)\}$/i.exec(part);
-
-          if (matches) {
-            return {
-              name: matches[1],
-              value: parts[index],
-            };
-          }
-        })
+      const pathParameters = (
+        OPERATION.path
+          .split(PATH_SEPARATOR)
+          .filter(identity)
+          .map((part, index) => {
+            const matches = /^\{([\d\w]+)\}$/i.exec(part);
+
+            if (matches) {
+              return {
+                name: matches[1],
+                value: parts[index],
+              };
+            }
+          }) as Array<{ name: string; value: string }>
+      )
         .filter(identity)
         .reduce(
           (accParameters, { name, value }) => ({
@@ -326,7 +328,7 @@ async function handleForAWSHTTPFunction(
         ...('undefined' !== typeof body ? { body } : {}),
       };
     } catch (err) {
-      throw HTTPError.cast(err, 400);
+      throw HTTPError.cast(err as Error, 400);
     }
 
     response = await executeHandler(operation, handler, parameters);
@@ -366,9 +368,9 @@ async function handleForAWSHTTPFunction(
       type: 'success',
       status: response.status,
     };
-    log('debug', JSON.stringify(responseLog));
+    log?.('debug', JSON.stringify(responseLog));
   } catch (err) {
-    const castedError = HTTPError.cast(err);
+    const castedError = HTTPError.cast(err as Error);
 
     responseLog = {
       type: 'error',
@@ -378,7 +380,7 @@ async function handleForAWSHTTPFunction(
       stack: castedError.stack,
     };
 
-    log('error', JSON.stringify(responseLog));
+    log?.('error', JSON.stringify(responseLog));
     response = {
       status: castedError.httpCode,
       headers: {
@@ -396,7 +398,7 @@ async function handleForAWSHTTPFunction(
     };
   }
 
-  log(
+  log?.(
     'debug',
     'RESPONSE',
     JSON.stringify({
@@ -441,8 +443,8 @@ async function pipeResponseInGCPFResponse(
   response: WhookResponse,
   res,
 ): Promise<void> {
-  Object.keys(response.headers).forEach((headerName) => {
-    res.set(headerName, response.headers[headerName]);
+  Object.keys(response.headers || {}).forEach((headerName) => {
+    res.set(headerName, response.headers?.[headerName]);
   });
   res.status(response.status);