@herrromich/az-functions 1.0.0

package/src/http-controller/http-request-arg-provider.factory.ts

@@ -0,0 +1,165 @@
+import { injectable } from 'inversify';
+import * as _ from 'lodash';
+import { HandlerArgsParseError, parseWithZod, ZodParserError } from 'shared';
+import { z, ZodArray, ZodPipe, ZodType } from 'zod';
+import { ControllerOperationPathArgMetadata, ControllerOperationQueryArgMetadata, QueryItemType } from './decorators';
+import { BadRequestError, OptionalStringSchema, StringSchema } from './http-controller.model';
+import { HttpRequestArgProvider, HttpRequestArgsProvider } from './http-handler-support.factory';
+
+@injectable()
+export class HttpRequestArgProviderFactory {
+  createBodyArgProvider<T>(bodySchema: ZodType<T>): HttpRequestArgProvider {
+    return async ({ request }): Promise<T> => {
+      try {
+        const data = await request.json();
+        return parseWithZod(bodySchema, data);
+      } catch (e) {
+        if (e instanceof ZodParserError) {
+          throw new HandlerArgsParseError('Failed parsing request body', {
+            cause: e,
+          });
+        } else {
+          throw e;
+        }
+      }
+    };
+  }
+
+  createPathParamArgProvider(arg: ControllerOperationPathArgMetadata): HttpRequestArgProvider {
+    const paramSchema = arg.schema ?? StringSchema;
+    const coercePathParamSchema = this.getCoercedSchema(paramSchema);
+    const pathParamName = arg.name;
+    return ({ request }): string | number => {
+      const pathParam = request.params[pathParamName];
+      try {
+        return parseWithZod(coercePathParamSchema, pathParam);
+      } catch (e) {
+        throw new HandlerArgsParseError(`Failed parsing path parameter ${pathParamName}`, {
+          cause: e,
+          details: {
+            pathParam: {
+              name: pathParamName,
+              value: pathParam,
+            },
+          },
+        });
+      }
+    };
+  }
+
+  createHeaderProvider(headerItemName: string, headerSchema: ZodType<string | undefined>): HttpRequestArgProvider {
+    return ({ request }): string | undefined => {
+      const headerElement = request.headers.get(headerItemName) ?? undefined;
+      try {
+        return parseWithZod(headerSchema, headerElement);
+      } catch (e) {
+        throw new HandlerArgsParseError(`Failed parsing header parameter ${headerItemName}`, {
+          cause: e,
+          details: {
+            header: {
+              name: headerItemName,
+              value: headerElement,
+            },
+          },
+        });
+      }
+    };
+  }
+
+  createQueryItemArgProvider(arg: ControllerOperationQueryArgMetadata): HttpRequestArgProvider {
+    const querySchema = arg.schema ?? OptionalStringSchema;
+    const isArray = querySchema instanceof ZodArray;
+    const coercedQuerySchema = this.getCoercedSchema(querySchema);
+    const queryItemName = arg.name;
+    return ({ request }): QueryItemType => {
+      /* There is a Bug in request.query
+         new URL(request.url).searchParams will be used instead for query parameters,
+       */
+      const queryItems = new URL(request.url).searchParams;
+      let queryItemValue: unknown;
+      if (isArray) {
+        queryItemValue = queryItems.getAll(queryItemName);
+      } else {
+        queryItemValue = queryItems.get(queryItemName) ?? undefined;
+      }
+      try {
+        return parseWithZod(coercedQuerySchema, queryItemValue);
+      } catch (e) {
+        throw new HandlerArgsParseError(`Failed parsing query parameter ${queryItemName}`, {
+          cause: e,
+          details: {
+            query: {
+              name: queryItemName,
+              value: queryItemValue,
+            },
+          },
+        });
+      }
+    };
+  }
+
+  private getCoercedSchema<T extends ZodType>(schema: T): ZodPipe<ZodType, T> {
+    let isArray: boolean;
+    let singleSchema: ZodType;
+    if (schema instanceof ZodArray) {
+      singleSchema = schema.unwrap() as ZodType;
+      isArray = true;
+    } else {
+      isArray = false;
+      singleSchema = schema;
+    }
+    let coercedSchema = this.getCoercedSingleSchema(singleSchema);
+    if (isArray) {
+      coercedSchema = coercedSchema.array();
+    }
+    return coercedSchema.pipe(schema);
+  }
+
+  private getCoercedSingleSchema(singleType: ZodType): ZodType {
+    return z
+      .string()
+      .optional()
+      .transform(val => {
+        const singleTypeName = singleType.type;
+        if (singleTypeName === 'boolean') {
+          if (val === 'true') {
+            return true;
+          } else if (val === 'false') {
+            return false;
+          } else {
+            return val;
+          }
+        } else if (singleTypeName === 'number') {
+          const numVal = Number(val).valueOf();
+          return Number.isNaN(numVal) ? val : numVal;
+        } else {
+          return val;
+        }
+      });
+  }
+
+  createArgsProvider(argProviders: HttpRequestArgProvider[]): HttpRequestArgsProvider {
+    return async (requestInput): Promise<unknown[]> => {
+      const parsingResults = await Promise.allSettled(
+        argProviders.map(
+          argProvider =>
+            new Promise((resolve, reject) => {
+              try {
+                resolve(argProvider(requestInput));
+              } catch (e) {
+                reject(e);
+              }
+            }),
+        ),
+      );
+      const [fulfilled, rejected] = _.partition(parsingResults, result => result.status === 'fulfilled');
+      if (rejected.length > 0) {
+        const errors = rejected.map(({ reason }) => reason);
+        throw new BadRequestError('Failed parsing request arguments', {
+          details: { errors: errors },
+        });
+      }
+      return fulfilled.map(({ value }) => value);
+    };
+  }
+}

package/src/http-controller/http-response-processor.factory.ts

@@ -0,0 +1,77 @@
+import { HttpHeadersInit } from '@azure/functions';
+import { HttpResponseInit } from '@azure/functions/types/http';
+import { StatusCodes } from 'http-status-codes';
+import { injectable } from 'inversify';
+import { parseWithZod } from 'shared';
+import { ZodType } from 'zod';
+import { DirectResponseObject } from './decorators';
+import { InternalServerError } from './http-controller.model';
+
+export type ResponsePartialProcessor = (input: HttpResponseInit) => Promise<HttpResponseInit>;
+
+@injectable()
+export class HttpResponseProcessorFactory {
+  provideStatusProcessor(directResponse?: DirectResponseObject): ResponsePartialProcessor {
+    const directStatus = directResponse?.status ?? StatusCodes.OK;
+    return async input => {
+      if (input.status === undefined) {
+        return { status: directStatus };
+      } else if (input.status !== directStatus) {
+        throw new InternalServerError(
+          `Response status code ${input.status} does not match direct response status code ${directStatus}.`,
+        );
+      } else {
+        return input;
+      }
+    };
+  }
+
+  provideJsonBodyProcessor(directResponse?: DirectResponseObject): ResponsePartialProcessor | undefined {
+    const contentSchema = directResponse?.jsonContent?.schema;
+    if (contentSchema instanceof ZodType) {
+      return async input => {
+        return {
+          jsonBody: this.parseJsonBody(contentSchema, input.jsonBody),
+        };
+      };
+    }
+  }
+
+  private parseJsonBody(schema: ZodType<unknown>, data: unknown): unknown {
+    try {
+      return parseWithZod(schema, data);
+    } catch (e) {
+      throw new InternalServerError('Failed to parse response body', { cause: e, details: { responseBody: data } });
+    }
+  }
+
+  provideHeaderProcessor(directResponse?: DirectResponseObject): ResponsePartialProcessor | undefined {
+    const responseHeader = directResponse?.headers;
+    if (responseHeader instanceof ZodType) {
+      return async input => {
+        const parsedHeaders = this.parseDirectResponseHeaders(responseHeader, input.headers);
+        return {
+          headers: parsedHeaders,
+        };
+      };
+    }
+  }
+
+  private parseDirectResponseHeaders(
+    schema: ZodType<Record<string, string>>,
+    headers?: HttpHeadersInit,
+  ): Record<string, string> {
+    const headersRecord: Record<string, string> = {};
+    new Headers(headers).forEach((value, key) => {
+      headersRecord[key] = value;
+    });
+    try {
+      return parseWithZod(schema, headersRecord);
+    } catch (e) {
+      throw new InternalServerError('Response headers do not match direct response headers schema', {
+        cause: e,
+        details: { headers: headersRecord },
+      });
+    }
+  }
+}

package/src/http-controller/index.ts

@@ -0,0 +1,47 @@
+import { ContainerModule } from 'inversify';
+import { TRIGGER_HANDLER_REGISTRATION_SERVICE } from 'shared';
+import { HTTP_CONTROLLER_TYPE, HttpControllerMetadataReader } from './decorators';
+import { HttpControllerRegistrationService } from './http-controller-registration.service';
+import { HttpHandlerSupportFactory } from './http-handler-support.factory';
+import { HttpHandlerFactory } from './http-handler.factory';
+import { HttpOperationsRegistrationService } from './http-operations-registration.service';
+import { HttpRequestArgProviderFactory } from './http-request-arg-provider.factory';
+import { HttpResponseProcessorFactory } from './http-response-processor.factory';
+import { OpenApiDefinitionService } from './open-api-definition.service';
+import { OpenApiMetadataService } from './open-api-metadata.service';
+import { OpenApiPrintService } from './open-api-print.service';
+import { OpenApiRegistrationService } from './open-api-registration.service';
+import { AuthenticatorProvider } from './security/authenticator.provider';
+import { OperationAuthenticationResolver } from './security/operation-authentication.resolver';
+import { FallbackPrincipalMergeService } from './security/principal-merge.service';
+import { StrictPrincipalMergeService } from './security/strict-principal-merge.servce';
+import { SwaggerHandlingService } from './swagger-handling.service';
+
+export * from './decorators';
+export * from './http-controller-registration.service';
+export * from './http-controller.model';
+export * from './http-handler-support.factory';
+export * from './open-api-definition.service';
+export * from './open-api-print.service';
+export * from './open-api-registration.service';
+export * from './security';
+export * from './swagger-handling.service';
+
+export const HttpControllerModule = new ContainerModule(({ bind }) => {
+  bind(HttpControllerMetadataReader).toSelf();
+  bind(HttpHandlerFactory).toSelf();
+  bind(TRIGGER_HANDLER_REGISTRATION_SERVICE).to(HttpControllerRegistrationService).whenNamed(HTTP_CONTROLLER_TYPE);
+  bind(SwaggerHandlingService).toSelf();
+  bind(HttpHandlerSupportFactory).toSelf();
+  bind(HttpRequestArgProviderFactory).toSelf();
+  bind(HttpResponseProcessorFactory).toSelf();
+  bind(OpenApiMetadataService).toSelf();
+  bind(AuthenticatorProvider).toSelf();
+  bind(OperationAuthenticationResolver).toSelf();
+  bind(OpenApiRegistrationService).toSelf();
+  bind(OpenApiDefinitionService).toSelf();
+  bind(HttpOperationsRegistrationService).toSelf();
+  bind(OpenApiPrintService).toSelf();
+  bind(FallbackPrincipalMergeService).toSelf();
+  bind(StrictPrincipalMergeService).toSelf();
+});

package/src/http-controller/open-api-definition.service.ts

@@ -0,0 +1,155 @@
+import { OpenApiGeneratorV3, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { ComponentTypeKey } from '@asteasolutions/zod-to-openapi/dist/openapi-registry';
+import { inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { ComponentsObject, OpenAPIObject } from 'openapi3-ts/oas30';
+import { AzFunctionsSystemError } from 'shared';
+import { RestApplication } from './http-controller.model';
+import { HttpOperationRegistration } from './http-operations-registration.service';
+import { OpenApiMetadataService } from './open-api-metadata.service';
+
+export interface RestOpenApiEntry {
+  application: RestApplication;
+  registry: OpenAPIRegistry;
+}
+export type RestOpenApiEntries = Record<string, RestOpenApiEntry>;
+
+export class OpenApiDefinitionError extends AzFunctionsSystemError {}
+
+const DEFAULT_APPLICATION = 'default';
+const defaultRestApplication: RestApplication = {
+  name: DEFAULT_APPLICATION,
+  context: DEFAULT_APPLICATION,
+  openApiConfig: {
+    openapi: '3.0.1',
+    info: {
+      version: '1.0.0',
+      title: 'unknown',
+    },
+  },
+};
+
+@injectable()
+export class OpenApiDefinitionService {
+  private readonly logger;
+  private readonly restOpenApiEntries: RestOpenApiEntries = {};
+
+  constructor(
+    @inject(LOGGER_FACTORY) private readonly loggerFactory: LoggerFactory,
+    private readonly openApiMetadataService: OpenApiMetadataService,
+  ) {
+    this.logger = this.loggerFactory();
+  }
+
+  addApplication(application: RestApplication) {
+    if (this.restOpenApiEntries[application.name]) {
+      throw new OpenApiDefinitionError(`OpenAPI definition for application ${application.name} already exists`);
+    }
+    const registry = new OpenAPIRegistry();
+    const components = application.openApiConfig.components ?? {};
+    for (const [componentType, component] of Object.entries(components) as [
+      ComponentTypeKey,
+      ComponentsObject[ComponentTypeKey],
+    ][]) {
+      for (const [name, componentEntry] of Object.entries(component)) {
+        registry.registerComponent(componentType, name, componentEntry);
+      }
+    }
+    this.restOpenApiEntries[application.name] = { application, registry };
+    this.logger.debug(`OpenAPI definition for application ${application.name} added`);
+  }
+
+  getApplications(): string[] {
+    return Object.keys(this.restOpenApiEntries);
+  }
+
+  getApplication(applicationName?: string): RestApplication {
+    const dataEntry = this.getApiDataEntry(applicationName);
+    return dataEntry.application;
+  }
+
+  getRegistry(applicationName?: string): OpenAPIRegistry {
+    const dataEntry = this.getApiDataEntry(applicationName);
+    return dataEntry.registry;
+  }
+
+  private getApiDataEntry(applicationName?: string): RestOpenApiEntry {
+    const dataEntry =
+      applicationName === undefined ? this.getDefaultDataEntry() : this.restOpenApiEntries[applicationName];
+    if (dataEntry === undefined) {
+      throw new OpenApiDefinitionError(`Unknown OpenAPI definition for application ${applicationName}`);
+    }
+    return dataEntry;
+  }
+
+  generateDocument(applicationName: string, apiUrl?: string): OpenAPIObject {
+    const { application, registry } = this.getApiDataEntry(applicationName);
+    let openApiConfig = application.openApiConfig;
+    if (apiUrl !== undefined) {
+      openApiConfig = {
+        ...openApiConfig,
+        servers: [
+          {
+            url: apiUrl + '/' + application.context,
+          },
+        ],
+      };
+    }
+    const openApiGenerator = new OpenApiGeneratorV3(registry.definitions);
+    return openApiGenerator.generateDocument(openApiConfig);
+  }
+
+  private getDefaultDataEntry(): RestOpenApiEntry {
+    let defaultDataEntry = this.restOpenApiEntries[DEFAULT_APPLICATION];
+    if (defaultDataEntry === undefined) {
+      defaultDataEntry = { application: defaultRestApplication, registry: new OpenAPIRegistry() };
+      this.restOpenApiEntries[DEFAULT_APPLICATION] = defaultDataEntry;
+    }
+    return defaultDataEntry;
+  }
+
+  registerOperation(operationRegistration: HttpOperationRegistration) {
+    const {
+      operationId,
+      controllerMetadata,
+      operationMetadata,
+      application: { name: applicationName },
+      route,
+    } = operationRegistration;
+    this.logger.debug('Registering OpenAPI operation', {
+      operationRegistration,
+    });
+    const tags = this.openApiMetadataService.getTags(controllerMetadata, operationMetadata);
+    const request = this.openApiMetadataService.getRequest(operationMetadata);
+    const responses = this.openApiMetadataService.getResponses(operationMetadata);
+    const openAPIRegistry = this.getRegistry(applicationName);
+    this.logger.silly('Registering OpenAPI operation', {
+      operationId,
+      applicationName,
+      route,
+      method: operationMetadata.method,
+      description: operationMetadata.description,
+      security: operationMetadata.security,
+      summary: operationMetadata.summary,
+      tags,
+      parameters: operationMetadata.parameters,
+      request,
+      responses,
+    });
+    openAPIRegistry.registerPath({
+      method: operationMetadata.method,
+      operationId,
+      description: operationMetadata.description,
+      security: operationMetadata.security,
+      summary: operationMetadata.summary,
+      path: '/' + route,
+      tags,
+      parameters: operationMetadata.parameters,
+      request,
+      responses,
+    });
+    this.logger.debug('Registered OpenAPI operation', {
+      operationRegistration,
+    });
+  }
+}

package/src/http-controller/open-api-metadata.service.ts

@@ -0,0 +1,96 @@
+import { ResponseConfig, RouteConfig, ZodRequestBody } from '@asteasolutions/zod-to-openapi';
+import { injectable } from 'inversify';
+import { z, ZodArray, ZodType } from 'zod';
+import {
+  ControllerOperationMetadata,
+  ControllerOperationQueryArgMetadata,
+  HttpControllerMetadata,
+  QueryItemType,
+} from './decorators';
+import { OptionalStringSchema, StringSchema } from './http-controller.model';
+
+type RouteConfigRequest = RouteConfig['request'];
+
+type Responses = Record<string, ResponseConfig>;
+
+@injectable()
+export class OpenApiMetadataService {
+  getTags(
+    controllerMetadata: HttpControllerMetadata,
+    operationMetadata: ControllerOperationMetadata,
+  ): string[] | undefined {
+    const tags = [...new Set([...(controllerMetadata.tags ?? []), ...(operationMetadata.tags ?? [])])];
+    return tags.length ? tags : undefined;
+  }
+
+  getRequest(operationMetadata: ControllerOperationMetadata): RouteConfigRequest {
+    const paramsShape: Record<string, ZodType> = {};
+    const headersShape: Record<string, ZodType> = {};
+    const queriesShape: Record<string, ZodType> = {};
+    let requestBody: ZodRequestBody | undefined = undefined;
+    for (const arg of operationMetadata.args) {
+      switch (arg.type) {
+        case 'path':
+          paramsShape[arg.name] = arg.schema ?? StringSchema;
+          break;
+        case 'header':
+          headersShape[arg.name] = arg.schema ?? OptionalStringSchema;
+          break;
+        case 'query':
+          queriesShape[arg.name] = OpenApiMetadataService.getQueryType(arg);
+          break;
+        case 'body':
+          requestBody = {
+            description: arg.description,
+            content: {
+              ['application/json']: {
+                example: arg.example,
+                schema: arg.schema,
+              },
+            },
+          };
+          break;
+        case 'undefined':
+        case 'request':
+        case 'authContext':
+        case 'invocationContext':
+          break;
+      }
+    }
+
+    return {
+      params: z.object(paramsShape),
+      headers: z.object(headersShape),
+      query: z.object(queriesShape),
+      body: requestBody,
+    };
+  }
+
+  getResponses(operationMetadata: ControllerOperationMetadata): Responses {
+    const responses = { ...operationMetadata.responses };
+    const directResponse = operationMetadata.directResponse;
+    if (directResponse) {
+      const customStatus = directResponse.status ?? 200;
+      responses[customStatus] = {
+        description: directResponse.description,
+        content: directResponse.jsonContent ? { ['application/json']: directResponse.jsonContent } : undefined,
+        headers: directResponse.headers,
+      };
+    }
+    return Object.getOwnPropertyNames(responses).length
+      ? responses
+      : {
+          '204': {
+            description: 'Default no jsonContent',
+          },
+        };
+  }
+
+  private static getQueryType(arg: ControllerOperationQueryArgMetadata): ZodType<QueryItemType> {
+    let querySchema = arg.schema;
+    if (querySchema instanceof ZodArray) {
+      querySchema = (querySchema as ZodType<string[] | number[]>).optional();
+    }
+    return querySchema ?? OptionalStringSchema;
+  }
+}

package/src/http-controller/open-api-print.service.ts

@@ -0,0 +1,49 @@
+import { inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import * as YAML from 'yaml';
+import { OpenApiDefinitionService } from './open-api-definition.service';
+
+@injectable()
+export class OpenApiPrintService {
+  private readonly logger;
+
+  constructor(
+    private readonly openApiDefinitionService: OpenApiDefinitionService,
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  printOpenApi(): void {
+    const applications = this.openApiDefinitionService.getApplications();
+    this.logger.info('Printing OpenAPI definitions started');
+
+    const printPath = process.env.OPEN_API_PRINT_PATH ?? path.resolve(process.cwd(), 'dist/open-api-definitions');
+    this.logger.verbose('Printing OpenAPI definitions started', {
+      applications,
+      printPath,
+    });
+    const printPathStat = fs.statSync(printPath, {
+      throwIfNoEntry: false,
+    });
+    if (printPathStat === undefined) {
+      fs.mkdirSync(printPath);
+    }
+    for (const application of applications) {
+      try {
+        this.logger.debug(`Printing OpenAPI definition for application ${application}`);
+        const definition = this.openApiDefinitionService.generateDocument(application);
+        let filePath = path.resolve(printPath, `${application}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(definition, null, 2));
+        filePath = path.resolve(printPath, `${application}.yaml`);
+        fs.writeFileSync(filePath, YAML.stringify(definition));
+        this.logger.debug(`OpenAPI definition for application ${application} printed`);
+      } catch (e) {
+        this.logger.error(`Failed to print OpenAPI definition for application ${application}`, e);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+import { inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { TriggerHandlerClass, TriggerHandlerMetadataReader } from 'shared';
+import { RestApplication } from './http-controller.model';
+import { HttpOperationsRegistrationService } from './http-operations-registration.service';
+import { OpenApiDefinitionService } from './open-api-definition.service';
+
+@injectable()
+export class OpenApiRegistrationService {
+  private readonly logger;
+
+  constructor(
+    private readonly metadataReader: TriggerHandlerMetadataReader,
+    private readonly definitionService: OpenApiDefinitionService,
+    private readonly operationRegistrationService: HttpOperationsRegistrationService,
+    @inject(LOGGER_FACTORY) private readonly loggerFactory: LoggerFactory,
+  ) {
+    this.logger = this.loggerFactory();
+  }
+
+  register(config: { triggerHandlerClasses: TriggerHandlerClass[]; restApplications?: RestApplication[] }): void {
+    const { restApplications } = config;
+    const httpTriggerHandlerClasses = config.triggerHandlerClasses.filter(handlerClass => {
+      const metadata = this.metadataReader.getHandlerClassMetadata(handlerClass);
+      return metadata.type === 'http-controller';
+    });
+    this.logger.info('Registering OpenAPI definitions for Azure Functions started', {
+      triggerHandlerClasses: httpTriggerHandlerClasses.length,
+      restApplications: restApplications?.length || 'none',
+    });
+    this.logger.debug('Registering OpenAPI definitions for Azure Functions started', {
+      triggerHandlerClasses: httpTriggerHandlerClasses.map(cls => cls.name),
+      restApplications: restApplications?.map(app => app.name) || 'none',
+    });
+    for (const application of restApplications ?? []) {
+      this.definitionService.addApplication(application);
+    }
+    for (const triggerHandlerClass of httpTriggerHandlerClasses) {
+      this.operationRegistrationService.registerOperations(triggerHandlerClass, operationRegistrationData => {
+        this.definitionService.registerOperation(operationRegistrationData);
+      });
+    }
+    this.logger.info(`${httpTriggerHandlerClasses.length} OpenAPI definition(s) registered`);
+  }
+}

package/src/http-controller/security/authentication-service.ts

@@ -0,0 +1,18 @@
+import { HttpRequest } from '@azure/functions';
+import { Principal } from 'security';
+import { serviceIdentifier } from 'shared';
+
+/**
+ * Service identifier for the AuthenticationService. This service is responsible for authenticating incoming HTTP requests and returning a Principal object representing the authenticated user.
+ * It can be used to implement custom authentication logic, such as validating JWT tokens, API keys, or other authentication mechanisms.
+ */
+export const AUTHENTICATION_SERVICE = serviceIdentifier<AuthenticationService>('AzFunctions.AuthenticationService');
+export const REST_APPLICATION_TAG_KEY = Symbol.for('AzFunctions.RestApplicationTagKey');
+
+/**
+ * Interface representing an authentication service that can authenticate incoming HTTP requests.
+ * The service should implement the `authenticate` method, which takes an HttpRequest and returns a Promise that resolves to a Principal object representing the authenticated user.
+ */
+export interface AuthenticationService {
+  authenticate(request: HttpRequest): Promise<Principal>;
+}