@herrromich/az-functions 1.0.0

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@herrromich/az-functions",
+  "description": "Extensions for NodeJS Azure Functions",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "dist/index.cjs",
+  "types": "dist/src/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.41",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.218.0",
+    "@opentelemetry/core": "^2.7.0",
+    "@opentelemetry/resources": "^2.7.0",
+    "@opentelemetry/sdk-logs": "^0.215.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "http-status-codes": "^2.3.0",
+    "lodash": "^4.17.21",
+    "mime-types": "^3.0.1",
+    "openapi3-ts": "^4.5.0",
+    "swagger-ui-dist": "^5.30.2",
+    "triple-beam": "^1.3.0",
+    "tslib": "^2.8.1",
+    "winston": "^3.18.3",
+    "winston-transport": "^4.9.0",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@asteasolutions/zod-to-openapi": "^8.2.0",
+    "@types/eslint": "^9.6.1",
+    "@types/jest": "^29.5.14",
+    "@types/lodash": "^4.17.20",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "22.13.14",
+    "@types/triple-beam": "^1.3.5",
+    "copy-webpack-plugin": "^13.0.1",
+    "eslint": "^9.39.4",
+    "jest": "^30.3.0",
+    "jest-extended": "^7.0.0",
+    "jest-mock": "^30.2.0",
+    "jest-mock-extended": "^4.0.0",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.0.0",
+    "source-map-loader": "^5.0.0",
+    "syncpack": "~13.0.4",
+    "tsc-alias": "^1.9.2",
+    "type-fest": "^5.5.0",
+    "typescript": "~5.9.3",
+    "webpack": "^5.102.1",
+    "webpack-bundle-analyzer": "^4.10.2",
+    "webpack-node-externals": "^3.0.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@asteasolutions/zod-to-openapi": "^8.2.0",
+    "@azure/functions": "^4.9.0",
+    "inversify": "^7.10.4",
+    "reflect-metadata": "0.2.2",
+    "zod": "^4.3.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:HerrRomich/az-functions.git"
+  },
+  "scripts": {
+    "dist:clean": "rimraf ./dist",
+    "dist:fix-types": "tsc-alias -p tsconfig.json --outDir dist",
+    "dist:assemble": "pnpm run dist:build",
+    "dist:build": "pnpm run dist:clean && webpack --mode=production && pnpm run dist:fix-types",
+    "dist:build:recursive": "pnpm -r --sort --filter {.}... run dist:build",
+    "watch:fix-types": "tsc-alias -p tsconfig.json --outDir dist --watch",
+    "watch:webpack": "webpack --mode=development --watch",
+    "watch": "pnpm run watch:webpack & pnpm run watch:fix-types",
+    "watch:recursive": "pnpm -r --sort --filter {.}... --parallel --stream run watch",
+    "test": "jest --env=node --colors --coverage",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "ci:build": "pnpm lint && pnpm test && pnpm dist:build",
+    "ci:build:recursive": "pnpm -r --sort --filter {.}... run ci:build"
+  }
+}

package/src/context/index.ts

@@ -0,0 +1,4 @@
+export * from './platform-context.manager';
+export * from './platform-context.model';
+export * from './platform-context.provider';
+export * from './platform.execution.context';

package/src/context/platform-context.manager.ts

@@ -0,0 +1,36 @@
+import { injectable } from 'inversify';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { serviceIdentifier } from 'shared';
+import { PlatformContext } from './platform-context.model';
+
+/**
+ * A unique identifier for the PlatformContextManager service.
+ * This identifier can be used for dependency injection and service resolution.
+ */
+export const PLATFORM_CONTEXT_MANAGER = serviceIdentifier<PlatformContextManager>('AzFunction.ContextManager');
+
+/**
+ * Interface representing a manager for PlatformContext instances.
+ * The manager provides methods to access the active context and to run code within a specific context.
+ *
+ * - `active()`: Returns the currently active PlatformContext, or undefined if no context is active.
+ * - `runWith(platformContext, callback)`: Runs the provided callback function within the specified PlatformContext.
+ *   The callback will have access to the context during its execution.
+ */
+export interface PlatformContextManager {
+  active(): PlatformContext | undefined;
+  runWith<T>(platformContext: PlatformContext, callback: () => T): T;
+}
+
+@injectable()
+export class BasePlatformContextManager implements PlatformContextManager {
+  private readonly storage = new AsyncLocalStorage<PlatformContext>();
+
+  runWith<T>(platformContext: PlatformContext, callback: () => T): T {
+    return this.storage.run(platformContext, callback);
+  }
+
+  active(): PlatformContext | undefined {
+    return this.storage.getStore();
+  }
+}

package/src/context/platform-context.model.ts

@@ -0,0 +1,59 @@
+import { InvocationContext } from '@azure/functions';
+import { AzFunctionsRuntimeError } from 'shared';
+
+/**
+ * Error class representing errors related to the platform context in Azure Functions.
+ * This class extends the AzFunctionsRuntimeError and can be used to throw errors specific to platform context operations.
+ */
+export class PlatformContextError extends AzFunctionsRuntimeError {}
+
+/**
+ * Type representing a unique key for storing and retrieving values in the PlatformContext.
+ * The key is created using a symbol, ensuring uniqueness across the application.
+ * The generic type parameter T allows for type safety when associating values with the key.
+ *
+ * @template T - The type of the value associated with the key.
+ */
+export type PlatformContextValueKey<T = unknown> = symbol & { __type: T };
+
+/**
+ * Creates a unique key for storing and retrieving values in the PlatformContext.
+ * The key is created using a symbol, ensuring uniqueness across the application.
+ *
+ * @template T - The type of the value associated with the key.
+ * @param key - The unique string identifier for the key.
+ * @returns A unique PlatformContextValueKey for the specified type.
+ *
+ * @example
+ * const MY_KEY = createPlatformContextValueKey<MyType>('MyUniqueKey');
+ *
+ * // Retrieve a value from the PlatformContext using the key
+ * const value = platformContext.getValue(MY_KEY);
+ *
+ * // Set a value in the PlatformContext using the key
+ * platformContext.setValue(MY_KEY, myValue);
+ *
+ * // Delete a value from the PlatformContext using the key
+ * platformContext.deleteValue(MY_KEY);
+ */
+export function createPlatformContextValueKey<T>(key: string): PlatformContextValueKey<T> {
+  return Symbol.for(key) as PlatformContextValueKey<T>;
+}
+
+/**
+ * Interface representing the platform context in Azure Functions.
+ * The PlatformContext provides access to the invocation context and allows storing and retrieving values associated with the context.
+ *
+ * - `invocationContext`: The InvocationContext associated with the current execution.
+ * - `getValue(key)`: Retrieves a value associated with the specified key from the context.
+ * - `setValue(key, value)`: Sets a value associated with the specified key in the context.
+ * - `deleteValue(key)`: Deletes a value associated with the specified key from the context.
+ * - `clone()`: Creates a deep copy of the current PlatformContext, preserving its values and invocation context.
+ */
+export interface PlatformContext {
+  readonly invocationContext: InvocationContext;
+  getValue<T>(key: PlatformContextValueKey<T>): T | undefined;
+  setValue<T>(key: PlatformContextValueKey<T>, value: T): PlatformContext;
+  deleteValue(key: PlatformContextValueKey): PlatformContext;
+  clone(): PlatformContext;
+}

package/src/context/platform-context.provider.ts

@@ -0,0 +1,37 @@
+import { InvocationContext } from '@azure/functions';
+import { injectable } from 'inversify';
+import { serviceIdentifier } from 'shared';
+import * as winston from 'winston';
+import { createPlatformContextValueKey, PlatformContext } from './platform-context.model';
+import { PlatformExecutionContext } from './platform.execution.context';
+
+/**
+ * A unique identifier for the PlatformContextProvider service.
+ * This identifier can be used for dependency injection and service resolution.
+ */
+export const PLATFORM_CONTEXT_PROVIDER = serviceIdentifier<PlatformContextProvider>(
+  'AzFunctions.Platform.ContextProvider',
+);
+
+/**
+ * Interface representing a provider for PlatformContext instances.
+ * The provider is responsible for creating and providing PlatformContext instances based on the given InvocationContext.
+ *
+ * - `providePlatformContext(invocationContext)`: Creates and returns a PlatformContext instance for the provided InvocationContext.
+ */
+export interface PlatformContextProvider {
+  providePlatformContext(invocationContext: InvocationContext): PlatformContext;
+}
+
+export const ORIGINAL_INVOCATION_CONTEXT_VALUE_KEY = createPlatformContextValueKey<InvocationContext>(
+  'AzFunctions.Platform.OriginalInvocationContext',
+);
+
+@injectable()
+export class PlatformExecutionContextProvider implements PlatformContextProvider {
+  constructor(private readonly logger: winston.Logger) {}
+
+  providePlatformContext(invocationContext: InvocationContext): PlatformContext {
+    return new PlatformExecutionContext(invocationContext, this.logger);
+  }
+}

package/src/context/platform.execution.context.ts

@@ -0,0 +1,44 @@
+import { InvocationContext } from '@azure/functions';
+import * as winston from 'winston';
+import { PlatformContext, PlatformContextError, PlatformContextValueKey } from './platform-context.model';
+import { ORIGINAL_INVOCATION_CONTEXT_VALUE_KEY } from './platform-context.provider';
+import { WrappedInvocationContext } from './wrapped-invocation-context';
+
+export class PlatformExecutionContext implements PlatformContext {
+  private readonly data: Map<PlatformContextValueKey, unknown>;
+  readonly invocationContext: InvocationContext;
+  private readonly logger;
+
+  constructor(invocationContext: InvocationContext, logger: winston.Logger) {
+    this.logger = logger.child({});
+    this.invocationContext = new WrappedInvocationContext(invocationContext, this.logger);
+    this.data = new Map<PlatformContextValueKey, unknown>();
+    this.data.set(ORIGINAL_INVOCATION_CONTEXT_VALUE_KEY, invocationContext);
+  }
+
+  getValue<T>(key: PlatformContextValueKey<T>): T | undefined {
+    return this.data.get(key) as T | undefined;
+  }
+
+  setValue<T>(key: PlatformContextValueKey<T>, value: T): PlatformContext {
+    this.data.set(key, value);
+    return this;
+  }
+
+  deleteValue(key: PlatformContextValueKey): PlatformContext {
+    this.data.delete(key);
+    return this;
+  }
+
+  clone(): PlatformContext {
+    const originalContext = this.getValue(ORIGINAL_INVOCATION_CONTEXT_VALUE_KEY);
+    if (!originalContext) {
+      throw new PlatformContextError('Original invocation context is missing');
+    }
+    const clonedContext = new PlatformExecutionContext(originalContext, this.logger);
+    for (const [key, value] of this.data.entries()) {
+      clonedContext.setValue(key, value);
+    }
+    return clonedContext;
+  }
+}

package/src/context/wrapped-invocation-context.ts

@@ -0,0 +1,26 @@
+import { LogLevel as FunctionsLoglevel, InvocationContext } from '@azure/functions';
+import { LogLevel } from 'logger';
+import * as winston from 'winston';
+
+const LOG_LEVEL_MAP: Record<FunctionsLoglevel, LogLevel> = {
+  critical: 'error',
+  error: 'error',
+  warning: 'warn',
+  information: 'info',
+  debug: 'debug',
+  trace: 'verbose',
+  none: 'info',
+};
+
+export class WrappedInvocationContext extends InvocationContext {
+  constructor(parentInvocationContext: InvocationContext, logger: winston.Logger) {
+    super({
+      ...parentInvocationContext,
+      logHandler: (level, ...args) => {
+        const translatedLogLevel = LOG_LEVEL_MAP[level];
+        const [message, ...meta] = args;
+        logger.log(translatedLogLevel, message as string, ...meta);
+      },
+    });
+  }
+}

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

@@ -0,0 +1,76 @@
+import { EventHubFunctionOptions, EventHubTriggerOptions } from '@azure/functions';
+import { ArgMetadata, CommonArgMetadata, TriggerHandlerClassMetadata } from 'shared';
+import { ZodType } from 'zod';
+
+/**
+ * Configuration for an Event Hub handler.
+ * - `connection`: The name of the app setting that contains the Event Hub connection string.
+ * - `eventHubName`: The name of the Event Hub to listen to.
+ */
+export interface EventHubHandlerConfig {
+  connection: string;
+  eventHubName: string;
+}
+
+export const EVENT_HUB_HANDLER_TYPE = 'event-hub-handler';
+
+export interface EventHubHandlerMetadata extends TriggerHandlerClassMetadata, EventHubHandlerConfig {
+  type: typeof EVENT_HUB_HANDLER_TYPE;
+}
+
+export type EventHubHandlerCardinality = EventHubTriggerOptions['cardinality'];
+
+/**
+ * Configuration for an Event Hub handler.
+ * - `triggerId`: A unique identifier for the trigger.
+ * - `consumerGroup`: (Optional) The consumer group to use. Defaults to `$Default`.
+ * - `cardinality`: (Optional) The cardinality of the Messages, either 'one' or 'many'. Defaults to 'many'.
+ * - `extraInputs`: (Optional) Additional inputs for the function.
+ * - `extraOutputs`: (Optional) Additional outputs for the function.
+ */
+export type OnEventHubTriggerConfig = {
+  triggerId?: string;
+  consumerGroup?: string;
+  cardinality?: EventHubHandlerCardinality;
+} & Pick<EventHubFunctionOptions, 'extraInputs' | 'extraOutputs'>;
+
+/**
+ * Configuration for an Event Hub trigger message argument.
+ * - `withPayload`: (Optional) A Zod schema for the payload of the message. If not provided, the payload will be of type `unknown`.
+ * - `withSystemProperties`: (Optional) A Zod schema for the system properties of the message. If not provided, the system properties won't be included in the message argument.
+ * - `withProperties`: (Optional) A Zod schema for the custom properties of the message. If not provided, the properties won't be included in the message argument.
+ * - `withEventData`: (Optional) If true, includes the raw EventData in the message argument.
+ */
+export interface EventHubTriggerMessageArgConfig {
+  withPayload?: ZodType<unknown>;
+  withSystemProperties?: ZodType<unknown>;
+  withProperties?: ZodType<unknown>;
+  withEventData?: true;
+}
+
+export interface EventHubHandlerMessageArgMetadata {
+  payloadSchema?: ZodType<unknown>;
+  systemPropertiesSchema?: ZodType<unknown>;
+  propertiesSchema?: ZodType<unknown>;
+  isEventData?: true;
+}
+
+export interface EventHubHandlerDataArgMetadata extends EventHubHandlerMessageArgMetadata, ArgMetadata {
+  type: 'message' | 'messages';
+}
+
+export interface EventHubHandlerRawDataArgMetadata extends ArgMetadata {
+  type: 'rawMessage' | 'rawMessages';
+}
+
+export type EventHubHandlerArgMetadata =
+  | CommonArgMetadata
+  | EventHubHandlerRawDataArgMetadata
+  | EventHubHandlerDataArgMetadata;
+
+export interface OnEventHubTriggerArgsMetadata {
+  args: EventHubHandlerArgMetadata[];
+}
+
+export type EventHubTriggerMetadata = { type: typeof EVENT_HUB_HANDLER_TYPE } & OnEventHubTriggerConfig &
+  OnEventHubTriggerArgsMetadata;

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

@@ -0,0 +1,231 @@
+import { decorate, injectable } from 'inversify';
+import * as shared from 'shared';
+import { adjustMetadata, FUNCTION_HANDLER_METADATA, getCommonArg } from 'shared';
+import {
+  EventHubHandlerArgMetadata,
+  EventHubHandlerConfig,
+  EventHubHandlerMetadata,
+  EventHubTriggerMessageArgConfig,
+  EventHubTriggerMetadata,
+  OnEventHubTriggerArgsMetadata,
+  OnEventHubTriggerConfig,
+} from './decorators.model';
+
+/**
+ * Class decorator to define an Event Hub function handler.
+ * This decorator registers the class as an Event Hub handler with the specified configuration.
+ *
+ * @param config Configuration for the Event Hub handler, including the name and event hub details.
+ *
+ * @example
+ * ```ts
+ * @EventHubHandler({
+ *   eventHubName: 'my-event-hub',
+ *   connection: 'EventHubConnectionString',
+ *   consumerGroup: '$Default',
+ * })
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *
+ *   @OnEventHubTrigger({ cardinality: 'many' })
+ *   async handle(
+ *     @Messages({ withPayload: z.object({ id: z.string(), value: z.number() }) }) messages: EventHubMessageWrapper<{ id: string; value: number }>[],
+ *     InvocationCtx: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       console.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function EventHubHandler(config: EventHubHandlerConfig): ClassDecorator {
+  return target => {
+    const metadata: EventHubHandlerMetadata = {
+      type: 'event-hub-handler',
+      ...config,
+    };
+    Reflect.defineMetadata(FUNCTION_HANDLER_METADATA, metadata, target);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    decorate(injectable(), target as Function);
+  };
+}
+
+/**
+ * Class decorator to define an Event Hub function handler.
+ * This decorator registers the class as an Event Hub handler with the specified configuration.
+ *
+ * @param config Configuration for the Event Hub handler, including the name and event hub details.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * @EventHubHandler({
+ *   eventHubName: 'my-event-hub',
+ *   connection: 'EventHubConnectionString',
+ *   consumerGroup: '$Default',
+ * })
+ * class MyEventHubHandler {
+ *   @OnEventHubTrigger({
+ *     triggerId: 'my-event-hub-trigger',
+ *     cardinality: 'many'
+ *   })
+ *   async handle(
+ *     @Messages({ withPayload: eventPayloadSchema, withEventData: true }) messages: EventHubMessageWrapper<EventPayload, undefined, undefined, true>[],
+ *     InvocationCtx: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       console.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}, enqueued at: ${message.eventData.enqueuedTimeUtc}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function OnEventHubTrigger(config: OnEventHubTriggerConfig): MethodDecorator {
+  return (target, propertyKey) => {
+    const ownMetadata = Reflect.getOwnMetadata(FUNCTION_HANDLER_METADATA, target, propertyKey) as
+      | OnEventHubTriggerArgsMetadata
+      | undefined;
+    const argsMetadata =
+      ownMetadata ?? shared.initializeMetadata<EventHubHandlerArgMetadata>(target, propertyKey, getCommonArg);
+    const metadata: EventHubTriggerMetadata = {
+      type: 'event-hub-handler',
+      ...config,
+      ...argsMetadata,
+    };
+    Reflect.defineMetadata(FUNCTION_HANDLER_METADATA, metadata, target, propertyKey);
+  };
+}
+
+/**
+ * Parameter decorator to inject Event Hub Message data into the handler method.
+ *
+ * This decorator can be used to specify the structure of the Event Hub Message payload,
+ * system properties, and custom properties using Zod schemas.
+ *
+ * @param messageConfig
+ * Configuration for the Event Hub Message argument, including optional Zod schemas for payload, system properties, and custom properties.
+ * - `withPayload`: A Zod schema to validate and parse the Message payload.
+ * - `withSystemProperties`: A Zod schema to validate and parse the system properties of the Message. If not provided, system properties will not be included.
+ * - `withProperties`: A Zod schema to validate and parse custom properties of the Message. If not provided, custom properties will not be included.
+ * - `withEventData`: If set to true, includes the raw Event Hub event data in the argument.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * const eventAppPropertiesSchema = z.object({ APP_REGISTRATION_ID: z.string() });
+ * type EventAppProperties = z.infer<typeof eventAppPropertiesSchema>;
+ *
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @Message({ withPayload: eventPayloadSchema, withProperties: eventAppPropertiesSchema
+ *     }) Message: EventHubMessageWrapper<EventPayload, undefined, EventAppProperties>,
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     context.log(`Received Message with id: ${Message.payload.id} and value: ${Message.payload.value}`);
+ *   }
+ * }
+ * ```
+ */
+export function Message(messageConfig: EventHubTriggerMessageArgConfig): ParameterDecorator {
+  return adjustHandlerMetadata(convertEventHubConfigToMeta('message', messageConfig));
+}
+
+/**
+ * Parameter decorator to inject multiple Event Hub Messages into the handler method.
+ *
+ * This decorator can be used to specify the structure of the Event Hub Message payload,
+ * system properties, and custom properties using Zod schemas.
+ * @param messagesConfig
+ * Configuration for the Event Hub Messages argument, including optional Zod schemas for payload, system properties, and custom properties.
+ * - `withPayload`: A Zod schema to validate and parse the Message payload.
+ * - `withSystemProperties`: A Zod schema to validate and parse the system properties of the Message. If not provided, system properties will not be included.
+ * - `withProperties`: A Zod schema to validate and parse custom properties of the Message. If not provided, custom properties will not be included.
+ * - `withEventData`: If set to true, includes the raw Event Hub event data in the argument.
+ *
+ * @example
+ * ```ts
+const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+type EventPayload = z.infer<typeof eventPayloadSchema>;
+
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @Messages({ withPayload: eventPayloadSchema }) messages: EventHubMessageWrapper<EventPayload>[],
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *   for (const message of messages) {
+ *    context.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}`);
+ *   }
+ *  }
+ * }
+ * ```
+ */
+export function Messages(messagesConfig: EventHubTriggerMessageArgConfig): ParameterDecorator {
+  return adjustHandlerMetadata(convertEventHubConfigToMeta('messages', messagesConfig));
+}
+
+/**
+ * Parameter decorator to inject the raw Event Hub Message into the handler method.
+ * This decorator can be used when you need access to the complete Event Hub Message object,
+ *
+ * @example
+ * ```ts
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @RawMessage() message: unknown,
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     context.log(`Received raw Message: ${JSON.stringify(message)}`);
+ *   }
+ * }
+ * ```
+ */
+export function RawMessage(): ParameterDecorator {
+  return adjustHandlerMetadata({
+    type: 'rawMessage',
+  });
+}
+
+/**
+ * Parameter decorator to inject multiple raw Event Hub Messages into the handler method.
+ * This decorator can be used when you need access to the complete Event Hub Message objects,
+ *
+ * @example
+ * ```ts
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @RawMessages() messages: unknown[],
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       context.log(`Received raw Message: ${JSON.stringify(message)}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function RawMessages(): ParameterDecorator {
+  return adjustHandlerMetadata({
+    type: 'rawMessages',
+  });
+}
+
+function convertEventHubConfigToMeta(
+  type: EventHubHandlerArgMetadata['type'],
+  messagesConfig: EventHubTriggerMessageArgConfig,
+): EventHubHandlerArgMetadata {
+  return {
+    type,
+    payloadSchema: messagesConfig.withPayload,
+    systemPropertiesSchema: messagesConfig.withSystemProperties,
+    propertiesSchema: messagesConfig.withProperties,
+    isEventData: messagesConfig.withEventData,
+  };
+}
+
+function adjustHandlerMetadata(handlerArg: EventHubHandlerArgMetadata): ParameterDecorator {
+  return adjustMetadata(FUNCTION_HANDLER_METADATA, handlerArg, getCommonArg);
+}

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

@@ -0,0 +1,2 @@
+export * from './decorators';
+export * from './decorators.model';

package/src/event-hub-handler/event-hub-handler-metadata.reader.ts

@@ -0,0 +1,38 @@
+import { injectable } from 'inversify';
+import {
+  FUNCTION_HANDLER_METADATA,
+  TriggerHandlerClass,
+  TriggerHandlerMetadataError,
+  TriggerHandlerMetadataReader,
+} from 'shared';
+import { EVENT_HUB_HANDLER_TYPE, EventHubHandlerMetadata, EventHubTriggerMetadata } from './decorators';
+
+@injectable()
+export class EventHubHandlerMetadataReader {
+  constructor(private readonly metadataReader: TriggerHandlerMetadataReader) {}
+
+  getHandlerClassMetadata(azureFunction: TriggerHandlerClass): EventHubHandlerMetadata {
+    const handlerClassMetadata = this.metadataReader.getHandlerClassMetadata(azureFunction);
+    if (handlerClassMetadata.type !== EVENT_HUB_HANDLER_TYPE) {
+      throw new TriggerHandlerMetadataError(
+        `Invalid type for handler class ${azureFunction.name}. Expected '${EVENT_HUB_HANDLER_TYPE}', but got '${handlerClassMetadata.type}'.`,
+      );
+    }
+    return handlerClassMetadata as EventHubHandlerMetadata;
+  }
+
+  getTriggerMetadata(azureFunction: TriggerHandlerClass, operation: string): EventHubTriggerMetadata {
+    const argsMetadata = Reflect.getOwnMetadata(FUNCTION_HANDLER_METADATA, azureFunction.prototype, operation);
+    if (argsMetadata === undefined) {
+      throw new TriggerHandlerMetadataError(
+        `No metadata found for operation ${operation} in handler class ${azureFunction.name}.`,
+      );
+    }
+    if (argsMetadata.type !== EVENT_HUB_HANDLER_TYPE) {
+      throw new TriggerHandlerMetadataError(
+        `Invalid type for operation ${operation} in handler class ${azureFunction.name}. Expected '${EVENT_HUB_HANDLER_TYPE}', but got '${argsMetadata.type}'.`,
+      );
+    }
+    return argsMetadata as EventHubTriggerMetadata;
+  }
+}