@whook/gcp-functions 18.1.0 → 19.0.0

package/src/services/_autoload.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import {
-  UNBUILDABLE_SERVICES,
   Knifecycle,
   wrapInitializer,
   constant,
@@ -16,18 +15,24 @@ import {
 import { YError } from 'yerror';
 import {
   initBuildAutoload,
+  initMainHandler,
   noop,
-  cleanupOpenAPI,
-  dereferenceOpenAPIOperations,
-  getOpenAPIOperations,
+  type WhookOpenAPI,
   type WhookBuildConstantsService,
-  type WhookRawOperation,
+  type WhookDefinitions,
+  type WhookRouteDefinition,
+  type WhookRoutesDefinitionsService,
 } from '@whook/whook';
 import { type LogService } from 'common-services';
-import { type OpenAPIV3_1 } from 'openapi-types';
-import { type WhookAPIOperationGCPFunctionConfig } from '../index.js';
-import initHandler from './HANDLER.js';
-import initWrapHandlerForGoogleHTTPFunction from '../wrappers/wrapHandlerForGoogleHTTPFunction.js';
+import { cleanupOpenAPI } from 'ya-open-api-types';
+import initWrapRouteHandlerForGoogleHTTPFunction from '../wrappers/wrapRouteHandlerForGoogleHTTPFunction.js';
+
+export type GCPFunctionDefinition = {
+  name: string;
+  type: 'route';
+  definition: WhookRouteDefinition;
+  openAPI: WhookOpenAPI;
+};
 
 export type WhookGoogleFunctionsAutoloadDependencies = {
   BUILD_CONSTANTS?: WhookBuildConstantsService;
@@ -36,19 +41,6 @@ export type WhookGoogleFunctionsAutoloadDependencies = {
   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
@@ -58,125 +50,106 @@ const initializerWrapper: ServiceInitializerWrapper<
 ): Promise<
   (serviceName: string) => Promise<Initializer<Dependencies, Service>>
 > => {
-  let API: OpenAPIV3_1.Document;
-  let OPERATION_APIS: WhookRawOperation<WhookAPIOperationGCPFunctionConfig>[];
-  const getAPIOperation: (
-    serviceName: string,
-  ) => Promise<
-    [
-      Required<WhookAPIOperationGCPFunctionConfig>['type'],
-      string,
-      OpenAPIV3_1.Document,
-    ]
-  > = (() => {
-    return async (serviceName) => {
-      const cleanedName = serviceName.split('_').pop();
+  let API: WhookOpenAPI;
+  let DEFINITIONS: WhookDefinitions;
+  let ROUTES_DEFINITIONS: WhookRoutesDefinitionsService;
+  const getDefinition = (() => {
+    return async (serviceName: string): Promise<GCPFunctionDefinition> => {
+      const cleanedName = serviceName.split('_').pop() as string;
 
       API = API || (await $injector(['API'])).API;
-      OPERATION_APIS =
-        OPERATION_APIS ||
-        getOpenAPIOperations<WhookAPIOperationGCPFunctionConfig>(API);
-
-      const OPERATION = OPERATION_APIS.find(
-        (operation) =>
-          cleanedName ===
-          (((operation['x-whook'] || {}).sourceOperationId &&
-            (operation['x-whook'] || {}).sourceOperationId) ||
-            operation.operationId) +
-            ((operation['x-whook'] || {}).suffix || ''),
-      );
+      DEFINITIONS =
+        DEFINITIONS || (await $injector(['DEFINITIONS'])).DEFINITIONS;
+      ROUTES_DEFINITIONS =
+        ROUTES_DEFINITIONS ||
+        (await $injector(['ROUTES_DEFINITIONS'])).ROUTES_DEFINITIONS;
+
+      const config = DEFINITIONS.configs[cleanedName as string];
 
-      if (!OPERATION) {
-        log('error', '💥 - Unable to find a function operation definition!');
-        throw new YError('E_OPERATION_NOT_FOUND', serviceName);
+      if (!config) {
+        log('error', '💥 - Unable to find a GCP Function definition!');
+        throw new YError('E_DEFINITION_NOT_FOUND', serviceName, cleanedName);
       }
 
-      const OPERATION_API: OpenAPIV3_1.Document = cleanupOpenAPI({
+      if (!config || config.type !== 'route') {
+        log('error', '💥 - GCP Function only supports routes!');
+        throw new YError('E_UNSUPPORTED_DEFINITION', serviceName, cleanedName);
+      }
+
+      const openAPI = (await cleanupOpenAPI({
         ...API,
         paths: {
-          [OPERATION.path]: {
-            [OPERATION.method]: API.paths?.[OPERATION.path]?.[OPERATION.method],
-          },
-        },
-      });
-
-      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],
-            },
+          [config.path]: {
+            parameters: API?.paths?.[config.path]?.parameters || [],
+            [config.method]: API.paths?.[config.path]?.[config.method],
           },
         },
-      ];
+      })) as WhookOpenAPI;
+
+      return {
+        name: cleanedName,
+        type: 'route',
+        openAPI,
+        definition:
+          ROUTES_DEFINITIONS[cleanedName]?.module?.definition || config,
+      };
     };
   })();
 
-  log('debug', '🤖 - Initializing the `$autoload` build wrapper.');
+  log(
+    'debug',
+    '🤖 - Initializing the GCP Functions `$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!`,
+    if (serviceName.startsWith('MAIN_API_')) {
+      const definition = await getDefinition(serviceName);
+
+      return constant(
+        serviceName,
+        definition.type === 'route' ? definition.openAPI : {},
       );
-      return constant(serviceName, undefined);
     }
 
-    if (serviceName.startsWith('OPERATION_API_')) {
-      const [, , OPERATION_API] = await getAPIOperation(serviceName);
+    if (serviceName.startsWith('MAIN_DEFINITION_')) {
+      const { definition } = await getDefinition(serviceName);
 
-      return constant(serviceName, OPERATION_API);
+      return constant(serviceName, definition);
     }
 
-    if (serviceName.startsWith('OPERATION_WRAPPER_')) {
-      const [type] = await getAPIOperation(serviceName);
-
+    if (serviceName.startsWith('MAIN_WRAPPER_')) {
       return location(
         alsoInject(
           [
-            `OPERATION_API>${serviceName.replace(
-              'OPERATION_WRAPPER_',
-              'OPERATION_API_',
+            `MAIN_DEFINITION>${serviceName.replace(
+              'MAIN_WRAPPER_',
+              'MAIN_DEFINITION_',
             )}`,
+            `MAIN_API>${serviceName.replace('MAIN_WRAPPER_', 'MAIN_API_')}`,
           ],
-          GCP_WRAPPERS[type].initializer as any,
-        ),
-        `@whook/gcp-functions/dist/wrappers/${GCP_WRAPPERS[type].name}.js`,
+          initWrapRouteHandlerForGoogleHTTPFunction as any,
+        ) as any,
+        `@whook/gcp-functions/dist/wrappers/wrapRouteHandlerForGoogleHTTPFunction.js`,
       ) as any;
     }
 
-    if (serviceName.startsWith('OPERATION_HANDLER_')) {
-      const [, operationId] = await getAPIOperation(serviceName);
+    if (serviceName.startsWith('MAIN_HANDLER_')) {
+      const { type, name, definition } = await getDefinition(serviceName);
+      const targetHandler = definition.config?.targetHandler || name;
 
       return location(
         alsoInject(
           [
-            `mainWrapper>OPERATION_WRAPPER_${serviceName.replace(
-              'OPERATION_HANDLER_',
+            `MAIN_WRAPPER>MAIN_WRAPPER_${serviceName.replace(
+              'MAIN_HANDLER_',
               '',
             )}`,
-            `baseHandler>${operationId}`,
+            `?WRAPPERS>${type.toUpperCase()}S_WRAPPERS`,
+            `BASE_HANDLER>${targetHandler}`,
           ],
-          initHandler,
-        ),
-        '@whook/gcp-functions/dist/services/HANDLER.js',
+          initMainHandler,
+        ) as any,
+        '@whook/whook/dist/services/MAIN_HANDLER.js',
       );
     }
 

package/src/types.d.ts

@@ -0,0 +1,8 @@
+import { type WhookBaseRouteConfig } from '@whook/whook';
+import { type WhookGCPFunctionRouteConfig } from './index.ts';
+
+declare module '@whook/whook' {
+  export interface WhookRouteConfig
+    extends WhookBaseRouteConfig,
+      WhookGCPFunctionRouteConfig {}
+}