@whook/gcp-functions 18.0.3 → 19.0.0

package/src/commands/{testHTTPFunction.ts → testGCPFunctionRoute.ts}

@@ -1,82 +1,84 @@
 import { loadFunction } from '../libs/utils.js';
-import { extra, autoService } from 'knifecycle';
+import { location, autoService } from 'knifecycle';
 import { YError } from 'yerror';
+import stream from 'node:stream';
 import {
-  dereferenceOpenAPIOperations,
-  getOpenAPIOperations,
-} from '@whook/http-router';
-import stream from 'stream';
-import camelCase from 'camelcase';
-import { DEFAULT_COMPILER_OPTIONS, readArgs } from '@whook/whook';
-import type {
-  WhookCommandArgs,
-  WhookCommandDefinition,
-  WhookCompilerOptions,
+  DEFAULT_COMPILER_OPTIONS,
+  PATH_SEPARATOR,
+  SEARCH_SEPARATOR,
+  type WhookRouteHandlerParameters,
+  type WhookCommandHandler,
+  type WhookCommandDefinition,
+  type WhookCompilerOptions,
+  type WhookRoutesDefinitionsService,
 } from '@whook/whook';
-import type { LogService } from 'common-services';
-import type { OpenAPIV3_1 } from 'openapi-types';
+import { type LogService } from 'common-services';
 
-const SEARCH_SEPARATOR = '?';
-const PATH_SEPARATOR = '/';
-
-export const definition: WhookCommandDefinition = {
-  description: 'A command for testing GCP HTTP function',
-  example: `whook testHTTPFunction --name getPing`,
-  arguments: {
-    type: 'object',
-    additionalProperties: false,
-    required: ['name'],
-    properties: {
-      name: {
-        description: 'Name of the function to run',
+export const definition = {
+  name: 'testGCPFunctionRoute',
+  description: 'A command for testing a GCP function route',
+  example: `whook testGCPFunctionRoute --name getPing`,
+  arguments: [
+    {
+      description: 'Name of the function to run',
+      name: 'name',
+      required: true,
+      schema: {
         type: 'string',
       },
-      type: {
-        description: 'Type of function to test',
+    },
+    {
+      name: 'type',
+      description: 'Type of function to test',
+      schema: {
         type: 'string',
         enum: ['main', 'index'],
         default: 'index',
       },
-      contentType: {
-        description: 'Content type of the payload',
+    },
+    {
+      name: 'contentType',
+      description: 'Content type of the payload',
+      schema: {
         type: 'string',
         default: 'application/json',
       },
-      parameters: {
-        description: 'The HTTP call parameters',
+    },
+    {
+      name: 'parameters',
+      description: 'The HTTP call parameters',
+      schema: {
         type: 'string',
         default: '{}',
       },
     },
-  },
-};
-
-export default extra(definition, autoService(initTestHTTPFunctionCommand));
+  ],
+} as const satisfies WhookCommandDefinition;
 
-async function initTestHTTPFunctionCommand({
+async function initTestGCPFunctionRouteCommand({
   APP_ENV,
   PROJECT_DIR,
   COMPILER_OPTIONS = DEFAULT_COMPILER_OPTIONS,
-  API,
+  ROUTES_DEFINITIONS,
   log,
-  args,
 }: {
   APP_ENV: string;
   PROJECT_DIR: string;
   COMPILER_OPTIONS?: WhookCompilerOptions;
-  API: OpenAPIV3_1.Document;
+  ROUTES_DEFINITIONS: WhookRoutesDefinitionsService;
   log: LogService;
-  args: WhookCommandArgs;
-}) {
-  return async () => {
+}): Promise<
+  WhookCommandHandler<{
+    name: string;
+    type: string;
+    contentType: string;
+    parameters: string;
+  }>
+> {
+  return async (args) => {
     const {
       namedArguments: { name, type, contentType, parameters: rawParameters },
-    } = readArgs<{
-      name: string;
-      type: string;
-      contentType: string;
-      parameters: string;
-    }>(definition.arguments, args);
+    } = args;
     const extension = COMPILER_OPTIONS.format === 'cjs' ? '.cjs' : '.mjs';
     const handler = await loadFunction(
       { APP_ENV, PROJECT_DIR, log },
@@ -84,61 +86,52 @@ async function initTestHTTPFunctionCommand({
       type,
       extension,
     );
-    const OPERATION = (
-      await dereferenceOpenAPIOperations(API, getOpenAPIOperations(API))
-    ).find(({ operationId }) => operationId === name);
+    const handlerDefinition = ROUTES_DEFINITIONS[name]?.module?.definition;
 
-    if (!OPERATION) {
+    if (!handlerDefinition) {
       throw new YError('E_OPERATION_NOT_FOUND');
     }
 
-    const hasBody = !!OPERATION.requestBody;
-    const parameters = JSON.parse(rawParameters);
-    const search = (
-      (OPERATION.parameters || []) as OpenAPIV3_1.ParameterObject[]
-    )
-      .filter((p) => p.in === 'query')
-      .reduce((accSearch, p) => {
-        if (null != parameters[p.name]) {
+    const hasBody = !!handlerDefinition.operation.requestBody;
+    const parameters = JSON.parse(rawParameters) as WhookRouteHandlerParameters;
+    const search = Object.keys(parameters.query || {}).reduce(
+      (accSearch, name) => {
+        if (null != parameters.query[name]) {
           return (
             accSearch +
             (accSearch ? '&' : '') +
-            p.name +
+            name +
             '=' +
-            parameters[p.name]
+            parameters.query[name]
           );
         }
         return accSearch;
-      }, '');
+      },
+      '',
+    );
 
-    const path = OPERATION.path
+    const path = handlerDefinition.path
       .split(PATH_SEPARATOR)
-
       .map((part) => {
         const matches = /^\{([\d\w]+)\}$/i.exec(part);
 
         if (matches) {
-          return parameters[matches[1]];
+          return parameters.path?.[matches[1]];
         }
         return part;
       })
       .join(PATH_SEPARATOR);
     const gcpfRequest = {
-      method: OPERATION.method,
+      method: handlerDefinition.method,
       originalUrl: path + (search ? SEARCH_SEPARATOR + search : ''),
-      headers: ((OPERATION.parameters || []) as OpenAPIV3_1.ParameterObject[])
-        .filter((p) => p.in === 'header')
-        .reduce((headerParameters, p) => {
-          headerParameters[p.name] = parameters[camelCase(p.name)];
-          return headerParameters;
-        }, {}),
+      headers: parameters.header || {},
       rawBody: Buffer.from(
         hasBody
           ? contentType === 'application/json'
             ? parameters.body
               ? JSON.stringify(parameters.body)
               : ''
-            : parameters.body || ''
+            : (parameters.body as string) || ''
           : '',
       ),
     };
@@ -183,3 +176,8 @@ async function initTestHTTPFunctionCommand({
     log('info', 'SUCCESS:', response);
   };
 }
+
+export default location(
+  autoService(initTestGCPFunctionRouteCommand),
+  import.meta.url,
+);

package/src/index.ts

@@ -6,49 +6,46 @@ import { pathToFileURL } from 'node:url';
 import { mkdirp } from 'mkdirp';
 import cpr from 'cpr';
 import { printStackTrace, YError } from 'yerror';
-import { Knifecycle, constant, initInitializerBuilder } from 'knifecycle';
 import {
-  DEFAULT_BUILD_INITIALIZER_PATH_MAP as BASE_DEFAULT_BUILD_INITIALIZER_PATH_MAP,
-  initCompiler,
-} from '@whook/whook';
+  Knifecycle,
+  constant,
+  initInitializerBuilder,
+  type Autoloader,
+  type Dependencies,
+  type BuildInitializer,
+  type Initializer,
+  type Service,
+} from 'knifecycle';
 import initBuildAutoloader from './services/_autoload.js';
 import {
-  dereferenceOpenAPIOperations,
-  getOpenAPIOperations,
-} from '@whook/http-router';
-import type {
-  Autoloader,
-  Dependencies,
-  BuildInitializer,
-  Initializer,
-  Service,
-} from 'knifecycle';
-import type {
-  WhookOperation,
-  WhookCompilerOptions,
-  WhookCompilerService,
+  DEFAULT_BUILD_INITIALIZER_PATH_MAP as BASE_DEFAULT_BUILD_INITIALIZER_PATH_MAP,
+  initCompiler,
+  type WhookDefinitions,
+  type WhookCompilerOptions,
+  type WhookCompilerService,
 } from '@whook/whook';
-import type { OpenAPIV3_1 } from 'openapi-types';
-import type { LogService } from 'common-services';
-import type { CprOptions } from 'cpr';
+import { type LogService } from 'common-services';
+import { type CprOptions } from 'cpr';
 import { parseArgs } from '@whook/whook/dist/libs/args.js';
+import initWrapRouteHandlerForGoogleHTTPFunction from './wrappers/wrapRouteHandlerForGoogleHTTPFunction.js';
 
 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.js',
+  log: '@whook/whook/dist/services/rawLog.js',
 };
 
-export type WhookGCPBuildConfig = {
+export type * from './wrappers/wrapRouteHandlerForGoogleHTTPFunction.js';
+export { initWrapRouteHandlerForGoogleHTTPFunction };
+
+export type WhookGCPFunctionBuildConfig = {
   BUILD_PARALLELISM?: number;
 };
-export type WhookAPIOperationGCPFunctionConfig = {
-  type?: 'http';
-  sourceOperationId?: string;
+export type WhookGCPFunctionBaseConfig = {
   staticFiles?: string[];
   compilerOptions?: WhookCompilerOptions;
-  suffix?: string;
 };
+export type WhookGCPFunctionRouteConfig = WhookGCPFunctionBaseConfig;
 
 const cprAsync = promisify(cpr) as (
   source: string,
@@ -85,15 +82,15 @@ export async function runBuild(
       compiler,
       log,
       $autoload,
-      API,
+      DEFINITIONS,
       buildInitializer,
-    }: WhookGCPBuildConfig & {
+    }: WhookGCPFunctionBuildConfig & {
       APP_ENV: string;
       PROJECT_DIR: string;
       compiler: WhookCompilerService;
       log: LogService;
       $autoload: Autoloader<Initializer<Dependencies, Service>>;
-      API: OpenAPIV3_1.Document;
+      DEFINITIONS: WhookDefinitions;
       buildInitializer: BuildInitializer;
     } = await $.run([
       'APP_ENV',
@@ -103,43 +100,30 @@ export async function runBuild(
       'compiler',
       'log',
       '$autoload',
-      'API',
+      'DEFINITIONS',
       'buildInitializer',
     ]);
 
     log('info', 'GCP Functions build Environment initialized 🚀🌕');
 
-    const operations = (
-      await dereferenceOpenAPIOperations(
-        API,
-        getOpenAPIOperations<WhookAPIOperationGCPFunctionConfig>(API),
-      )
-    ).filter((operation) => {
-      if (handlerName) {
-        const sourceOperationId =
-          operation['x-whook'] && operation['x-whook'].sourceOperationId;
-
-        return (
-          handlerName === operation.operationId ||
-          handlerName === sourceOperationId
-        );
-      }
-      return true;
-    });
+    const handlerNames = Object.keys(DEFINITIONS.configs).filter(
+      (aHandlerName) => handlerName === aHandlerName || !handlerName,
+    );
 
-    log('warning', `📃 - ${operations.length} operations to process.`);
+    log('warning', `📃 - ${handlerNames.length} handlerNames to process.`);
 
-    await processOperations(
+    await processHandlers(
       {
         APP_ENV,
         BUILD_PARALLELISM: BUILD_PARALLELISM || DEFAULT_BUILD_PARALLELISM,
         PROJECT_DIR,
+        DEFINITIONS,
         compiler,
         log,
         $autoload,
         buildInitializer,
       },
-      operations,
+      handlerNames,
     );
     await $.destroy();
   } catch (err) {
@@ -150,124 +134,128 @@ export async function runBuild(
   }
 }
 
-async function processOperations(
+async function processHandlers(
   {
     APP_ENV,
     BUILD_PARALLELISM,
     PROJECT_DIR,
+    DEFINITIONS,
     compiler,
     log,
     $autoload,
     buildInitializer,
-  }: WhookGCPBuildConfig & {
+  }: WhookGCPFunctionBuildConfig & {
     APP_ENV: string;
     PROJECT_DIR: string;
+    DEFINITIONS: WhookDefinitions;
     compiler: WhookCompilerService;
     log: LogService;
     $autoload: Autoloader<Initializer<Dependencies, Service>>;
     buildInitializer: BuildInitializer;
   },
-  operations: WhookOperation<WhookAPIOperationGCPFunctionConfig>[],
+  handlerNames: string[],
 ): Promise<void> {
-  const operationsLeft = operations.slice(BUILD_PARALLELISM);
+  const handlerNamesLeft = handlerNames.slice(BUILD_PARALLELISM);
 
   await Promise.all(
-    operations.slice(0, BUILD_PARALLELISM).map((operation) =>
-      buildAnyLambda(
+    handlerNames.slice(0, BUILD_PARALLELISM).map((handlerName) =>
+      buildHandler(
         {
           APP_ENV,
           PROJECT_DIR,
+          DEFINITIONS,
           compiler,
           log,
           buildInitializer,
         },
-        operation,
+        handlerName,
       ),
     ),
   );
 
-  if (operationsLeft.length) {
-    log('info', `📃 - ${operationsLeft.length} operations left.`);
-    return processOperations(
+  if (handlerNamesLeft.length) {
+    log('info', `📃 - ${handlerNamesLeft.length} handlerNames left.`);
+    return processHandlers(
       {
         APP_ENV,
         BUILD_PARALLELISM,
         PROJECT_DIR,
+        DEFINITIONS,
         compiler,
         log,
         $autoload,
         buildInitializer,
       },
-      operationsLeft,
+      handlerNamesLeft,
     );
   }
-  log('info', '🤷 - No more operations.');
+  log('info', '🤷 - No more handlerNames.');
 }
 
-async function buildAnyLambda(
+async function buildHandler(
   {
     APP_ENV,
     PROJECT_DIR,
+    DEFINITIONS,
     compiler,
     log,
     buildInitializer,
   }: {
     APP_ENV: string;
     PROJECT_DIR: string;
+    DEFINITIONS: WhookDefinitions;
     compiler: WhookCompilerService;
     log: LogService;
     buildInitializer: BuildInitializer;
   },
-  operation: WhookOperation<WhookAPIOperationGCPFunctionConfig>,
+  handlerName: string,
 ): Promise<void> {
-  const { operationId } = operation;
-
   try {
-    const whookConfig: WhookAPIOperationGCPFunctionConfig = operation[
-      'x-whook'
-    ] || { type: 'http' };
-    const operationType = whookConfig.type || 'http';
-    const sourceOperationId = whookConfig.sourceOperationId;
-    const finalEntryPoint =
-      (sourceOperationId ? sourceOperationId : operationId) +
-      ((operation['x-whook'] || {}).suffix || '');
-
-    log('warning', `🏗 - Building ${operationType} "${finalEntryPoint}"...`);
-
-    const lambdaPath = join(PROJECT_DIR, 'builds', APP_ENV, finalEntryPoint);
+    const definition = DEFINITIONS.configs[handlerName];
+
+    if (definition.type !== 'route') {
+      log('warning', `🚮 - Skipping "${handlerName}"...`);
+      return;
+    }
+
+    log('warning', `🏗 - Building "${handlerName}"...`);
+
+    const handlerPath = join(PROJECT_DIR, 'builds', APP_ENV, handlerName);
     const srcPath = join(PROJECT_DIR, 'src');
-    const srcRelativePath = relative(lambdaPath, srcPath);
+    const srcRelativePath = relative(handlerPath, srcPath);
 
     const initializerContent = (
-      await buildInitializer([`OPERATION_HANDLER_${finalEntryPoint}`])
+      await buildInitializer([`MAIN_HANDLER_${handlerName}`])
     ).replaceAll(pathToFileURL(srcPath).toString(), srcRelativePath);
-    const indexContent = await buildLambdaIndex(
-      `OPERATION_HANDLER_${finalEntryPoint}`,
-    );
+    const indexContent = await buildHandlerIndex(`MAIN_HANDLER_${handlerName}`);
 
-    await mkdirp(lambdaPath);
+    await mkdirp(handlerPath);
     await Promise.all([
       copyStaticFiles(
         { PROJECT_DIR, log },
-        lambdaPath,
-        whookConfig.staticFiles || [],
+        handlerPath,
+        definition.config?.staticFiles || [],
       ),
       ensureFile(
         { log },
-        join(lambdaPath, 'initialize.js'),
+        join(handlerPath, 'initialize.js'),
         initializerContent,
       ),
-      ensureFile({ log }, join(lambdaPath, 'main.js'), indexContent),
+      ensureFile({ log }, join(handlerPath, 'main.js'), indexContent),
     ]);
-    await buildFinalLambda({ compiler, log }, lambdaPath, whookConfig);
+    await buildFinalHandler(
+      { DEFINITIONS, compiler, log },
+      handlerPath,
+      handlerName,
+    );
   } catch (err) {
-    log('error', `Error building "${operationId}"...`);
+    log('error', `💥 - Error building "${handlerName}"...`);
     log('error-stack', printStackTrace(err as Error));
-    throw YError.wrap(err as Error, 'E_LAMBDA_BUILD', operationId);
+    throw YError.wrap(err as Error, 'E_HANDLER_BUILD', handlerName);
   }
 }
 
-async function buildLambdaIndex(name: string): Promise<string> {
+async function buildHandlerIndex(handlerName: string): Promise<string> {
   return `// Automatically generated by \`@whook/gcp-functions\`
 import { initialize } from './initialize.js';
 
@@ -275,28 +263,36 @@ const initializationPromise = initialize();
 
 export default function handler (req, res) {
   return initializationPromise
-    .then(services => services['${name}'](req, res));
+    .then(services => services['${handlerName}'](req, res));
 };
 `;
 }
 
-async function buildFinalLambda(
-  { compiler, log }: { compiler: WhookCompilerService; log: LogService },
-  lambdaPath: string,
-  whookConfig: WhookAPIOperationGCPFunctionConfig,
+async function buildFinalHandler(
+  {
+    DEFINITIONS,
+    compiler,
+    log,
+  }: {
+    DEFINITIONS: WhookDefinitions;
+    compiler: WhookCompilerService;
+    log: LogService;
+  },
+  handlerPath: string,
+  handlerName: string,
 ): Promise<void> {
-  const entryPoint = `${lambdaPath}/main.js`;
+  const entryPoint = `${handlerPath}/main.js`;
   const { extension, contents, mappings } = await compiler(
     entryPoint,
-    whookConfig.compilerOptions,
+    DEFINITIONS[handlerName]?.config?.compilerOptions,
   );
 
   await Promise.all([
-    ensureFile({ log }, join(lambdaPath, `/index${extension}`), contents),
+    ensureFile({ log }, join(handlerPath, `/index${extension}`), contents),
     mappings
       ? ensureFile(
           { log },
-          join(lambdaPath, `/index${extension}.map`),
+          join(handlerPath, `/index${extension}.map`),
           mappings,
         )
       : Promise.resolve(),
@@ -305,7 +301,7 @@ async function buildFinalLambda(
 
 async function copyStaticFiles(
   { PROJECT_DIR, log }: { PROJECT_DIR: string; log: LogService },
-  lambdaPath: string,
+  handlerPath: string,
   staticFiles: string[] = [],
 ): Promise<void> {
   await Promise.all(
@@ -314,7 +310,7 @@ async function copyStaticFiles(
         await copyFiles(
           { log },
           join(PROJECT_DIR, 'node_modules', staticFile),
-          join(lambdaPath, 'node_modules', staticFile),
+          join(handlerPath, 'node_modules', staticFile),
         ),
     ),
   );

package/src/libs/utils.ts

@@ -1,6 +1,6 @@
 import { YError } from 'yerror';
-import path from 'path';
-import type { LogService } from 'common-services';
+import path from 'node:path';
+import { type LogService } from 'common-services';
 
 export async function loadFunction(
   {