@herrromich/az-functions 1.0.0

package/src/event-hub-handler/event-hub-handler-registration.service.ts

@@ -0,0 +1,45 @@
+import { app } from '@azure/functions';
+import { Container, inject, injectable } from 'inversify';
+import { PLATFORM_CONTAINER, TriggerHandlerClass, TriggerHandlerRegistrationService } from 'shared';
+import { EventHubHandlerFactory } from './event-hub-handler.factory';
+import {
+  EventhubTriggerRegistration,
+  EventHubTriggersRegistrationService,
+} from './event-hub-triggers-registration.service';
+
+@injectable()
+export class EventHubHandlerRegistrationService implements TriggerHandlerRegistrationService {
+  constructor(
+    @inject(PLATFORM_CONTAINER) private readonly platformContainer: Container,
+    private readonly eventHubHandlerProvider: EventHubHandlerFactory,
+    private readonly triggersRegistrationService: EventHubTriggersRegistrationService,
+  ) {}
+
+  register(eventHubHandlerClass: TriggerHandlerClass) {
+    this.platformContainer.bind(eventHubHandlerClass).toSelf();
+    const handler = this.platformContainer.get(eventHubHandlerClass);
+
+    this.triggersRegistrationService.registerTriggers(eventHubHandlerClass, triggerRegistration =>
+      this.registerTrigger(handler, triggerRegistration),
+    );
+  }
+
+  private registerTrigger(handler: object, triggerRegistration: EventhubTriggerRegistration) {
+    const { triggerId, triggerMethod, handlerMetadata, triggerMetadata } = triggerRegistration;
+
+    const handlersPrototype = handler.constructor.prototype;
+    const method = async (...args: unknown[]): Promise<unknown> => {
+      return await handlersPrototype[triggerMethod].call(handler, ...args);
+    };
+    const eventhubHandler = this.eventHubHandlerProvider.createHandler(triggerRegistration, method);
+    app.eventHub(triggerId, {
+      connection: handlerMetadata.connection,
+      eventHubName: handlerMetadata.eventHubName,
+      consumerGroup: triggerMetadata.consumerGroup,
+      cardinality: triggerMetadata.cardinality,
+      extraInputs: triggerMetadata.extraInputs,
+      extraOutputs: triggerMetadata.extraOutputs,
+      handler: eventhubHandler,
+    });
+  }
+}

package/src/event-hub-handler/event-hub-handler.factory.ts

@@ -0,0 +1,66 @@
+import { InvocationContext } from '@azure/functions';
+import { PLATFORM_CONTEXT_MANAGER, PLATFORM_CONTEXT_PROVIDER } from 'context';
+import { Container, inject, injectable } from 'inversify';
+import { adjustContextLoggerMetadata, LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { PLATFORM_CONTAINER } from 'shared';
+import { EventHubTriggerSupportFactory } from './event-hub-trigger-support.factory';
+import { EventhubTriggerRegistration } from './event-hub-triggers-registration.service';
+
+export type EventHubTriggerHandler = (messages: unknown, invocationContext: InvocationContext) => Promise<void>;
+
+@injectable()
+export class EventHubHandlerFactory {
+  private readonly logger;
+
+  constructor(
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+    @inject(PLATFORM_CONTAINER) private readonly platformContainer: Container,
+    private readonly eventHubTriggerService: EventHubTriggerSupportFactory,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  createHandler(
+    registrationData: EventhubTriggerRegistration,
+    method: (...args: unknown[]) => Promise<unknown>,
+  ): EventHubTriggerHandler {
+    const { triggerId, triggerMetadata } = registrationData;
+    const argsProvider = this.eventHubTriggerService.buildArgProviders(
+      triggerMetadata.args,
+      triggerMetadata.cardinality,
+    );
+    const contextManager = this.platformContainer.get(PLATFORM_CONTEXT_MANAGER);
+    const contextProvider = this.platformContainer.get(PLATFORM_CONTEXT_PROVIDER);
+    return async (messages: unknown, invocationContext: InvocationContext): Promise<void> => {
+      return contextManager.runWith(contextProvider.providePlatformContext(invocationContext), async () => {
+        adjustContextLoggerMetadata(contextManager, {
+          error: {
+            registrationData,
+          },
+          warn: {
+            triggerId,
+          },
+          silly: {
+            registrationData,
+          },
+        });
+        try {
+          const args = await argsProvider(messages, invocationContext);
+          this.logger.debug('Processing Event Hub event started');
+          this.logger.silly('Processing Event Hub event started', {
+            args,
+            triggerMetadata: invocationContext.triggerMetadata,
+            messages,
+          });
+          await method(...args);
+        } catch (e) {
+          this.logger.error('Error processing Event Hub event', {
+            triggerMetadata: invocationContext.triggerMetadata,
+            messages,
+            error: e,
+          });
+        }
+      });
+    };
+  }
+}

package/src/event-hub-handler/event-hub-handler.model.ts

@@ -0,0 +1,112 @@
+import { InvocationContext } from '@azure/functions';
+import { AzFunctionsSystemError } from 'shared';
+import { z } from 'zod';
+
+export class EventHubTriggerDefinitionError extends AzFunctionsSystemError {}
+
+export interface EventHubArgProviderInput {
+  context: InvocationContext;
+  messages: unknown;
+}
+
+export type EventHubArgProvider = (input: EventHubArgProviderInput) => unknown;
+export type EventHubAsyncArgsProvider = (messages: unknown, context: InvocationContext) => Promise<unknown[]>;
+
+export const EventHubEventDataSchema = z.object({
+  partitionContext: z.object({
+    fullyQualifiedNamespace: z.string(),
+    consumerGroup: z.string(),
+    eventHubName: z.string(),
+    partitionId: z.string(),
+  }),
+  enqueuedTimeUtc: z.iso.datetime({ local: true }),
+  offset: z.int(),
+  partitionKey: z.string().optional(),
+  sequenceNumber: z.int(),
+});
+
+/**
+ * Schema representing the raw Event Hub event data.
+ * Includes metadata such as partition InvocationCtx, enqueue time, offset, partition key, and sequence number.
+ * Can be used to strongly type the raw event data in handler methods.
+ *
+ * ```ts
+ * type EventHubEventData = {
+ *  partitionContext: {
+ *   consumerGroupName: string;
+ *   eventHubPath: string;
+ *  }
+ *  enqueuedTimeUtc: string;
+ *  offset: string;
+ *  partitionKey: string;
+ *  sequenceNumber: number;
+ *  };
+ * ```
+ * properties:
+ * - `partitionContext`: Metadata about the partition, including consumer group name and Event Hub path.
+ *   - `consumerGroupName`: The name of the consumer group.
+ *   - `eventHubPath`: The path of the Event Hub.
+ * - `enqueuedTimeUtc`: The UTC time when the event was enqueued, in ISO string format.
+ * - `offset`: The offset of the event in the partition.
+ * - `partitionKey`: The partition key of the event.
+ * - `sequenceNumber`: The sequence number of the event in the partition.
+ *
+ * @example
+ * ```ts
+ * const eventData: EventHubEventData = {
+ *   partitionContext: {
+ *     consumerGroupName: 'my-consumer-group',
+ *     eventHubPath: 'my-event-hub',
+ *   },
+ *   enqueuedTimeUtc: '2023-10-01T12:00:00Z',
+ *   offset: '12345',
+ *   partitionKey: 'my-partition-key',
+ *   sequenceNumber: 67890,
+ * };
+ * ```
+ */
+export type EventHubEventData = z.infer<typeof EventHubEventDataSchema>;
+
+export type EventHubMessageBaseWrapper<PAYLOAD = unknown, PROPERTIES = undefined, SYSTEM_PROPERTIES = undefined> = {
+  payload: PAYLOAD;
+} & (PROPERTIES extends undefined ? object : { properties: PROPERTIES }) &
+  (SYSTEM_PROPERTIES extends undefined ? object : { systemProperties: SYSTEM_PROPERTIES });
+
+export type SafeWrapper<T, P> = ({ valid: true } & T) | ({ valid: false; error: unknown } & P);
+
+export type SafeEventHubMessageWrapper<
+  PAYLOAD = unknown,
+  PROPERTIES = undefined,
+  SYSTEM_PROPERTIES = undefined,
+> = SafeWrapper<
+  EventHubMessageBaseWrapper<PAYLOAD, PROPERTIES, SYSTEM_PROPERTIES>,
+  EventHubMessageBaseWrapper<unknown, unknown, unknown>
+>;
+
+/**
+ * Wrapper for Event Hub Messages, including payload, properties, system properties, and optionally the raw event data.
+ * It allows for flexible typing of the Message components. Can be used to strongly type the Message structure in handler methods.
+ *
+ * Type Parameters:
+ * - `PAYLOAD`: The type of the Message payload.
+ * - `PROPERTIES`: The type of the custom properties of the Message. If not provided, properties will be omitted.
+ * - `SYSTEM_PROPERTIES`: The type of the system properties of the Message. If not provided, system properties will be omitted.
+ * - `EVENT_DATA`: If set to true, includes the raw Event Hub event data in the wrapper.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * const eventPropertiesSchema = z.object({ source: z.string() });
+ * type EventProperties = z.infer<typeof eventPropertiesSchema>;
+ *
+ * type MyEventHubMessage = EventHubMessageWrapper<EventPayload, EventProperties, undefined, true>;
+ */
+export type EventHubMessageWrapper<
+  PAYLOAD = unknown,
+  PROPERTIES = undefined,
+  SYSTEM_PROPERTIES = undefined,
+  EVENT_DATA extends true | undefined = undefined,
+> = SafeEventHubMessageWrapper<PAYLOAD, PROPERTIES, SYSTEM_PROPERTIES> &
+  (EVENT_DATA extends undefined ? object : { eventData: EventHubEventData });

package/src/event-hub-handler/event-hub-trigger-support.factory.ts

@@ -0,0 +1,234 @@
+import { injectable } from 'inversify';
+import { HandlerArgsParseError } from 'shared';
+import { z, ZodObject, ZodType } from 'zod';
+import {
+  EventHubHandlerArgMetadata,
+  EventHubHandlerCardinality,
+  EventHubHandlerMessageArgMetadata,
+} from './decorators';
+import {
+  EventHubArgProvider,
+  EventHubArgProviderInput,
+  EventHubAsyncArgsProvider,
+  EventHubEventData,
+  EventHubEventDataSchema,
+  EventHubTriggerDefinitionError,
+  SafeWrapper,
+} from './event-hub-handler.model';
+import {
+  TriggerMetadataMany,
+  triggerMetadataManySchema,
+  TriggerMetadataOne,
+  triggerMetadataOneSchema,
+} from './event-hub-trigger.model';
+
+type EventHubUnknownMessageSchema = ZodObject<{
+  payload: ZodType<unknown>;
+  properties?: ZodType<unknown>;
+  systemProperties?: ZodType<unknown>;
+  eventData?: ZodType<EventHubEventData>;
+}>;
+
+@injectable()
+export class EventHubTriggerSupportFactory {
+  buildArgProviders(
+    args: EventHubHandlerArgMetadata[],
+    cardinality?: EventHubHandlerCardinality,
+  ): EventHubAsyncArgsProvider {
+    const argProviders: EventHubArgProvider[] = [];
+    for (const arg of args) {
+      switch (arg.type) {
+        case 'invocationContext':
+          argProviders.push(({ context }) => context);
+          break;
+        case 'message':
+          if (cardinality === 'many') {
+            throw new EventHubTriggerDefinitionError('Decorator "Message" is not allowed with cardinality "many"', {
+              details: {
+                arg,
+                cardinality,
+              },
+            });
+          }
+          argProviders.push(this.getMessageProvider(arg));
+          break;
+        case 'messages':
+          if (cardinality !== 'many') {
+            throw new EventHubTriggerDefinitionError('Decorator "Messages" is only allowed with cardinality "many"', {
+              details: {
+                arg,
+                cardinality,
+              },
+            });
+          }
+          argProviders.push(this.getMessagesProvider(arg));
+          break;
+        case 'rawMessage':
+          if (cardinality === 'many') {
+            throw new EventHubTriggerDefinitionError('Decorator "RawMessage" is not allowed with cardinality "many"', {
+              details: {
+                arg,
+                cardinality,
+              },
+            });
+          }
+          argProviders.push(({ messages }) => messages);
+          break;
+        case 'rawMessages':
+          if (cardinality !== 'many') {
+            throw new EventHubTriggerDefinitionError(
+              'Decorator "RawMessages" is only allowed with cardinality "many"',
+              {
+                details: {
+                  arg,
+                  cardinality,
+                },
+              },
+            );
+          }
+          argProviders.push(({ messages }) => messages);
+          break;
+        case 'undefined':
+          argProviders.push(() => undefined);
+          break;
+      }
+    }
+    return this.getArgsProvider(argProviders);
+  }
+
+  private getArgsProvider(argProviders: EventHubArgProvider[]): EventHubAsyncArgsProvider {
+    return async (messages, context) => {
+      return await Promise.allSettled(
+        argProviders.map(argProvider => {
+          const asyncArgProvider = async () => argProvider({ messages, context });
+          return asyncArgProvider();
+        }),
+      ).then(results => {
+        const splitResults = results.reduce(
+          (aggregator, currentValue) => {
+            if (currentValue.status === 'fulfilled') {
+              aggregator.fulfilled.push(currentValue.value);
+            } else {
+              aggregator.rejected.push(currentValue.reason);
+            }
+            return aggregator;
+          },
+          { fulfilled: new Array<unknown>(), rejected: new Array<unknown>() },
+        );
+        if (splitResults.rejected.length === 0) {
+          return splitResults.fulfilled;
+        } else {
+          throw new HandlerArgsParseError('Error parsing handler arguments', {
+            details: {
+              rejected: splitResults.rejected,
+            },
+          });
+        }
+      });
+    };
+  }
+
+  private getMessageProvider(
+    argMetadata: EventHubHandlerMessageArgMetadata,
+  ): (input: EventHubArgProviderInput) => Promise<unknown> {
+    const extendedMessageSchema = this.provideExtendedMessageSchema(argMetadata);
+    return async (input): Promise<unknown> => {
+      const { context, messages: payload } = input;
+      let triggerMetadata: TriggerMetadataOne;
+      try {
+        triggerMetadata = triggerMetadataOneSchema.parse(context.triggerMetadata);
+      } catch (e) {
+        throw new HandlerArgsParseError('Error parsing trigger metadata', {
+          cause: e,
+          details: {
+            argMetadata,
+          },
+        });
+      }
+      return this.validateMessage(payload, triggerMetadata, extendedMessageSchema, argMetadata);
+    };
+  }
+
+  private validateMessage(
+    payload: unknown,
+    triggerMetadata: TriggerMetadataOne,
+    schema: EventHubUnknownMessageSchema,
+    argMetadata: EventHubHandlerMessageArgMetadata,
+  ): SafeWrapper<unknown, unknown> {
+    const extendedMessage = {
+      payload,
+      properties: triggerMetadata.properties,
+      systemProperties: triggerMetadata.systemProperties,
+      eventData: {
+        partitionContext: triggerMetadata.partitionContext,
+        enqueuedTimeUtc: triggerMetadata.enqueuedTimeUtc,
+        offset: triggerMetadata.offset,
+        partitionKey: triggerMetadata.partitionKey,
+        sequenceNumber: triggerMetadata.sequenceNumber,
+      },
+    };
+    const safeParsed = schema.safeParse(extendedMessage);
+    if (!safeParsed.success) {
+      return {
+        valid: false,
+        error: new HandlerArgsParseError('Error parsing extended message', {
+          cause: safeParsed.error,
+          details: { argMetadata },
+        }),
+        ...extendedMessage,
+      };
+    }
+    return {
+      valid: true,
+      ...safeParsed.data,
+    };
+  }
+
+  private getMessagesProvider(
+    argMetadata: EventHubHandlerMessageArgMetadata,
+  ): (input: EventHubArgProviderInput) => unknown {
+    const extendedMessageSchema = this.provideExtendedMessageSchema(argMetadata);
+    return async ({ context, messages }): Promise<unknown> => {
+      if (!Array.isArray(messages)) {
+        throw new HandlerArgsParseError('Message should be an array for cardinality "many"', {
+          details: {
+            argMetadata,
+            cardinality: 'many',
+          },
+        });
+      }
+      let triggerMetadata: TriggerMetadataMany;
+      try {
+        triggerMetadata = triggerMetadataManySchema.parse(context.triggerMetadata);
+      } catch (e: unknown) {
+        throw new HandlerArgsParseError('Error parsing trigger metadata', {
+          cause: e,
+          details: {
+            argMetadata,
+          },
+        });
+      }
+      return messages.map((payload, index) => {
+        const triggerMetadataEntry = {
+          enqueuedTimeUtc: triggerMetadata.enqueuedTimeUtcArray[index]!,
+          offset: triggerMetadata.offsetArray[index]!,
+          partitionKey: triggerMetadata.partitionKeyArray[index]!,
+          sequenceNumber: triggerMetadata.sequenceNumberArray[index]!,
+          partitionContext: triggerMetadata.partitionContext,
+          properties: triggerMetadata.propertiesArray[index]!,
+          systemProperties: triggerMetadata.systemPropertiesArray[index]!,
+        };
+        return this.validateMessage(payload, triggerMetadataEntry, extendedMessageSchema, argMetadata);
+      });
+    };
+  }
+
+  private provideExtendedMessageSchema(argMetadata: EventHubHandlerMessageArgMetadata): EventHubUnknownMessageSchema {
+    return z.object({
+      payload: argMetadata.payloadSchema ?? z.unknown(),
+      ...(argMetadata.propertiesSchema ? { properties: argMetadata.propertiesSchema } : {}),
+      ...(argMetadata.systemPropertiesSchema ? { systemProperties: argMetadata.systemPropertiesSchema } : {}),
+      ...(argMetadata.isEventData ? { eventData: EventHubEventDataSchema } : {}),
+    });
+  }
+}

package/src/event-hub-handler/event-hub-trigger.model.ts

@@ -0,0 +1,36 @@
+import z from 'zod';
+
+const partitionContextSchema = z.object({
+  fullyQualifiedNamespace: z.string(),
+  consumerGroup: z.string(),
+  eventHubName: z.string(),
+  partitionId: z.string(),
+});
+
+export type PartitionContext = z.infer<typeof partitionContextSchema>;
+
+const triggerMetadataBaseSchema = z.object({
+  partitionContext: partitionContextSchema,
+});
+
+export const triggerMetadataOneSchema = z.object({
+  ...triggerMetadataBaseSchema.shape,
+  enqueuedTimeUtc: z.iso.datetime({ local: true }),
+  offset: z.int(),
+  partitionKey: z.string(),
+  sequenceNumber: z.int(),
+  properties: z.record(z.string(), z.any()),
+  systemProperties: z.record(z.string(), z.any()),
+});
+export type TriggerMetadataOne = z.infer<typeof triggerMetadataOneSchema>;
+
+export const triggerMetadataManySchema = z.object({
+  ...triggerMetadataBaseSchema.shape,
+  enqueuedTimeUtcArray: z.iso.datetime({ local: true }).array(),
+  offsetArray: z.int().array(),
+  partitionKeyArray: z.string().array(),
+  sequenceNumberArray: z.int().array(),
+  propertiesArray: z.record(z.string(), z.any()).array(),
+  systemPropertiesArray: z.record(z.string(), z.any()).array(),
+});
+export type TriggerMetadataMany = z.infer<typeof triggerMetadataManySchema>;

package/src/event-hub-handler/event-hub-triggers-registration.service.ts

@@ -0,0 +1,74 @@
+import { inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { TriggerHandlerClass, TriggerHandlerMetadataError } from 'shared';
+import { EventHubHandlerMetadata, EventHubTriggerMetadata } from './decorators/index';
+import { EventHubHandlerMetadataReader } from './event-hub-handler-metadata.reader';
+
+export interface EventhubTriggerRegistration {
+  triggerId: string;
+  triggerMethod: string;
+  handlerMetadata: EventHubHandlerMetadata;
+  triggerMetadata: EventHubTriggerMetadata;
+}
+
+export type RegisterCallback = (triggerRegistration: EventhubTriggerRegistration) => void;
+
+@injectable()
+export class EventHubTriggersRegistrationService {
+  private readonly logger;
+
+  constructor(
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+    private readonly metadataReader: EventHubHandlerMetadataReader,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  registerTriggers(handlerClass: TriggerHandlerClass, registerCallback: RegisterCallback): void {
+    const handlerMetadata = this.metadataReader.getHandlerClassMetadata(handlerClass);
+    const prototype = handlerClass.prototype;
+    this.logger.debug('Registering operations for event hub handler started', {
+      class: handlerClass.name,
+      metadata: handlerMetadata,
+    });
+    let operationsCount = 0;
+    for (const triggerMethod of Object.getOwnPropertyNames(prototype)) {
+      const triggerMetadata = this.getOperationMetadata(handlerClass, triggerMethod);
+      if (triggerMetadata === undefined) {
+        continue;
+      }
+      const triggerId = triggerMetadata.triggerId ?? triggerMethod;
+      const triggerRegistration: EventhubTriggerRegistration = {
+        triggerId,
+        triggerMethod,
+        handlerMetadata: handlerMetadata,
+        triggerMetadata,
+      };
+      registerCallback(triggerRegistration);
+      operationsCount++;
+      this.logger.debug(
+        `Trigger ${triggerId} for method ${triggerMethod} in handler class ${handlerClass.name} registered`,
+        {
+          class: handlerClass.name,
+          ...triggerRegistration,
+        },
+      );
+    }
+    this.logger.verbose(`${operationsCount} operation(s) for handler ${handlerClass.name} registered`);
+  }
+
+  private getOperationMetadata(
+    handlerClass: TriggerHandlerClass,
+    handlerMethod: string,
+  ): EventHubTriggerMetadata | undefined {
+    try {
+      return this.metadataReader.getTriggerMetadata(handlerClass, handlerMethod);
+    } catch (error) {
+      // if Azure Function class is not EventHub Handler
+      if (error instanceof TriggerHandlerMetadataError) {
+        return undefined;
+      }
+      throw error;
+    }
+  }
+}

package/src/event-hub-handler/index.ts

@@ -0,0 +1,19 @@
+import { ContainerModule } from 'inversify';
+import { TRIGGER_HANDLER_REGISTRATION_SERVICE } from 'shared';
+import { EVENT_HUB_HANDLER_TYPE } from './decorators';
+import { EventHubHandlerMetadataReader } from './event-hub-handler-metadata.reader';
+import { EventHubHandlerRegistrationService } from './event-hub-handler-registration.service';
+import { EventHubHandlerFactory } from './event-hub-handler.factory';
+import { EventHubTriggerSupportFactory } from './event-hub-trigger-support.factory';
+import { EventHubTriggersRegistrationService } from './event-hub-triggers-registration.service';
+
+export * from './decorators';
+export { EventHubMessageWrapper } from './event-hub-handler.model';
+
+export const EventHubHandlersModule = new ContainerModule(({ bind }) => {
+  bind(EventHubTriggerSupportFactory).toSelf();
+  bind(EventHubHandlerMetadataReader).toSelf();
+  bind(EventHubHandlerFactory).toSelf();
+  bind(TRIGGER_HANDLER_REGISTRATION_SERVICE).to(EventHubHandlerRegistrationService).whenNamed(EVENT_HUB_HANDLER_TYPE);
+  bind(EventHubTriggersRegistrationService).toSelf();
+});

package/src/framework.container.ts

@@ -0,0 +1,24 @@
+import { EventHubHandlersModule } from 'event-hub-handler';
+import { HttpControllerModule } from 'http-controller';
+import { Container } from 'inversify';
+import { LOGGER_FACTORY, LoggerConfiguration } from 'logger';
+import { PlatformModule } from 'platform';
+import { PLATFORM_CONTAINER, SharedModule } from 'shared';
+import * as winston from 'winston';
+import { bindLoggerFactory } from './logger/bindings';
+import { providePlatformContainer } from './platform.container';
+
+export function createContainers(loggerConfiguration?: LoggerConfiguration): {
+  frameworkContainer: Container;
+  platformContainer: Container;
+} {
+  const frameworkContainer = new Container({
+    defaultScope: 'Singleton',
+  });
+  frameworkContainer.loadSync(SharedModule, PlatformModule, HttpControllerModule, EventHubHandlersModule);
+  const platformContainer = providePlatformContainer(loggerConfiguration);
+  frameworkContainer.bind(PLATFORM_CONTAINER).toConstantValue(platformContainer);
+  frameworkContainer.bind(winston.Logger).toDynamicValue(() => platformContainer.get(winston.Logger));
+  frameworkContainer.bind(LOGGER_FACTORY).toDynamicValue(context => bindLoggerFactory(context));
+  return { frameworkContainer, platformContainer };
+}