@whook/gcp-functions 18.0.3 → 19.0.0

package/src/wrappers/wrapRouteHandlerForGoogleHTTPFunction.ts

@@ -0,0 +1,571 @@
+import { YError, printStackTrace } from 'yerror';
+import stream, { type Readable } from 'node:stream';
+import { autoService } from 'knifecycle';
+import bytes from 'bytes';
+import { YHTTPError } from 'yhttperror';
+import {
+  DEFAULT_COERCION_OPTIONS,
+  DEFAULT_BUFFER_LIMIT,
+  DEFAULT_PARSERS,
+  DEFAULT_STRINGIFYERS,
+  DEFAULT_DECODERS,
+  DEFAULT_ENCODERS,
+  SEARCH_SEPARATOR,
+  PATH_SEPARATOR,
+  extractOperationSecurityParameters,
+  prepareBodyValidator,
+  extractBodySpec,
+  extractResponseSpec,
+  checkResponseCharset,
+  checkResponseMediaType,
+  executeHandler,
+  extractProduceableMediaTypes,
+  extractConsumableMediaTypes,
+  getBody,
+  sendBody,
+  noop,
+  identity,
+  lowerCaseHeaders,
+  resolveParameters,
+  createParametersValidators,
+  pickFirstHeaderValue,
+  type WhookRequest,
+  type WhookResponse,
+  type WhookRouteHandler,
+  type WhookObfuscatorService,
+  type WhookRouteHandlerWrapper,
+  type WhookErrorHandler,
+  type WhookOpenAPI,
+  type WhookCoercionOptions,
+  type WhookRouteDefinition,
+  type WhookRequestBody,
+  type WhookHTTPRouterDescriptor,
+  type WhookSchemaValidatorsService,
+  type WhookRouteHandlerParameters,
+  type WhookQueryParserBuilderService,
+} from '@whook/whook';
+import { type LogService } from 'common-services';
+import {
+  ensureResolvedObject,
+  type OpenAPIReference,
+  type OpenAPIExtension,
+  type OpenAPIResponse,
+} from 'ya-open-api-types';
+import { type ExpressiveJSONSchema } from 'ya-json-schema-types';
+
+export type WhookGCPFunctionRouteWrapperDependencies = {
+  MAIN_DEFINITION: WhookRouteDefinition;
+  MAIN_API: WhookOpenAPI;
+  DECODERS?: typeof DEFAULT_DECODERS;
+  ENCODERS?: typeof DEFAULT_ENCODERS;
+  PARSERS?: typeof DEFAULT_PARSERS;
+  STRINGIFYERS?: typeof DEFAULT_STRINGIFYERS;
+  queryParserBuilder: WhookQueryParserBuilderService;
+  BUFFER_LIMIT?: string;
+  COERCION_OPTIONS: WhookCoercionOptions;
+  obfuscator: WhookObfuscatorService;
+  errorHandler: WhookErrorHandler;
+  schemaValidators: WhookSchemaValidatorsService;
+  log?: LogService;
+};
+
+/**
+ * Wrap an handler to make it work with GCP Functions.
+ * @param  {Object}   services
+ * The services the wrapper depends on
+ * @param  {Object}   services.MAIN_DEFINITION
+ * An OpenAPI definitition for that handler
+ * @param  {Object}   services.DECODERS
+ * Request body decoders available
+ * @param  {Object}   services.ENCODERS
+ * Response body encoders available
+ * @param  {Object}   services.PARSERS
+ * Request body parsers available
+ * @param  {Object}   services.STRINGIFYERS
+ * Response body stringifyers available
+ * @param  {Object}   services.BUFFER_LIMIT
+ * The buffer size limit
+ * @param  {Object} services.queryParserBuilder
+ * A query parser builder from OpenAPI parameters
+ * @param  {Object}   services.obfuscator
+ * A service to hide sensible values
+ * @param  {Object}   services.errorHandler
+ * A service that changes any error to Whook response
+ * @param  {Object}   [services.log=noop]
+ * An optional logging service
+ * @return {Promise<Object>}
+ * A promise of an object containing the reshaped env vars.
+ */
+
+async function initWrapRouteHandlerForGoogleHTTPFunction({
+  MAIN_DEFINITION,
+  MAIN_API,
+  DECODERS = DEFAULT_DECODERS,
+  ENCODERS = DEFAULT_ENCODERS,
+  PARSERS = DEFAULT_PARSERS,
+  STRINGIFYERS = DEFAULT_STRINGIFYERS,
+  BUFFER_LIMIT = DEFAULT_BUFFER_LIMIT,
+  queryParserBuilder,
+  COERCION_OPTIONS = DEFAULT_COERCION_OPTIONS,
+  obfuscator,
+  errorHandler,
+  schemaValidators,
+  log = noop,
+}: WhookGCPFunctionRouteWrapperDependencies): Promise<WhookRouteHandlerWrapper> {
+  log('debug', '📥 - Initializing the GCP Function wrapper.');
+
+  const path = MAIN_DEFINITION.path;
+  const pathItem = MAIN_API.paths?.[path];
+
+  if (typeof pathItem === 'undefined' || '$ref' in pathItem) {
+    throw new YError('E_BAD_OPERATION', 'pathItem', pathItem);
+  }
+
+  const method = MAIN_DEFINITION.method;
+  const operation = pathItem[method];
+
+  if (typeof operation === 'undefined' || '$ref' in operation) {
+    throw new YError('E_BAD_OPERATION', 'operation', operation);
+  }
+
+  const pathItemParameters = await resolveParameters(
+    { API: MAIN_API, log },
+    pathItem.parameters || [],
+  );
+  const pathItemValidators = await createParametersValidators(
+    {
+      API: MAIN_API,
+      COERCION_OPTIONS,
+      schemaValidators,
+    },
+    pathItemParameters,
+  );
+
+  const operationParameters = await resolveParameters(
+    { API: MAIN_API, log },
+    operation.parameters || [],
+  );
+  const ammendedParameters = await resolveParameters(
+    { API: MAIN_API, log },
+    await extractOperationSecurityParameters({ API: MAIN_API }, operation),
+  );
+  const operationValidators = await createParametersValidators(
+    {
+      API: MAIN_API,
+      COERCION_OPTIONS,
+      schemaValidators,
+    },
+    operationParameters.concat(ammendedParameters),
+  );
+  const bodyValidator = await prepareBodyValidator(
+    { API: MAIN_API, schemaValidators },
+    operation,
+  );
+  const consumableCharsets = Object.keys(DECODERS);
+  const produceableCharsets = Object.keys(ENCODERS);
+  const consumableMediaTypes = await extractConsumableMediaTypes(
+    MAIN_API,
+    operation,
+  );
+  const produceableMediaTypes = await extractProduceableMediaTypes(
+    MAIN_API,
+    operation,
+  );
+  const parameters = pathItemParameters
+    .concat(ammendedParameters)
+    .filter((parameter) =>
+      operationParameters.every(
+        (aParameter) =>
+          aParameter.in !== parameter.in || aParameter.name !== parameter.name,
+      ),
+    )
+    .concat(operationParameters);
+  const queryParser = await queryParserBuilder(parameters);
+  const wrapper = async (
+    handler: WhookRouteHandler,
+  ): Promise<WhookRouteHandler> => {
+    const wrappedHandler = handleForAWSHTTPFunction.bind(
+      null,
+      {
+        MAIN_DEFINITION,
+        MAIN_API,
+        DECODERS,
+        ENCODERS,
+        PARSERS,
+        STRINGIFYERS,
+        BUFFER_LIMIT,
+        obfuscator,
+        errorHandler,
+        log,
+      },
+      {
+        consumableCharsets,
+        produceableCharsets,
+        handler,
+        operation,
+        queryParser,
+        parametersValidators: {
+          path: {
+            ...pathItemValidators.path,
+            ...operationValidators.path,
+          },
+          query: {
+            ...pathItemValidators.query,
+            ...operationValidators.query,
+          },
+          header: {
+            ...pathItemValidators.header,
+            ...operationValidators.header,
+          },
+          cookie: {
+            ...pathItemValidators.cookie,
+            ...operationValidators.cookie,
+          },
+        },
+        consumableMediaTypes,
+        produceableMediaTypes,
+        bodyValidator,
+      },
+      MAIN_DEFINITION,
+    );
+
+    return wrappedHandler as unknown as WhookRouteHandler;
+  };
+
+  return wrapper;
+}
+
+async function handleForAWSHTTPFunction(
+  {
+    MAIN_API,
+    DECODERS,
+    ENCODERS,
+    PARSERS,
+    STRINGIFYERS,
+    BUFFER_LIMIT,
+    obfuscator,
+    errorHandler,
+    log,
+  }: Omit<
+    Required<WhookGCPFunctionRouteWrapperDependencies>,
+    'COERCION_OPTIONS' | 'schemaValidators' | 'queryParserBuilder'
+  >,
+  {
+    handler,
+    operation,
+    parametersValidators,
+    consumableMediaTypes,
+    produceableMediaTypes,
+    consumableCharsets,
+    produceableCharsets,
+    queryParser,
+    bodyValidator,
+  }: WhookHTTPRouterDescriptor & {
+    consumableCharsets: string[];
+    produceableCharsets: string[];
+  },
+  definition: WhookRouteDefinition,
+  req,
+  res,
+) {
+  const bufferLimit =
+    bytes.parse(BUFFER_LIMIT) || (bytes.parse(DEFAULT_BUFFER_LIMIT) as number);
+
+  log?.(
+    'info',
+    'GCP_FUNCTIONS_REQUEST',
+    JSON.stringify({
+      url: req.originalUrl,
+      method: req.method,
+      body: req.body,
+      // body: obfuscateEventBody(obfuscator, req.body),
+      headers: obfuscator.obfuscateSensibleHeaders(req.headers || {}),
+    }),
+  );
+
+  const request = await gcpfReqToRequest(req);
+  let response;
+  let responseLog;
+  let responseSpec;
+
+  log?.(
+    'debug',
+    'REQUEST',
+    JSON.stringify({
+      ...request,
+      body: request.body ? 'Stream' : undefined,
+      headers: obfuscator.obfuscateSensibleHeaders(request.headers),
+    }),
+  );
+
+  const parametersValues: WhookRouteHandlerParameters = {
+    query: {},
+    header: {},
+    path: {},
+    cookie: {},
+    body: undefined as unknown as WhookRequestBody,
+    options: {},
+  };
+
+  try {
+    try {
+      const path = request.url.split(SEARCH_SEPARATOR)[0];
+      const parts = path.split(PATH_SEPARATOR).filter(identity);
+      const search = request.url.substr(
+        request.url.split(SEARCH_SEPARATOR)[0].length,
+      );
+      const queryValues = queryParser(search);
+      const pathParameters = (
+        definition.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 }) => ({
+            ...accParameters,
+            [name]: value,
+          }),
+          {},
+        );
+
+      for (const location of Object.keys(parametersValidators)) {
+        if (location === 'query') {
+          for (const [name, validator] of Object.entries(
+            parametersValidators.query,
+          )) {
+            parametersValues.query[name] = validator(
+              queryValues && typeof queryValues[name] !== 'undefined'
+                ? queryValues[name]?.toString()
+                : undefined,
+            );
+          }
+        } else if (location === 'header') {
+          for (const [name, validator] of Object.entries(
+            parametersValidators.header,
+          )) {
+            // header names are case insensitive
+            const canonicalName = name.toLowerCase();
+
+            parametersValues.header[name] = validator(
+              typeof request.headers[canonicalName] !== 'undefined'
+                ? request.headers[canonicalName].toString()
+                : undefined,
+            );
+          }
+        } else if (location === 'path') {
+          for (const [name, validator] of Object.entries(
+            parametersValidators.path,
+          )) {
+            parametersValues.path[name] = validator(
+              pathParameters && typeof pathParameters[name] !== 'undefined'
+                ? pathParameters[name].toString()
+                : undefined,
+            );
+          }
+        }
+      }
+
+      const bodySpec = extractBodySpec(
+        request,
+        consumableMediaTypes || [],
+        consumableCharsets,
+      );
+
+      responseSpec = extractResponseSpec(
+        operation,
+        request,
+        produceableMediaTypes || [],
+        produceableCharsets,
+      );
+
+      const body = await getBody(
+        {
+          API: MAIN_API,
+          DECODERS,
+          PARSERS,
+          bufferLimit,
+        },
+        operation,
+        request.body as Readable,
+        bodySpec,
+      );
+
+      bodyValidator(operation, bodySpec.contentType, body);
+
+      if (typeof body !== 'undefined') {
+        parametersValues.body = body;
+      }
+    } catch (err) {
+      throw YHTTPError.cast(err as Error, 400);
+    }
+
+    response = await executeHandler(definition, handler, parametersValues);
+
+    response.headers = response.headers || {};
+
+    if (response.body) {
+      response.headers['content-type'] =
+        response.headers['content-type'] || responseSpec.contentTypes[0];
+    }
+
+    const responseContentType =
+      pickFirstHeaderValue('content-type', response.headers || {}) ||
+      'text/plain';
+
+    const responseObject =
+      operation.responses && operation.responses[response.status]
+        ? await ensureResolvedObject(
+            MAIN_API,
+            operation.responses[response.status] as
+              | OpenAPIResponse<ExpressiveJSONSchema, OpenAPIExtension>
+              | OpenAPIReference<
+                  OpenAPIResponse<ExpressiveJSONSchema, OpenAPIExtension>
+                >,
+          )
+        : undefined;
+    const responseSchema =
+      responseObject &&
+      responseObject.content &&
+      responseObject.content?.[responseContentType] &&
+      'schema' in responseObject.content[responseContentType] &&
+      ((await ensureResolvedObject(
+        MAIN_API,
+        responseObject.content?.[responseContentType].schema,
+      )) as ExpressiveJSONSchema);
+
+    // Check the stringifyer only when a schema is
+    // specified and it is not a binary one
+    const responseHasSchema =
+      typeof responseSchema === 'boolean' ||
+      (typeof responseSchema === 'object' &&
+        responseSchema &&
+        !(
+          'type' in responseSchema &&
+          responseSchema.type === 'string' &&
+          responseSchema.format === 'binary'
+        ));
+
+    if (responseHasSchema && !STRINGIFYERS[responseContentType]) {
+      throw new YHTTPError(
+        500,
+        'E_STRINGIFYER_LACK',
+        response.headers['content-type'],
+        response,
+      );
+    }
+    if (response.body) {
+      checkResponseMediaType(
+        request,
+        responseSpec,
+        produceableMediaTypes || [],
+      );
+      checkResponseCharset(request, responseSpec, produceableCharsets);
+    }
+    responseLog = {
+      type: 'success',
+      status: response.status,
+    };
+    log?.('debug', JSON.stringify(responseLog));
+  } catch (err) {
+    response = await errorHandler('none', responseSpec, err as Error);
+    responseLog = {
+      type: 'error',
+      code: (err as YError)?.code || 'E_UNEXPECTED',
+      statusCode: response.status,
+      params: (err as YError)?.params || [],
+      stack: printStackTrace(err as Error),
+    };
+
+    log?.('error', JSON.stringify(responseLog));
+
+    response = {
+      ...response,
+      headers: {
+        ...response.headers,
+        'content-type': 'application/json',
+      },
+    };
+  }
+
+  log?.(
+    'debug',
+    'RESPONSE',
+    JSON.stringify({
+      ...response,
+      body: obfuscateEventBody(obfuscator, response.body),
+      headers: obfuscator.obfuscateSensibleHeaders(response.headers),
+    }),
+  );
+
+  await pipeResponseInGCPFResponse(
+    await sendBody(
+      {
+        ENCODERS,
+        STRINGIFYERS,
+      },
+      response,
+    ),
+    res,
+  );
+}
+
+async function gcpfReqToRequest(req): Promise<WhookRequest> {
+  const request: WhookRequest = {
+    method: req.method.toLowerCase(),
+    headers: lowerCaseHeaders(req.headers || {}),
+    url: req.originalUrl,
+  };
+
+  if (req.rawBody) {
+    request.headers['content-length'] = req.rawBody.length.toString();
+    const bodyStream = new stream.PassThrough();
+
+    request.body = bodyStream;
+    bodyStream.write(req.rawBody);
+    bodyStream.end();
+  }
+
+  return request;
+}
+
+async function pipeResponseInGCPFResponse(
+  response: WhookResponse,
+  res,
+): Promise<void> {
+  Object.keys(response.headers || {}).forEach((headerName) => {
+    res.set(headerName, response.headers?.[headerName]);
+  });
+  res.status(response.status);
+
+  if (response.body) {
+    (response.body as Readable).pipe(res);
+    return;
+  }
+
+  res.end();
+}
+
+function obfuscateEventBody(obfuscator, rawBody) {
+  if (typeof rawBody === 'string') {
+    try {
+      const jsonBody = JSON.parse(rawBody);
+
+      return JSON.stringify(obfuscator.obfuscateSensibleProps(jsonBody));
+      // eslint-disable-next-line
+    } catch (err) {}
+  }
+  return rawBody;
+}
+
+export default autoService(initWrapRouteHandlerForGoogleHTTPFunction);

package/dist/commands/testHTTPFunction.d.ts

@@ -1,13 +0,0 @@
-import type { WhookCommandArgs, WhookCommandDefinition, WhookCompilerOptions } from '@whook/whook';
-import type { LogService } from 'common-services';
-import type { OpenAPIV3_1 } from 'openapi-types';
-export declare const definition: WhookCommandDefinition;
-declare const _default: import("knifecycle").ServiceInitializer<{
-    APP_ENV: string;
-    PROJECT_DIR: string;
-    COMPILER_OPTIONS?: WhookCompilerOptions;
-    API: OpenAPIV3_1.Document;
-    log: LogService;
-    args: WhookCommandArgs;
-}, () => Promise<void>>;
-export default _default;

package/dist/commands/testHTTPFunction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testHTTPFunction.js","sourceRoot":"","sources":["../../src/commands/testHTTPFunction.ts"],"names":[],"mappings":"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"}

package/dist/services/HANDLER.d.ts

@@ -1,11 +0,0 @@
-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;
-};
-declare const _default: import("knifecycle").ServiceInitializer<WhookHandlerDependencies<WhookHandler<import("knifecycle").Parameters, import("@whook/http-transaction").WhookResponse<number, void | import("@whook/http-transaction").WhookHeaders, void | import("stream").Readable | import("type-fest").JsonValue>, import("@whook/http-transaction").WhookOperation<Record<string, unknown>>>>, WhookHandler<WhookHandler<import("knifecycle").Parameters, import("@whook/http-transaction").WhookResponse<number, void | import("@whook/http-transaction").WhookHeaders, void | import("stream").Readable | import("type-fest").JsonValue>, import("@whook/http-transaction").WhookOperation<Record<string, unknown>>>, import("@whook/http-transaction").WhookResponse<number, void | import("@whook/http-transaction").WhookHeaders, void | import("stream").Readable | import("type-fest").JsonValue>, import("@whook/http-transaction").WhookOperation<Record<string, unknown>>>>;
-export default _default;

package/dist/services/HANDLER.js

@@ -1,21 +0,0 @@
-import { autoService, name, location } from 'knifecycle';
-import { noop, applyWrappers } from '@whook/whook';
-export default location(name('HANDLER', autoService(initHandler)), import.meta.url);
-/**
- * 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({ WRAPPERS, mainWrapper, baseHandler, log = noop, }) {
-    log('warning', `🏭 - Initializing the HANDLER service with wrapped by ${WRAPPERS.length} wrappers.`);
-    return await applyWrappers([...WRAPPERS, mainWrapper], baseHandler);
-}
-//# sourceMappingURL=HANDLER.js.map

package/dist/services/HANDLER.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HANDLER.js","sourceRoot":"","sources":["../../src/services/HANDLER.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAqB,MAAM,cAAc,CAAC;AAWtE,eAAe,QAAQ,CACrB,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,EACzC,MAAM,CAAC,IAAI,CAAC,GAAG,CAChB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,KAAK,UAAU,WAAW,CAAyB,EACjD,QAAQ,EACR,WAAW,EACX,WAAW,EACX,GAAG,GAAG,IAAI,GACkB;IAC5B,GAAG,CACD,SAAS,EACT,yDAAyD,QAAQ,CAAC,MAAM,YAAY,CACrF,CAAC;IAEF,OAAO,MAAM,aAAa,CAAI,CAAC,GAAG,QAAQ,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;AACzE,CAAC"}

package/dist/services/log.d.ts

@@ -1,5 +0,0 @@
-declare const _default: import("knifecycle").ServiceInitializer<import("knifecycle").Dependencies<any>, {
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-}>;
-export default _default;

package/dist/services/log.js

@@ -1,4 +0,0 @@
-import { service, location } from 'knifecycle';
-import { log } from 'node:console';
-export default location(service(async () => log, 'log'), import.meta.url);
-//# sourceMappingURL=log.js.map

package/dist/services/log.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/services/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,eAAe,QAAQ,CACrB,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAC/B,MAAM,CAAC,IAAI,CAAC,GAAG,CAChB,CAAC"}

package/dist/wrappers/wrapHandlerForGoogleHTTPFunction.d.ts

@@ -1,23 +0,0 @@
-import { DEFAULT_PARSERS, DEFAULT_STRINGIFYERS, DEFAULT_DECODERS, DEFAULT_ENCODERS } from '@whook/http-router';
-import stream from 'stream';
-import type { WhookQueryStringParser } from '@whook/http-router';
-import type { WhookResponse, WhookHandler, WhookObfuscatorService, WhookOperation, WhookWrapper, WhookErrorHandler } from '@whook/whook';
-import type { LogService } from 'common-services';
-import type { OpenAPIV3_1 } from 'openapi-types';
-import type { AppEnvVars } from 'application-services';
-export type WhookWrapHTTPFunctionDependencies = {
-    OPERATION_API: OpenAPIV3_1.Document;
-    ENV: AppEnvVars;
-    DEBUG_NODE_ENVS?: string[];
-    DECODERS?: typeof DEFAULT_DECODERS;
-    ENCODERS?: typeof DEFAULT_ENCODERS;
-    PARSERS?: typeof DEFAULT_PARSERS;
-    STRINGIFYERS?: typeof DEFAULT_STRINGIFYERS;
-    QUERY_PARSER: WhookQueryStringParser;
-    BUFFER_LIMIT?: string;
-    obfuscator: WhookObfuscatorService;
-    errorHandler: WhookErrorHandler;
-    log?: LogService;
-};
-declare const _default: import("knifecycle").ServiceInitializer<WhookWrapHTTPFunctionDependencies, WhookWrapper<WhookHandler<import("knifecycle").Parameters, WhookResponse<number, void | import("@whook/http-transaction").WhookHeaders, void | stream.Readable | import("type-fest").JsonValue>, WhookOperation<Record<string, unknown>>>>>;
-export default _default;