@whook/gcp-functions 12.0.2 → 13.1.0

package/src/index.ts

@@ -1,18 +1,15 @@
-/* eslint global-require:0 */
 import fs from 'fs';
 import util from 'util';
 import path from 'path';
-import mkdirp from 'mkdirp';
+import { mkdirp } from 'mkdirp';
+import { argv, exit, stderr } from 'node:process';
 import cpr from 'cpr';
 import { printStackTrace, YError } from 'yerror';
-import { createRequire } from 'module';
+import { Knifecycle, constant, initInitializerBuilder } from 'knifecycle';
 import {
-  Knifecycle,
-  SPECIAL_PROPS,
-  constant,
-  initInitializerBuilder,
-} from 'knifecycle';
-import { initCompiler } from '@whook/whook';
+  DEFAULT_BUILD_INITIALIZER_PATH_MAP as BASE_DEFAULT_BUILD_INITIALIZER_PATH_MAP,
+  initCompiler,
+} from '@whook/whook';
 import initBuildAutoloader from './services/_autoload.js';
 import {
   dereferenceOpenAPIOperations,
@@ -35,6 +32,10 @@ import type { LogService } from 'common-services';
 import type { CprOptions } from 'cpr';
 
 export const DEFAULT_BUILD_PARALLELISM = 10;
+export const DEFAULT_BUILD_INITIALIZER_PATH_MAP = {
+  ...BASE_DEFAULT_BUILD_INITIALIZER_PATH_MAP,
+  log: '@whook/gcp-functions/dist/services/log',
+};
 
 export type WhookGCPBuildConfig = {
   BUILD_PARALLELISM?: number;
@@ -62,40 +63,11 @@ const cprAsync = util.promisify(cpr) as (
   options: CprOptions,
 ) => Promise<string[]>;
 
-// TODO: Use import.meta when Jest will support it
-const require = createRequire(path.join(process.cwd(), 'src', 'index.ts'));
-
-const BUILD_DEFINITIONS: Record<
-  NonNullable<WhookAPIOperationGCPFunctionConfig['type']>,
-  {
-    type: string;
-    wrapper: { name: string; path: string };
-    suffix?: string;
-  }
-> = {
-  http: {
-    type: 'HTTP',
-    wrapper: {
-      name: 'wrapHandlerForGoogleHTTPFunction',
-      path: path.join(
-        path.dirname(require.resolve('@whook/gcp-functions')),
-        'wrappers/googleHTTPFunction.js',
-      ),
-    },
-    suffix: 'Wrapped',
-  },
-};
-
 export async function prepareBuildEnvironment<T extends Knifecycle>(
   $: T = new Knifecycle() as T,
 ): Promise<T> {
   $.register(
-    constant('INITIALIZER_PATH_MAP', {
-      ENV: '@whook/whook/dist/services/ProxyedENV',
-      log: '@whook/gcp-functions/dist/services/log',
-      time: 'common-services/dist/time',
-      delay: 'common-services/dist/delay',
-    }),
+    constant('INITIALIZER_PATH_MAP', DEFAULT_BUILD_INITIALIZER_PATH_MAP),
   );
   $.register(initInitializerBuilder);
   $.register(initBuildAutoloader);
@@ -110,10 +82,10 @@ export async function runBuild(
   aPrepareBuildEnvironment: typeof prepareBuildEnvironment,
 ): Promise<void> {
   try {
-    const handlerName = process.argv[2];
+    const handlerName = argv[2];
     const $ = await aPrepareBuildEnvironment();
     const {
-      NODE_ENV,
+      APP_ENV,
       BUILD_PARALLELISM,
       PROJECT_DIR,
       compiler,
@@ -122,7 +94,7 @@ export async function runBuild(
       API,
       buildInitializer,
     }: WhookGCPBuildConfig & {
-      NODE_ENV: string;
+      APP_ENV: string;
       PROJECT_DIR: string;
       compiler: WhookCompilerService;
       log: LogService;
@@ -130,7 +102,7 @@ export async function runBuild(
       API: OpenAPIV3.Document;
       buildInitializer: BuildInitializer;
     } = await $.run([
-      'NODE_ENV',
+      'APP_ENV',
       '?BUILD_PARALLELISM',
       'PROJECT_DIR',
       'process',
@@ -161,10 +133,11 @@ export async function runBuild(
       return true;
     });
 
-    log('warning', `${operations.length} operations to process.`);
+    log('warning', `📃 - ${operations.length} operations to process.`);
+
     await processOperations(
       {
-        NODE_ENV,
+        APP_ENV,
         BUILD_PARALLELISM: BUILD_PARALLELISM || DEFAULT_BUILD_PARALLELISM,
         PROJECT_DIR,
         compiler,
@@ -176,19 +149,16 @@ export async function runBuild(
     );
     await $.destroy();
   } catch (err) {
-    // eslint-disable-next-line
-    console.error(
-      '💀 - Cannot launch the build:',
-      printStackTrace(err),
-      JSON.stringify((err as YError)?.params, null, 2),
+    stderr.write(
+      `💀 - Cannot launch the build:' ${printStackTrace(err as Error)}`,
     );
-    process.exit(1);
+    exit(1);
   }
 }
 
 async function processOperations(
   {
-    NODE_ENV,
+    APP_ENV,
     BUILD_PARALLELISM,
     PROJECT_DIR,
     compiler,
@@ -196,7 +166,7 @@ async function processOperations(
     $autoload,
     buildInitializer,
   }: WhookGCPBuildConfig & {
-    NODE_ENV: string;
+    APP_ENV: string;
     PROJECT_DIR: string;
     compiler: WhookCompilerService;
     log: LogService;
@@ -211,11 +181,10 @@ async function processOperations(
     operations.slice(0, BUILD_PARALLELISM).map((operation) =>
       buildAnyLambda(
         {
-          NODE_ENV,
+          APP_ENV,
           PROJECT_DIR,
           compiler,
           log,
-          $autoload,
           buildInitializer,
         },
         operation,
@@ -224,10 +193,10 @@ async function processOperations(
   );
 
   if (operationsLeft.length) {
-    log('info', operationsLeft.length, ' operations left.');
+    log('info', `📃 - ${operationsLeft.length} operations left.`);
     return processOperations(
       {
-        NODE_ENV,
+        APP_ENV,
         BUILD_PARALLELISM,
         PROJECT_DIR,
         compiler,
@@ -238,23 +207,21 @@ async function processOperations(
       operationsLeft,
     );
   }
-  log('info', 'No more operations.');
+  log('info', '🤷 - No more operations.');
 }
 
 async function buildAnyLambda(
   {
-    NODE_ENV,
+    APP_ENV,
     PROJECT_DIR,
     compiler,
     log,
-    $autoload,
     buildInitializer,
   }: {
-    NODE_ENV: string;
+    APP_ENV: string;
     PROJECT_DIR: string;
     compiler: WhookCompilerService;
     log: LogService;
-    $autoload: Autoloader<Initializer<Dependencies, Service>>;
     buildInitializer: BuildInitializer;
   },
   operation: WhookOperation<WhookAPIOperationGCPFunctionConfig>,
@@ -267,36 +234,25 @@ async function buildAnyLambda(
     ] || { type: 'http' };
     const operationType = whookConfig.type || 'http';
     const sourceOperationId = whookConfig.sourceOperationId;
-    const entryPoint = operationId;
     const finalEntryPoint =
       (sourceOperationId ? sourceOperationId : operationId) +
       ((operation['x-whook'] || {}).suffix || '');
-    log('warning', `Building ${operationType} "${finalEntryPoint}"...`);
-    const buildDefinition = BUILD_DEFINITIONS[operationType];
-    // eslint-disable-next-line
-    const applyWrapper = (await import(buildDefinition.wrapper.path)).default;
-    const rootNode = await $autoload(
-      entryPoint + (buildDefinition.suffix || ''),
-    );
+
+    log('warning', `🏗 - Building ${operationType} "${finalEntryPoint}"...`);
+
     const lambdaPath = path.join(
       PROJECT_DIR,
       'builds',
-      NODE_ENV,
+      APP_ENV,
       finalEntryPoint,
     );
-    const finalHandlerInitializer = applyWrapper(rootNode.initializer);
 
-    const initializerContent = await buildInitializer(
-      finalHandlerInitializer[SPECIAL_PROPS.INJECT].map((name) =>
-        name === 'OPERATION_API'
-          ? `OPERATION_API>OPERATION_API_${finalEntryPoint}`
-          : name,
-      ),
+    const initializerContent = await buildInitializer([
+      `OPERATION_HANDLER_${finalEntryPoint}`,
+    ]);
+    const indexContent = await buildLambdaIndex(
+      `OPERATION_HANDLER_${finalEntryPoint}`,
     );
-    const indexContent = await buildLambdaIndex(rootNode, {
-      name: buildDefinition.wrapper.name,
-      path: buildDefinition.wrapper.path,
-    });
 
     await mkdirp(lambdaPath);
     await Promise.all([
@@ -315,30 +271,20 @@ async function buildAnyLambda(
     await buildFinalLambda({ compiler, log }, lambdaPath, whookConfig);
   } catch (err) {
     log('error', `Error building "${operationId}"...`);
-    log('error-stack', printStackTrace(err));
-    log('debug', JSON.stringify((err as YError).params, null, 2));
+    log('error-stack', printStackTrace(err as Error));
     throw YError.wrap(err as Error, 'E_LAMBDA_BUILD', operationId);
   }
 }
 
-async function buildLambdaIndex(
-  rootNode: { path: string },
-  buildWrapper: { name: string; path: string },
-): Promise<string> {
-  return `import initHandler from '${rootNode.path}';
-import ${buildWrapper.name} from '${buildWrapper.path}';
+async function buildLambdaIndex(name: string): Promise<string> {
+  return `// Automatically generated by \`@whook/gcp-functions\`
 import { initialize } from './initialize.js';
 
-const handlerInitializer = ${buildWrapper.name}(
-    initHandler
-);
-
-const handlerPromise = initialize()
-  .then(handlerInitializer);
+const initializationPromise = initialize();
 
-  export default function handler (req, res) {
-  return handlerPromise
-  .then(handler => handler(req, res));
+export default function handler (req, res) {
+  return initializationPromise
+    .then(services => services['${name}'](req, res));
 };
 `;
 }

package/src/libs/utils.ts

@@ -5,20 +5,22 @@ import type { LogService } from 'common-services';
 export async function loadFunction(
   {
     PROJECT_DIR,
+    APP_ENV,
     log,
   }: {
     PROJECT_DIR: string;
+    APP_ENV: string;
     log: LogService;
   },
-  target: string,
   operationId: string,
   type: string,
   extension = '.mjs',
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): Promise<any> {
   const modulePath = path.join(
     PROJECT_DIR,
     'builds',
-    target,
+    APP_ENV,
     operationId,
     type + extension,
   );

package/src/services/HANDLER.ts

@@ -0,0 +1,41 @@
+import { autoService, name } from 'knifecycle';
+import { noop, applyWrappers } from '@whook/whook';
+import type { WhookWrapper } from '@whook/whook';
+import type { WhookHandler } from '@whook/http-transaction';
+import type { LogService } from 'common-services';
+
+export type WhookHandlerDependencies<T extends WhookHandler> = {
+  WRAPPERS: WhookWrapper<T>[];
+  mainWrapper: WhookWrapper<T>;
+  baseHandler: T;
+  log?: LogService;
+};
+
+export default name('HANDLER', autoService(initHandler));
+
+/**
+ * Initialize one Whook handler
+ * @param  {Object}   services
+ * The services `$autoload` depends on
+ * @param  {Array}    services.WRAPPERS
+ * An optional list of wrappers to inject
+ * @param  {Object}   [services.log=noop]
+ * An optional logging service
+ * @param  {Object}   services.HANDLERS
+ * The rest is a hash of handlers mapped by their operation id
+ * @return {Promise<Function>}
+ * A promise of the `HANDLERS` hash.
+ */
+async function initHandler<T extends WhookHandler>({
+  WRAPPERS,
+  mainWrapper,
+  baseHandler,
+  log = noop,
+}: WhookHandlerDependencies<T>): Promise<WhookHandler<T>> {
+  log(
+    'warning',
+    `🏭 - Initializing the HANDLER service with wrapped by ${WRAPPERS.length} wrappers.`,
+  );
+
+  return await applyWrappers<T>([...WRAPPERS, mainWrapper], baseHandler);
+}

package/src/services/_autoload.ts

@@ -1,7 +1,9 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { initAutoload, noop, cleanupOpenAPI } from '@whook/whook';
 import {
-  Knifecycle,
   SPECIAL_PROPS,
+  UNBUILDABLE_SERVICES,
+  Knifecycle,
   wrapInitializer,
   constant,
   alsoInject,
@@ -11,6 +13,8 @@ import {
   dereferenceOpenAPIOperations,
   getOpenAPIOperations,
 } from '@whook/http-router';
+import initHandler from './HANDLER.js';
+import initWrapHandlerForGoogleHTTPFunction from '../wrappers/wrapHandlerForGoogleHTTPFunction.js';
 import type {
   Injector,
   Autoloader,
@@ -21,10 +25,31 @@ import type {
 } from 'knifecycle';
 import type { WhookBuildConstantsService } from '@whook/whook';
 import type { WhookRawOperation } from '@whook/http-router';
-import type { LogService } from 'common-services';
+import type { LogService, ResolveService } from 'common-services';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { WhookAPIOperationGCPFunctionConfig } from '../index.js';
 
+export type WhookGoogleFunctionsAutoloadDependencies = {
+  BUILD_CONSTANTS?: WhookBuildConstantsService;
+  $injector: Injector<Service>;
+  $instance: Knifecycle;
+  resolve: ResolveService;
+  log?: LogService;
+};
+
+export const GCP_WRAPPERS: Record<
+  Required<WhookAPIOperationGCPFunctionConfig>['type'],
+  {
+    name: string;
+    initializer: Initializer<Service, Dependencies>;
+  }
+> = {
+  http: {
+    name: 'wrapHandlerForGoogleHTTPFunction',
+    initializer: initWrapHandlerForGoogleHTTPFunction as any,
+  },
+};
+
 const initializerWrapper: ServiceInitializerWrapper<
   Autoloader<Initializer<Dependencies, Service>>,
   Dependencies
@@ -33,13 +58,9 @@ const initializerWrapper: ServiceInitializerWrapper<
     BUILD_CONSTANTS = {},
     $injector,
     $instance,
+    resolve,
     log = noop,
-  }: {
-    BUILD_CONSTANTS?: WhookBuildConstantsService;
-    $injector: Injector<Service>;
-    $instance: Knifecycle;
-    log: LogService;
-  },
+  }: WhookGoogleFunctionsAutoloadDependencies,
   $autoload: Autoloader<Initializer<Dependencies, Service>>,
 ): Promise<
   (serviceName: string) => Promise<{
@@ -49,7 +70,15 @@ const initializerWrapper: ServiceInitializerWrapper<
 > => {
   let API: OpenAPIV3.Document;
   let OPERATION_APIS: WhookRawOperation<WhookAPIOperationGCPFunctionConfig>[];
-  const getAPIOperation = (() => {
+  const getAPIOperation: (
+    serviceName: string,
+  ) => Promise<
+    [
+      Required<WhookAPIOperationGCPFunctionConfig>['type'],
+      string,
+      OpenAPIV3.Document,
+    ]
+  > = (() => {
     return async (serviceName) => {
       // eslint-disable-next-line
       API = API || (await $injector(['API'])).API;
@@ -74,7 +103,7 @@ const initializerWrapper: ServiceInitializerWrapper<
       }
 
       // eslint-disable-next-line
-      const OPERATION_API = cleanupOpenAPI({
+      const OPERATION_API: OpenAPIV3.Document = cleanupOpenAPI({
         ...API,
         paths: {
           [OPERATION.path]: {
@@ -83,32 +112,58 @@ const initializerWrapper: ServiceInitializerWrapper<
         },
       });
 
-      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],
+      return [
+        OPERATION['x-whook']?.type || 'http',
+        OPERATION.operationId as string,
+        {
+          ...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) => {
+    if (UNBUILDABLE_SERVICES.includes(serviceName)) {
+      log(
+        'warning',
+        `🤷 - Building a project with the "${serviceName}" unbuildable service (ie Knifecycle ones: ${UNBUILDABLE_SERVICES.join(
+          ', ',
+        )}) can give unpredictable results!`,
+      );
+      return {
+        initializer: constant(serviceName, undefined),
+        path: `constant://${serviceName}`,
+      };
+    }
+
     try {
-      // TODO: add initializer map to knifecycle public API
-      const initializer = ($instance as any)._initializers.get(serviceName);
+      let initializer;
+
+      try {
+        initializer = $instance._getInitializer(serviceName);
+      } catch (err) {
+        log(
+          'debug',
+          `🤖 - Direct initializer access failure from the Knifecycle instance: "${serviceName}".`,
+        );
+        log('debug-stack', printStackTrace(err as Error));
+      }
 
       if (initializer && initializer[SPECIAL_PROPS.TYPE] === 'constant') {
         log(
@@ -122,7 +177,7 @@ const initializerWrapper: ServiceInitializerWrapper<
       }
 
       if (serviceName.startsWith('OPERATION_API_')) {
-        const OPERATION_API = await getAPIOperation(serviceName);
+        const [, , OPERATION_API] = await getAPIOperation(serviceName);
 
         return {
           initializer: constant(serviceName, OPERATION_API),
@@ -130,6 +185,45 @@ const initializerWrapper: ServiceInitializerWrapper<
         };
       }
 
+      if (serviceName.startsWith('OPERATION_WRAPPER_')) {
+        const [type] = await getAPIOperation(serviceName);
+
+        return {
+          initializer: alsoInject(
+            [
+              `OPERATION_API>${serviceName.replace(
+                'OPERATION_WRAPPER_',
+                'OPERATION_API_',
+              )}`,
+            ],
+            GCP_WRAPPERS[type].initializer as any,
+          ) as any,
+          path: resolve(
+            `@whook/gcp-functions/dist/wrappers/${GCP_WRAPPERS[type].name}`,
+          ),
+        };
+      }
+
+      if (serviceName.startsWith('OPERATION_HANDLER_')) {
+        const [, operationId] = await getAPIOperation(serviceName);
+
+        return {
+          name: serviceName,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          initializer: alsoInject(
+            [
+              `mainWrapper>OPERATION_WRAPPER_${serviceName.replace(
+                'OPERATION_HANDLER_',
+                '',
+              )}`,
+              `baseHandler>${operationId}`,
+            ],
+            initHandler,
+          ) as any,
+          path: resolve('@whook/gcp-functions/dist/services/HANDLER'),
+        };
+      }
+
       if (BUILD_CONSTANTS[serviceName]) {
         return {
           initializer: constant(serviceName, BUILD_CONSTANTS[serviceName]),
@@ -139,22 +233,25 @@ const initializerWrapper: ServiceInitializerWrapper<
 
       return $autoload(serviceName);
     } catch (err) {
-      log('error', `Build error while loading "${serviceName}".`);
-      log('error-stack', printStackTrace(err));
+      log('error', `💥 - Build error while loading "${serviceName}".`);
+      log('error-stack', printStackTrace(err as Error));
       throw err;
     }
   };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }) as any;
 
 /**
- * Wrap the _autoload service in order to build AWS
- *  Lambda compatible code.
+ * Wrap the _autoload service in order to build for GCP
+ *  Functions compatible code.
  * @param  {Object}   services
  * The services ENV depends on
- * @param  {Object}   services.NODE_ENV
- * The injected NODE_ENV value to add it to the build env
- * @param  {Object}   [services.PROXYED_ENV_VARS={}]
- * A list of environment variable names to proxy
+ * @param  {Object}   [services.BUILD_CONSTANTS]
+ * Service whose contents should be considered as constants
+ * @param  {Object}   $instance
+ * A Knifecycle instance
+ * @param  {Object}   $injector
+ * The Knifecycle injector
  * @param  {Object}   [services.log=noop]
  * An optional logging service
  * @return {Promise<Object>}
@@ -162,5 +259,6 @@ const initializerWrapper: ServiceInitializerWrapper<
  */
 export default alsoInject(
   ['?BUILD_CONSTANTS', '$instance', '$injector', '?log'],
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   wrapInitializer(initializerWrapper as any, initAutoload),
 );

package/src/services/log.ts

@@ -1,4 +1,4 @@
 import { service } from 'knifecycle';
+import { log } from 'node:console';
 
-// eslint-disable-next-line
-export default service(async () => console.log.bind(console), 'log');
+export default service(async () => log, 'log');