@herrromich/az-functions 1.0.0

package/src/http-controller/http-controller-metadata.reader.ts

@@ -0,0 +1,62 @@
+import { injectable } from 'inversify';
+import {
+  FUNCTION_HANDLER_METADATA,
+  TriggerHandlerClass,
+  TriggerHandlerMetadataError,
+  TriggerHandlerMetadataReader,
+} from 'shared';
+import { ControllerOperationMetadata, HTTP_CONTROLLER_TYPE, HttpControllerMetadata } from './decorators';
+
+@injectable()
+export class HttpControllerMetadataReader {
+  constructor(private readonly metadataReader: TriggerHandlerMetadataReader) {}
+
+  getHandlerClassMetadata(triggerHandlerClass: TriggerHandlerClass): HttpControllerMetadata {
+    const handlerClassMetadata = this.metadataReader.getHandlerClassMetadata(triggerHandlerClass);
+    if (handlerClassMetadata.type !== HTTP_CONTROLLER_TYPE) {
+      throw new TriggerHandlerMetadataError(
+        `Invalid type for handler class ${triggerHandlerClass.name}. Expected '${HTTP_CONTROLLER_TYPE}', but got '${handlerClassMetadata.type}'.`,
+        {
+          cause: {
+            triggerHandlerClass: triggerHandlerClass.name,
+            expectedType: HTTP_CONTROLLER_TYPE,
+            actualType: handlerClassMetadata.type,
+            reason: 'invalid type',
+          },
+        },
+      );
+    }
+    return handlerClassMetadata as HttpControllerMetadata;
+  }
+
+  getOperationMetadata(handlerClass: TriggerHandlerClass, operation: string): ControllerOperationMetadata {
+    const argsMetadata = Reflect.getOwnMetadata(FUNCTION_HANDLER_METADATA, handlerClass.prototype, operation);
+    if (argsMetadata === undefined) {
+      throw new TriggerHandlerMetadataError(
+        `No metadata found for operation ${operation} in handler class ${handlerClass.name}.`,
+        {
+          cause: {
+            handlerClass: handlerClass.name,
+            operation,
+            reason: 'no metadata',
+          },
+        },
+      );
+    }
+    if (argsMetadata.type !== HTTP_CONTROLLER_TYPE) {
+      throw new TriggerHandlerMetadataError(
+        `Invalid type for operation ${operation} in handler class ${handlerClass.name}. Expected '${HTTP_CONTROLLER_TYPE}', but got '${argsMetadata.type}'.`,
+        {
+          cause: {
+            handlerClass: handlerClass.name,
+            operation,
+            expectedType: HTTP_CONTROLLER_TYPE,
+            actualType: argsMetadata.type,
+            reason: 'invalid type',
+          },
+        },
+      );
+    }
+    return argsMetadata as ControllerOperationMetadata;
+  }
+}

package/src/http-controller/http-controller-registration.service.ts

@@ -0,0 +1,52 @@
+import { app, HttpMethod } from '@azure/functions';
+import { Container, inject, injectable } from 'inversify';
+import { PLATFORM_CONTAINER, TriggerHandlerClass, TriggerHandlerRegistrationService } from 'shared';
+import { OperationMethod } from './decorators';
+import { HttpHandlerFactory } from './http-handler.factory';
+import { HttpOperationRegistration, HttpOperationsRegistrationService } from './http-operations-registration.service';
+
+const httpMethodMap: Record<OperationMethod, HttpMethod> = {
+  get: 'GET',
+  head: 'HEAD',
+  delete: 'DELETE',
+  post: 'POST',
+  put: 'PUT',
+  patch: 'PATCH',
+};
+
+@injectable()
+export class HttpControllerRegistrationService implements TriggerHandlerRegistrationService {
+  constructor(
+    @inject(PLATFORM_CONTAINER) private readonly platformContainer: Container,
+    private readonly operationsRegistrationService: HttpOperationsRegistrationService,
+    private readonly handlerFactory: HttpHandlerFactory,
+  ) {}
+
+  register(controllerClass: TriggerHandlerClass) {
+    this.platformContainer.bind(controllerClass).toSelf();
+    const controller = this.platformContainer.get(controllerClass);
+    this.operationsRegistrationService.registerOperations(controllerClass, registrationData => {
+      this.registerTrigger(controller, registrationData);
+    });
+  }
+
+  private registerTrigger(controller: object, registrationData: HttpOperationRegistration) {
+    const { operationId, controllerMethod, operationMetadata } = registrationData;
+
+    const controllerPrototype = controller.constructor.prototype;
+    const route = registrationData.application.context + '/' + registrationData.route;
+    const method = async (...args: unknown[]): Promise<unknown> => {
+      return await controllerPrototype[controllerMethod].call(controller, ...args);
+    };
+    const handler = this.handlerFactory.createHandler(registrationData, method);
+    const { method: httpMethod, authLevel, extraInputs, extraOutputs } = operationMetadata;
+    app.http(operationId, {
+      route,
+      methods: [httpMethodMap[httpMethod]],
+      handler,
+      authLevel,
+      extraInputs,
+      extraOutputs,
+    });
+  }
+}

package/src/http-controller/http-controller.model.ts

@@ -0,0 +1,233 @@
+import { Cookie, HttpResponseInit } from '@azure/functions';
+import { getReasonPhrase, StatusCodes } from 'http-status-codes';
+import * as _ from 'lodash';
+import * as path from 'node:path';
+import type { OpenAPIObject } from 'openapi3-ts/oas30';
+import { AzFunctionsRuntimeError } from 'shared';
+import { z } from 'zod';
+
+export type OpenAPIObjectConfig = Omit<OpenAPIObject, 'paths' | 'webhooks'>;
+
+/**
+ * Represents a REST application with a name, context, and OpenAPI configuration.
+ *
+ * @property name The name of the REST application.
+ * @property context The context path for the REST application.
+ * @property openApiConfig The OpenAPI configuration for the REST application.
+ */
+export interface RestApplication {
+  name: string;
+  context: string;
+  openApiConfig: OpenAPIObjectConfig;
+}
+
+/**
+ * Represents the options for an HTTP trigger error, including the response and additional details.
+ *
+ * @property response The HTTP response initialization options, including the status.
+ * @property details Additional details about the error.
+ */
+export interface HttpTriggerErrorOptions<Status extends number = number> extends ErrorOptions {
+  response?: HttpResponseInit & { status?: Status };
+  details?: Record<string, unknown>;
+}
+
+export abstract class BaseHttpTriggerError<Status extends number = number> extends AzFunctionsRuntimeError {
+  private readonly _response: HttpResponseInit;
+  protected abstract getStatus(): Status;
+  get status(): number {
+    return this.getStatus();
+  }
+
+  constructor(message?: string, options?: HttpTriggerErrorOptions<Status>) {
+    super(message, { cause: options?.cause, details: options?.details });
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    const response = options?.response;
+    const status = response?.status ?? this.getStatus();
+    this.message = message ?? getReasonPhrase(status);
+    this._response = {
+      ...response,
+      status,
+      ...(response?.body === undefined && response?.jsonBody === undefined ? { body: this.message } : {}),
+    };
+    this._details = {
+      httpStatus: this.getStatus(),
+      reasonPhrase: getReasonPhrase(this.getStatus()),
+      ...options?.details,
+    };
+  }
+
+  get response(): HttpResponseInit {
+    return this._response;
+  }
+}
+
+/**
+ * Represents a common HTTP trigger error with a default status of 500 (Internal Server Error).
+ *
+ * It can optionally include a response object with a specific status and body, and additional details about the error.
+ *
+ * @example
+ * ```ts
+ * throw new CommonHttpTriggerError('Resource was not found', {
+ *   response: {
+ *     status: 404,
+ *     jsonBody: {
+ *       error: 'Resource not found'
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export class CommonHttpTriggerError extends BaseHttpTriggerError {
+  override getStatus(): number {
+    return this.response?.status ?? StatusCodes.INTERNAL_SERVER_ERROR;
+  }
+}
+
+/**
+ * Represents a Bad Request (400) HTTP trigger error.
+ */
+export class BadRequestError extends BaseHttpTriggerError<StatusCodes.BAD_REQUEST> {
+  override getStatus(): StatusCodes.BAD_REQUEST {
+    return StatusCodes.BAD_REQUEST;
+  }
+}
+
+/**
+ * Represents an Unauthorized (401) HTTP trigger error.
+ */
+export class UnauthorizedError extends BaseHttpTriggerError<StatusCodes.UNAUTHORIZED> {
+  override getStatus(): StatusCodes.UNAUTHORIZED {
+    return StatusCodes.UNAUTHORIZED;
+  }
+}
+
+/**
+ * Represents a Forbidden (403) HTTP trigger error.
+ */
+export class ForbiddenError extends BaseHttpTriggerError<StatusCodes.FORBIDDEN> {
+  override getStatus(): StatusCodes.FORBIDDEN {
+    return StatusCodes.FORBIDDEN;
+  }
+}
+
+/**
+ * Represents a Not Found (404) HTTP trigger error.
+ */
+export class NotFoundError extends BaseHttpTriggerError<StatusCodes.NOT_FOUND> {
+  override getStatus(): StatusCodes.NOT_FOUND {
+    return StatusCodes.NOT_FOUND;
+  }
+}
+
+/**
+ * Represents an Internal Server Error (500) HTTP trigger error.
+ */
+export class InternalServerError extends BaseHttpTriggerError<StatusCodes.INTERNAL_SERVER_ERROR> {
+  override getStatus(): StatusCodes.INTERNAL_SERVER_ERROR {
+    return StatusCodes.INTERNAL_SERVER_ERROR;
+  }
+}
+
+/**
+ * Default Zod schema for validating string values.
+ */
+export const StringSchema = z.string();
+
+/**
+ * Default Zod schema for validating optional string values.
+ */
+export const OptionalStringSchema = StringSchema.optional();
+
+/**
+ * Default Zod schema for validating number values.
+ */
+export const NumberSchema = z.number();
+
+/**
+ * Abstract builder class for constructing HTTP direct responses.
+ *
+ * @template T The type of the JSON body to be included in the response.
+ */
+export abstract class HttpDirectResponseBuilder<T = unknown> {
+  abstract status(status: number): HttpDirectResponseBuilder<T>;
+  abstract header(name: string, value: string): HttpDirectResponseBuilder<T>;
+  abstract addCookie(value: Cookie): HttpDirectResponseBuilder<T>;
+  abstract jsonBody(body: T): HttpDirectResponseBuilder<T>;
+  abstract build(): HttpResponseInit;
+
+  /**
+   * Creates a new instance of the HTTP direct response builder.
+   *
+   * @template T The type of the JSON body to be included in the response.
+   * @returns A new instance of HttpDirectResponseBuilder.
+   */
+  static builder<T>(): HttpDirectResponseBuilder<T> {
+    return new HttpDirectResponseBuilderImpl<T>();
+  }
+}
+
+export class HttpDirectResponseBuilderImpl<T = unknown> extends HttpDirectResponseBuilder<T> {
+  private _status: number = StatusCodes.OK;
+  private _headers?: Record<string, string>;
+  private _cookies?: Cookie[];
+  private _jsonBody?: T;
+
+  status(status: number): HttpDirectResponseBuilder<T> {
+    this._status = status;
+    return this;
+  }
+
+  header(name: string, value: string): HttpDirectResponseBuilder<T> {
+    if (!this._headers) {
+      this._headers = {};
+    }
+    this._headers[name] = value;
+    return this;
+  }
+
+  addCookie(value: Cookie): HttpDirectResponseBuilder<T> {
+    if (!this._cookies) {
+      this._cookies = [];
+    }
+    this._cookies.push(value);
+    return this;
+  }
+
+  jsonBody(body: T): HttpDirectResponseBuilder<T> {
+    this._jsonBody = body;
+    return this;
+  }
+
+  build(): HttpResponseInit {
+    return {
+      status: this._status,
+      headers: _.cloneDeep(this._headers),
+      cookies: _.cloneDeep(this._cookies),
+      jsonBody: _.cloneDeep(this._jsonBody),
+    };
+  }
+}
+
+// eslint-disable-next-line sonarjs/slow-regex
+const CLEANUP_REGEX = /^\/+|\/+$/g;
+export function joinPosix(...segments: string[]): string {
+  return path.posix.join(...segments.map(s => s.replace(CLEANUP_REGEX, '')));
+}
+
+const HttpResponseInitSchema = z
+  .object({
+    status: z.number().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    cookies: z.array(z.any()).optional(),
+    body: z.any().optional(),
+    jsonBody: z.any().optional(),
+    enableContentNegotiation: z.boolean().optional(),
+  })
+  .refine(obj => Object.values(obj).some(v => v !== undefined), { message: 'At least one property must be provided' });
+
+export function isHttpResponseInit(obj: unknown): obj is HttpResponseInit {
+  return HttpResponseInitSchema.safeParse(obj).success;
+}

package/src/http-controller/http-handler-support.factory.ts

@@ -0,0 +1,132 @@
+import { HttpRequest, InvocationContext } from '@azure/functions';
+import { HttpResponseInit } from '@azure/functions/types/http';
+import { injectable } from 'inversify';
+import * as _ from 'lodash';
+import { AuthContext } from 'security';
+import { AzFunctionsSystemError } from 'shared';
+import { Promisable } from 'type-fest';
+import { ControllerOperationArgMetadata, DirectResponseObject } from './decorators';
+import { InternalServerError, isHttpResponseInit, OptionalStringSchema } from './http-controller.model';
+import { HttpRequestArgProviderFactory } from './http-request-arg-provider.factory';
+import { HttpResponseProcessorFactory, ResponsePartialProcessor } from './http-response-processor.factory';
+
+export class HttpTriggerDefinitionError extends AzFunctionsSystemError {}
+
+export interface HttpRequestProcessorInput {
+  request: HttpRequest;
+  invocationContext: InvocationContext;
+  authContext: AuthContext;
+}
+export type HttpRequestArgsProvider = (input: HttpRequestProcessorInput) => Promise<unknown[]>;
+export type HttpRequestArgProvider = (input: HttpRequestProcessorInput) => Promisable<unknown>;
+
+export type HttpResponseProcessor = (response: unknown) => Promise<HttpResponseInit>;
+
+@injectable()
+export class HttpHandlerSupportFactory {
+  constructor(
+    private readonly httpRequestArgProviderFactory: HttpRequestArgProviderFactory,
+    private readonly httpResponseProcessorFactory: HttpResponseProcessorFactory,
+  ) {}
+
+  createRequestArgsProvider(operationArgs: ControllerOperationArgMetadata[]): HttpRequestArgsProvider {
+    this.validateArgs(operationArgs);
+    const argProviders: HttpRequestArgProvider[] = [];
+    for (const arg of operationArgs) {
+      switch (arg.type) {
+        case 'path': {
+          argProviders.push(this.httpRequestArgProviderFactory.createPathParamArgProvider(arg));
+          break;
+        }
+        case 'header': {
+          const headerItemName = arg.name;
+          const headerSchema = arg.schema ?? OptionalStringSchema;
+          argProviders.push(this.httpRequestArgProviderFactory.createHeaderProvider(headerItemName, headerSchema));
+          break;
+        }
+        case 'query': {
+          argProviders.push(this.httpRequestArgProviderFactory.createQueryItemArgProvider(arg));
+          break;
+        }
+        case 'request':
+          argProviders.push(({ request }) => request);
+          break;
+        case 'invocationContext':
+          argProviders.push(({ invocationContext }) => invocationContext);
+          break;
+        case 'authContext':
+          argProviders.push(({ authContext }) => authContext);
+          break;
+        case 'body':
+          argProviders.push(this.httpRequestArgProviderFactory.createBodyArgProvider(arg.schema));
+          break;
+        case 'undefined':
+          argProviders.push(() => undefined);
+          break;
+      }
+    }
+    return this.httpRequestArgProviderFactory.createArgsProvider(argProviders);
+  }
+
+  private validateArgs(operationArgs: ControllerOperationArgMetadata[]) {
+    let bodyParamCount = 0;
+    let requestParamCount = 0;
+    for (const arg of operationArgs) {
+      if (arg.type === 'body') {
+        bodyParamCount++;
+      }
+      if (arg.type === 'request') {
+        requestParamCount++;
+      }
+    }
+    if (bodyParamCount > 1) {
+      throw new HttpTriggerDefinitionError('Multiple body parameters are not allowed in a single operation.');
+    }
+    if (requestParamCount > 1) {
+      throw new HttpTriggerDefinitionError('Multiple request parameters are not allowed in a single operation.');
+    }
+    if (bodyParamCount > 0 && requestParamCount > 0) {
+      throw new HttpTriggerDefinitionError('Cannot have both body and request parameters in a single operation.');
+    }
+  }
+
+  createResponseProcessor(directResponse?: DirectResponseObject): HttpResponseProcessor {
+    const partialProcessors: ResponsePartialProcessor[] = [
+      this.httpResponseProcessorFactory.provideJsonBodyProcessor(directResponse),
+      this.httpResponseProcessorFactory.provideStatusProcessor(directResponse),
+      this.httpResponseProcessorFactory.provideHeaderProcessor(directResponse),
+    ].filter((processor): processor is ResponsePartialProcessor => processor !== undefined);
+
+    return async (value: unknown): Promise<HttpResponseInit> => {
+      let input: HttpResponseInit;
+      if (isHttpResponseInit(value)) {
+        if (directResponse === undefined) {
+          return value;
+        } else {
+          input = value;
+        }
+      } else {
+        if (directResponse === undefined) {
+          throw new InternalServerError(
+            'Controller method should return HttpResponseInit when directResponse is not defined',
+          );
+        }
+        input = {
+          jsonBody: value,
+        };
+      }
+      const processionResults = await Promise.allSettled(partialProcessors.map(processor => processor(input)));
+
+      const [fulfilled, rejected] = _.partition(processionResults, result => result.status === 'fulfilled');
+      if (rejected.length > 0) {
+        const errors = rejected.map(reason => reason.reason);
+        throw new InternalServerError('Failed processing response', {
+          details: { errors },
+        });
+      }
+      return fulfilled.reduce((acc, result) => {
+        return { ...acc, ...result.value };
+      }, input);
+    };
+  }
+}

package/src/http-controller/http-handler.factory.ts

@@ -0,0 +1,107 @@
+import { HttpRequest, InvocationContext } from '@azure/functions';
+import { HttpResponseInit } from '@azure/functions/types/http';
+import { PLATFORM_CONTEXT_MANAGER, PLATFORM_CONTEXT_PROVIDER } from 'context';
+import { getReasonPhrase, StatusCodes } from 'http-status-codes';
+import { Container, inject, injectable } from 'inversify';
+import { adjustContextLoggerMetadata, LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { AUTHENTICATION_CONTEXT_KEY } from 'security';
+import { PLATFORM_CONTAINER } from 'shared';
+import { BaseHttpTriggerError } from './http-controller.model';
+import { HttpHandlerSupportFactory } from './http-handler-support.factory';
+import { HttpOperationRegistration } from './http-operations-registration.service';
+import { AuthenticatorProvider } from './security/authenticator.provider';
+
+export type RequestHandler = (request: HttpRequest, context: InvocationContext) => Promise<HttpResponseInit>;
+
+@injectable()
+export class HttpHandlerFactory {
+  private readonly logger;
+
+  constructor(
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+    @inject(PLATFORM_CONTAINER) private readonly platformContainer: Container,
+    private readonly supportService: HttpHandlerSupportFactory,
+    private readonly authenticationProvider: AuthenticatorProvider,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  createHandler(
+    operationRegistration: HttpOperationRegistration,
+    method: (...args: unknown[]) => Promise<unknown>,
+  ): RequestHandler {
+    const { operationId, operationMetadata } = operationRegistration;
+    const argsProvider = this.supportService.createRequestArgsProvider(operationMetadata.args);
+    const responseProvider = this.supportService.createResponseProcessor(operationMetadata.directResponse);
+    const contextManager = this.platformContainer.get(PLATFORM_CONTEXT_MANAGER);
+    const contextProvider = this.platformContainer.get(PLATFORM_CONTEXT_PROVIDER);
+    const authenticator = this.authenticationProvider.provideAuthenticator(operationRegistration);
+    return async (request: HttpRequest, invocationContext: InvocationContext): Promise<HttpResponseInit> => {
+      return await contextManager.runWith(
+        contextProvider.providePlatformContext(invocationContext),
+        async (): Promise<HttpResponseInit> => {
+          adjustContextLoggerMetadata(contextManager, {
+            error: {
+              operationRegistration,
+            },
+            warn: {
+              operationId,
+            },
+            silly: {
+              operationRegistration,
+            },
+          });
+          this.logger.http(`Processing HTTP request for operation ${operationId} started`, {
+            request,
+          });
+          this.logger.silly(`Processing HTTP request for operation ${operationId} started`, {
+            request,
+          });
+          let response: HttpResponseInit;
+          try {
+            const authContext = await authenticator(request);
+            contextManager.active()?.setValue(AUTHENTICATION_CONTEXT_KEY, authContext);
+            const args = await argsProvider({ request, invocationContext, authContext });
+            this.logger.debug(`Calling controller method for operation ${operationId} with arguments`, {
+              args,
+            });
+            const result = await method(...args);
+            this.logger.debug(`Controller method for operation ${operationId} called`);
+            response = await responseProvider(result);
+            this.logger.http(`HTTP request processed for operation ${operationId}`, {
+              response,
+            });
+            this.logger.silly(`HTTP request for operation ${operationId} processed`, {
+              response,
+            });
+          } catch (e) {
+            if (e instanceof BaseHttpTriggerError) {
+              this.logger.warn(e.message, {
+                operationId,
+                ...e.details,
+              });
+              response = e.response;
+            } else {
+              this.logger.error(`Failed to process HTTP request for operation ${operationId}`, {
+                httpStatus: StatusCodes.INTERNAL_SERVER_ERROR,
+                reasonPhrase: getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
+                error: e,
+              });
+              response = {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                body: 'Internal server error.',
+              };
+            }
+            this.logger.http(`Failed to process HTTP request for operation ${operationId}`, {
+              response,
+            });
+            this.logger.silly(`Failed to process HTTP request for operation ${operationId}`, {
+              response,
+            });
+          }
+          return response;
+        },
+      );
+    };
+  }
+}

package/src/http-controller/http-operations-registration.service.ts

@@ -0,0 +1,81 @@
+import { inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { TriggerHandlerClass, TriggerHandlerMetadataError } from 'shared';
+import { ControllerOperationMetadata, HttpControllerMetadata, HttpControllerMetadataReader } from './decorators';
+import { joinPosix, RestApplication } from './http-controller.model';
+import { OpenApiDefinitionService } from './open-api-definition.service';
+
+export interface HttpOperationRegistration {
+  operationId: string;
+  controllerMethod: string;
+  controllerMetadata: HttpControllerMetadata;
+  operationMetadata: ControllerOperationMetadata;
+  application: RestApplication;
+  route: string;
+}
+
+export type RegisterCallback = (operationRegistration: HttpOperationRegistration) => void;
+
+@injectable()
+export class HttpOperationsRegistrationService {
+  private readonly logger;
+
+  constructor(
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+    private readonly metadataReader: HttpControllerMetadataReader,
+    private readonly openApiDefinitionService: OpenApiDefinitionService,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  registerOperations(controllerClass: TriggerHandlerClass, registerCallback: RegisterCallback): void {
+    const controllerMetadata = this.metadataReader.getHandlerClassMetadata(controllerClass);
+    const prototype = controllerClass.prototype;
+    const application = this.openApiDefinitionService.getApplication(controllerMetadata.application);
+    this.logger.debug('Registering operations for controller started', {
+      class: controllerClass.name,
+      metadata: controllerMetadata,
+    });
+    let operationsCount = 0;
+    for (const controllerMethod of Object.getOwnPropertyNames(prototype)) {
+      const operationMetadata = this.getOperationMetadata(controllerClass, controllerMethod);
+      if (operationMetadata === undefined) {
+        continue;
+      }
+      const route = joinPosix(controllerMetadata.path, operationMetadata.path ?? '.');
+      const operationId = operationMetadata.operationId ?? controllerMethod;
+      const operationRegistration: HttpOperationRegistration = {
+        operationId,
+        controllerMethod,
+        controllerMetadata: controllerMetadata,
+        operationMetadata,
+        application,
+        route,
+      };
+      registerCallback(operationRegistration);
+      operationsCount++;
+      this.logger.debug(
+        `Operation ${operationId} for ${route} in controller class ${controllerClass.name} registered`,
+        {
+          operationRegistration,
+        },
+      );
+    }
+    this.logger.verbose(`${operationsCount} operation(s) for controller ${controllerClass.name} registered`);
+  }
+
+  private getOperationMetadata(
+    controllerClass: TriggerHandlerClass,
+    controllerMethod: string,
+  ): ControllerOperationMetadata | undefined {
+    try {
+      return this.metadataReader.getOperationMetadata(controllerClass, controllerMethod);
+    } catch (error) {
+      // if Azure Function class is not HTTP Controller
+      if (error instanceof TriggerHandlerMetadataError) {
+        return undefined;
+      }
+      throw error;
+    }
+  }
+}