@herrromich/az-functions 1.0.0

package/src/logger/logger.utils.ts

@@ -0,0 +1,264 @@
+import { HttpRequest, HttpResponse } from '@azure/functions';
+import { PlatformContextManager } from 'context';
+import { AzFunctionsError } from 'shared';
+import { ZodType } from 'zod';
+import { CONTEXT_LOGGER_METADATA, ContextLoggerMetadata, LogLevel } from './logger.model';
+
+export type AnyValueScalar = string | number | boolean;
+export type AnyValueArray = AnyValue[];
+export interface AnyValueMap {
+  [attributeKey: string]: AnyValue;
+}
+export type AnyValue = AnyValueScalar | Uint8Array | AnyValueArray | AnyValueMap | null | undefined;
+
+const MAX_DEPTH = 5;
+const MAX_TRACE_LENGTH = 10;
+const MAX_ARRAY_LENGTH = 20;
+const MAX_KEYS_COUNT = 20;
+const MAX_STRING_LENGTH = 250;
+
+export interface SanitizerOptions {
+  maxDepth?: number;
+  maxTraceLength?: number;
+  maxArrayLength?: number;
+  maxKeysCount?: number;
+  maxStringLength?: number;
+}
+
+function sanitizeHeaders(headers: Headers) {
+  return Array.from(headers.entries()).reduce<Record<string, string>>((acc, [key, val]) => {
+    if (!['authorization', 'cookie', 'x-ms'].some(prefix => key.toLowerCase().startsWith(prefix))) {
+      acc[key] = val;
+    } else {
+      acc[key] = '[REDACTED]';
+    }
+    return acc;
+  }, {});
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getZodCheckDef(value: any): object | undefined {
+  const def = value?._zod?.def;
+  if (typeof def === 'object' && def !== null && 'check' in def && typeof def.check === 'string') {
+    return def;
+  }
+  return undefined;
+}
+
+interface SanitizeContext {
+  limits: Required<SanitizerOptions>;
+  objectsStack: WeakSet<object>;
+  sanitize: (value: unknown, depth: number) => AnyValue;
+}
+
+function truncateList(items: AnyValue[], maxArrayLength: number): AnyValue[] {
+  return items.length > maxArrayLength
+    ? [...items.slice(0, maxArrayLength), `... more ${items.length - maxArrayLength} items`]
+    : items;
+}
+
+function truncateEntries(entries: (readonly [string, AnyValue])[], maxKeysCount: number): AnyValueMap {
+  if (entries.length > maxKeysCount) {
+    return {
+      ...Object.fromEntries(entries.slice(0, maxKeysCount)),
+      __meta__: {
+        truncated: true,
+        totalKeys: entries.length,
+        omittedKeys: entries.length - maxKeysCount,
+      },
+    };
+  }
+  return Object.fromEntries(entries);
+}
+
+function sanitizeError(error: Error, depth: number, ctx: SanitizeContext): AnyValue {
+  if (depth > ctx.limits.maxDepth) {
+    return `[Error<${error.name}>]`;
+  }
+  const stackLines = error.stack?.split('\n');
+  const { maxTraceLength } = ctx.limits;
+  return {
+    name: error.name,
+    message: error.message,
+    ...(stackLines
+      ? {
+          stack:
+            stackLines.length > maxTraceLength
+              ? [...stackLines.slice(0, maxTraceLength), `... more ${stackLines.length - maxTraceLength} lines`].join(
+                  '\n',
+                )
+              : error.stack,
+        }
+      : {}),
+    ...(error.cause ? { cause: ctx.sanitize(error.cause, depth + 1) } : {}),
+    ...(error instanceof AzFunctionsError ? { details: ctx.sanitize(error.details, depth + 1) } : {}),
+  };
+}
+
+function sanitizeRequest(value: HttpRequest, depth: number, ctx: SanitizeContext): AnyValue {
+  if (depth > ctx.limits.maxDepth) {
+    return '[HttpRequest]';
+  }
+  const headers = sanitizeHeaders(value.headers);
+  const contentLength = headers['content-length'];
+  return {
+    method: value.method,
+    url: value.url,
+    headers,
+    query: Object.fromEntries(value.query.entries()),
+    params: value.params,
+    ...(contentLength ? { body: `[RequestBody<${contentLength}Byte>]` } : {}),
+  };
+}
+
+function sanitizeResponse(value: HttpResponse, depth: number, ctx: SanitizeContext): AnyValue {
+  if (depth > ctx.limits.maxDepth) {
+    return '[HttpResponse]';
+  }
+  const headers = sanitizeHeaders(value.headers);
+  const contentLength = headers['content-length'];
+  return {
+    status: value.status,
+    headers,
+    ...(contentLength ? { body: `[ResponseBody<${contentLength}>Bytes]` } : {}),
+  };
+}
+
+function sanitizeCollection(
+  value: unknown[] | Map<unknown, unknown> | Set<unknown>,
+  depth: number,
+  ctx: SanitizeContext,
+): AnyValue {
+  const { maxDepth, maxArrayLength, maxKeysCount } = ctx.limits;
+
+  if (Array.isArray(value)) {
+    if (depth > maxDepth) return `[Array<${value.length}>]`;
+    if (value.length === 0) return '[empty Array]';
+    return truncateList(
+      value.map(v => ctx.sanitize(v, depth + 1)),
+      maxArrayLength,
+    );
+  }
+
+  if (value instanceof Map) {
+    if (depth > maxDepth) return `[Map<${value.size}>]`;
+    if (value.size === 0) return '[empty map]';
+    const entries = [...value.entries()].map(([k, v]) => [String(k), ctx.sanitize(v, depth + 1)] as const);
+    return truncateEntries(entries, maxKeysCount);
+  }
+
+  // Set
+  if (depth > maxDepth) return `[Set<${value.size}>]`;
+  if (value.size === 0) return '[empty set]';
+  return truncateList(
+    [...value].map(v => ctx.sanitize(v, depth + 1)),
+    maxArrayLength,
+  );
+}
+
+function sanitizeObject(value: object, depth: number, ctx: SanitizeContext): AnyValue {
+  const objectName = value.constructor.name;
+  if (depth > ctx.limits.maxDepth) return `[${objectName}]`;
+  if (Object.keys(value).length === 0) return `[empty ${objectName}]`;
+  if (ctx.objectsStack.has(value)) return '[Circular]';
+
+  ctx.objectsStack.add(value);
+  const entries = truncateEntries(
+    Object.entries(value).map(([k, v]) => [k, ctx.sanitize(v, depth + 1)] as const),
+    ctx.limits.maxKeysCount,
+  );
+  ctx.objectsStack.delete(value);
+  return entries;
+}
+
+function sanitizePrimitive(value: unknown, maxStringLength: number): AnyValue | typeof UNHANDLED {
+  if (value === undefined || value === null || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'string') {
+    return value.length > maxStringLength ? `${value.slice(0, maxStringLength)}...` : value;
+  }
+  if (typeof value === 'symbol') {
+    return `[Symbol(${value.description})]`;
+  }
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  return UNHANDLED;
+}
+
+const UNHANDLED = Symbol('unhandled');
+
+export function sanitizeMetadata(metadata: unknown, options?: SanitizerOptions): AnyValueMap {
+  const ctx: SanitizeContext = {
+    limits: {
+      maxDepth: options?.maxDepth ?? MAX_DEPTH,
+      maxTraceLength: options?.maxTraceLength ?? MAX_TRACE_LENGTH,
+      maxArrayLength: options?.maxArrayLength ?? MAX_ARRAY_LENGTH,
+      maxKeysCount: options?.maxKeysCount ?? MAX_KEYS_COUNT,
+      maxStringLength: options?.maxStringLength ?? MAX_STRING_LENGTH,
+    },
+    objectsStack: new WeakSet(),
+    sanitize: (value, depth) => sanitize(value, depth),
+  };
+
+  function sanitize(value: unknown, depth: number): AnyValue {
+    const primitive = sanitizePrimitive(value, ctx.limits.maxStringLength);
+    if (primitive !== UNHANDLED) {
+      return primitive;
+    }
+
+    if (value instanceof ZodType) {
+      return sanitize(value.def, depth + 1);
+    }
+    const zodCheckDef = getZodCheckDef(value);
+    if (zodCheckDef !== undefined) {
+      return sanitize(zodCheckDef, depth + 1);
+    }
+
+    if (Array.isArray(value) || value instanceof Map || value instanceof Set) {
+      return sanitizeCollection(value, depth, ctx);
+    }
+    if (value instanceof Error) {
+      return sanitizeError(value, depth, ctx);
+    }
+    if (value instanceof HttpRequest) {
+      return sanitizeRequest(value, depth, ctx);
+    }
+    if (value instanceof HttpResponse) {
+      return sanitizeResponse(value, depth, ctx);
+    }
+    if (typeof value === 'object' && value !== null) {
+      return sanitizeObject(value, depth, ctx);
+    }
+
+    return undefined;
+  }
+
+  return sanitize(metadata, 1) as AnyValueMap;
+}
+
+export function adjustContextLoggerMetadata(contextManager: PlatformContextManager, metadata: ContextLoggerMetadata) {
+  const currentContext = contextManager.active();
+  if (currentContext === undefined) {
+    return;
+  }
+  const existingMetadata = currentContext.getValue(CONTEXT_LOGGER_METADATA) ?? {};
+  const newMetadata: ContextLoggerMetadata = { ...existingMetadata };
+
+  for (const level in metadata) {
+    const typedLevel = level as LogLevel;
+    newMetadata[typedLevel] = {
+      ...newMetadata[typedLevel],
+      ...metadata[typedLevel],
+    };
+  }
+
+  currentContext.setValue(CONTEXT_LOGGER_METADATA, newMetadata);
+}

package/src/logger/otel.logger.ts

@@ -0,0 +1,91 @@
+import { ROOT_CONTEXT, trace } from '@opentelemetry/api';
+import { AnyValueMap, SeverityNumber } from '@opentelemetry/api-logs';
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { inject, injectable } from 'inversify';
+import { LOGGER_PROVIDER, LogLevel, PlatformLogInfo } from './logger.model';
+
+const LOG_LEVEL_SEVERITY_MAP: Record<LogLevel, { severityNumber: SeverityNumber; severityText: string }> = {
+  error: {
+    severityNumber: SeverityNumber.ERROR,
+    severityText: 'error',
+  },
+  warn: {
+    severityNumber: SeverityNumber.WARN,
+    severityText: 'warn',
+  },
+  info: {
+    severityNumber: SeverityNumber.INFO,
+    severityText: 'info',
+  },
+  http: {
+    severityNumber: SeverityNumber.INFO2,
+    severityText: 'http',
+  },
+  verbose: {
+    severityNumber: SeverityNumber.INFO3,
+    severityText: 'verbose',
+  },
+  debug: {
+    severityNumber: SeverityNumber.DEBUG,
+    severityText: 'debug',
+  },
+  silly: {
+    severityNumber: SeverityNumber.TRACE,
+    severityText: 'silly',
+  },
+};
+
+const TraceParentRegex = /^\d{2}-([0-9a-z]+)-([0-9a-z]+)-\d{2}$/;
+
+@injectable()
+export class OtelLogger {
+  constructor(@inject(LOGGER_PROVIDER) private readonly loggerProvider: LoggerProvider) {}
+
+  log(logInfo: PlatformLogInfo): void {
+    const traceContextValues = this.decodeTraceContext(logInfo);
+    let context;
+    if (traceContextValues !== undefined) {
+      context = trace.setSpanContext(ROOT_CONTEXT, {
+        traceId: traceContextValues.operationId,
+        spanId: traceContextValues.operationParentId,
+        traceFlags: 1,
+      });
+    }
+    const logger = this.loggerProvider.getLogger('default');
+    logger.emit({
+      timestamp: logInfo.timestamp,
+      ...LOG_LEVEL_SEVERITY_MAP[logInfo.level],
+      body: logInfo.message,
+      context,
+      attributes: this.getCustomDimensions(logInfo),
+    });
+  }
+
+  private decodeTraceContext(logInfo: PlatformLogInfo): { operationId: string; operationParentId: string } | undefined {
+    const { traceContext } = logInfo;
+    if (traceContext !== undefined) {
+      const traceParent = traceContext.traceParent;
+      const traceParentParts = traceParent !== undefined ? TraceParentRegex.exec(traceParent) : null;
+      if (traceParentParts !== null && traceParentParts.length >= 3) {
+        const operationId = traceParentParts[1]!;
+        const operationParentId = traceParentParts[2]!;
+        return { operationId, operationParentId };
+      }
+    }
+  }
+
+  private getCustomDimensions(logInfo: PlatformLogInfo): AnyValueMap {
+    const { level, loggerName, invocationId, traceContext, metadata } = logInfo;
+    const severity = LOG_LEVEL_SEVERITY_MAP[level].severityText;
+    return {
+      LogLevel: severity,
+      Category: traceContext?.attributes?.Category,
+      HostInstanceId: traceContext?.attributes?.HostInstanceId,
+      ProcessId: traceContext?.attributes?.ProcessId ?? process.pid,
+      InvocationId: invocationId,
+      LoggerName: loggerName,
+      ...(metadata !== undefined && Object.getOwnPropertyNames(metadata).length > 0 ? { Metadata: metadata } : {}),
+      ...traceContext?.attributes,
+    };
+  }
+}

package/src/logger/trie-search.service.ts

@@ -0,0 +1,177 @@
+interface TrieNode<T> {
+  children: Record<string, TrieNode<T>>;
+  value?: T;
+}
+
+interface TraverseResult<T> {
+  part: string;
+  name: string;
+  parentNode?: TraverseResult<T>;
+  trieNode: TrieNode<T>;
+}
+
+/**
+ * A service that provides a trie data structure for searching and storing values associated with string keys.
+ *
+ * This class can be used for providing of log levels for loggers based on their names, where the logger names are structured in a hierarchical manner using a separator (e.g., '.').
+ *
+ * @template T - The type of values stored in the trie.
+ *
+ * @example
+ * export class TrieSearchLogLevelProvider implements LogLevelProvider {
+ *   private readonly trieSearchService: TrieSearchService<LogLevel>;
+ *
+ *   constructor(@inject(DEFAULT_LOG_LEVEL) @optional() defaultLogLevel: LogLevel) {
+ *     this.trieSearchService = new TrieSearchService('.', defaultLogLevel);
+ *     this.trieSearchService.set(SYSTEM_LOGGER_NAME_PREFIX, 'silly');
+ *     this.trieSearchService.set(PERSISTENCE_KYSELY_LOGGER_NAME, 'error');
+ *   }
+ *
+ *   getLogLevel(loggerName: string | undefined): LogLevel | undefined {
+ *     return this.trieSearchService.find(loggerName);
+ *   }
+ * }
+ */
+export class TrieSearchService<T> {
+  private readonly root: Required<TrieNode<T>>;
+
+  /**
+   * Creates an instance of TrieSearchService.
+   *
+   * @param trieSeparator - The separator used to split the keys into parts for the trie structure.
+   * @param rootValue - The value associated with the root of the trie.
+   */
+  constructor(
+    private readonly trieSeparator: string,
+    rootValue: T,
+  ) {
+    this.root = { children: {}, value: rootValue };
+  }
+
+  /**
+   * Retrieves all key-value pairs in the trie that match the specified prefix.
+   *
+   * @param prefix - An optional prefix to filter the keys. If provided, only keys starting with this prefix will be included in the result.
+   * @returns A record containing all matching key-value pairs.
+   */
+  getAll(prefix?: string): Record<string, T> {
+    const traverseResult = this.traverse(prefix);
+    if (traverseResult.name === (prefix ?? '')) {
+      return this.getAllChildren(traverseResult.trieNode, traverseResult.name);
+    } else {
+      return {};
+    }
+  }
+
+  private getAllChildren(node: TrieNode<T>, name: string): Record<string, T> {
+    const result: Record<string, T> = node.value !== undefined ? { [name]: node.value } : {};
+    const keys = Object.keys(node.children);
+    keys.sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+      const childNode = node.children[key]!;
+      const childName = name ? `${name}${this.trieSeparator}${key}` : key;
+      Object.assign(result, this.getAllChildren(childNode, childName));
+    }
+    return result;
+  }
+
+  /**
+   * Finds the value associated with the longest matching prefix of the specified key in the trie.
+   *
+   * @param key - The key to search for in the trie. If undefined, the root value will be returned.
+   * @returns The value associated with the longest matching prefix of the key, or undefined if no match is found.
+   */
+  find(key: string | undefined): T {
+    let traverseResult = this.traverse(key ?? '');
+    let result = traverseResult.trieNode.value;
+    while (result === undefined && traverseResult.parentNode !== undefined) {
+      traverseResult = traverseResult.parentNode;
+      result = traverseResult.trieNode.value;
+    }
+    return result!;
+  }
+
+  /**
+   * Retrieves the value associated with the specified key in the trie.
+   *
+   * @param key - The key to search for in the trie.
+   * @returns The value associated with the key, or undefined if the key is not found.
+   */
+  get(key: string): T | undefined {
+    const traverseResult = this.traverse(key);
+    if (traverseResult.name === key) {
+      return traverseResult.trieNode.value;
+    }
+  }
+
+  /**
+   * Sets the value associated with the specified key in the trie. If the value is undefined, the key will be removed from the trie.
+   *
+   * @param key - The key to set or remove in the trie.
+   * @param value - The value to associate with the key. If undefined, the key will be removed.
+   */
+  set(key: string, value?: T): void {
+    const traverseResult = this.traverse(key);
+
+    if (value !== undefined) {
+      const prefix = traverseResult.name;
+      const restKey = prefix && key.startsWith(prefix) ? key.substring(traverseResult.name.length + 1) : key;
+      this.concatNodes(traverseResult.trieNode, restKey, value);
+    } else {
+      if (traverseResult.name === key) {
+        delete traverseResult.trieNode.value;
+      }
+      this.removeNodes(traverseResult);
+    }
+  }
+
+  private traverse(key?: string): TraverseResult<T> {
+    const parts = key ? key.split(this.trieSeparator) : [];
+    let currentNode: TrieNode<T> = this.root;
+    let traverseResult: TraverseResult<T> = { part: '', name: '', trieNode: currentNode };
+
+    for (const part of parts) {
+      if (currentNode.children?.[part] === undefined) {
+        break;
+      }
+      currentNode = currentNode.children[part];
+      const name = traverseResult.name ? `${traverseResult.name}${this.trieSeparator}${part}` : part;
+      traverseResult = {
+        part,
+        name,
+        parentNode: traverseResult,
+        trieNode: currentNode,
+      };
+    }
+    return traverseResult;
+  }
+
+  private concatNodes(node: TrieNode<T>, restKey: string, value: T) {
+    const parts = restKey ? restKey.split(this.trieSeparator) : [];
+    let currentNode = node;
+    for (const part of parts) {
+      const child = {
+        children: {},
+      };
+      currentNode.children[part] = child;
+      currentNode = child;
+    }
+    currentNode.value = value;
+  }
+
+  private removeNodes(traverseResult: TraverseResult<T>) {
+    let currentNode = traverseResult.trieNode;
+    let part: string | undefined;
+    while (traverseResult.parentNode) {
+      if (currentNode.children && Object.keys(currentNode.children).length > 0) {
+        break;
+      }
+      currentNode = traverseResult.trieNode;
+      part = traverseResult.part;
+      traverseResult = traverseResult.parentNode;
+      if (currentNode.value === undefined) {
+        delete currentNode.children[part];
+      }
+    }
+  }
+}

package/src/middleware.ts

@@ -0,0 +1,49 @@
+import { OpenApiPrintService, OpenApiRegistrationService } from 'http-controller';
+import { Container } from 'inversify';
+import { LOGGER_FACTORY, SYSTEM_LOGGER_NAME_PREFIX } from 'logger';
+import { AzurePlatform, PlatformConfiguration } from 'platform';
+import { platformModeSchema } from 'shared';
+import { createContainers } from './framework.container';
+
+function registerOpenApi(frameworkContainer: Container, config: PlatformConfiguration) {
+  const openApiRegistrationService = frameworkContainer.get(OpenApiRegistrationService);
+  openApiRegistrationService.register({
+    triggerHandlerClasses: config.triggerHandlerClasses,
+    restApplications: config.restApplications,
+  });
+}
+
+/**
+ * Starts the platform based on the provided configuration and the current platform mode.
+ *
+ * The function initializes the necessary containers and services, and then either prints the OpenAPI specification or starts the platform with the registered trigger handlers.
+ * @param config The platform configuration.
+ * @returns The platform container.
+ */
+export function startPlatform(config: PlatformConfiguration): Container {
+  const platformMode = platformModeSchema.parse(process.env.PLATFORM_MODE);
+  const { frameworkContainer, platformContainer } = createContainers(config.loggerConfiguration);
+  const loggerFactory = frameworkContainer.get(LOGGER_FACTORY);
+  const logger = loggerFactory(`${SYSTEM_LOGGER_NAME_PREFIX}.platform`);
+  logger.info(`Starting platform in mode: ${platformMode}`);
+  try {
+    switch (platformMode) {
+      case 'print-open-api': {
+        registerOpenApi(frameworkContainer, config);
+        frameworkContainer.get(OpenApiPrintService).printOpenApi();
+        break;
+      }
+      case 'start': {
+        platformContainer.loadSync(...config.modules);
+        registerOpenApi(frameworkContainer, config);
+        const azurePlatform = frameworkContainer.get(AzurePlatform);
+        azurePlatform.start(config.triggerHandlerClasses);
+        break;
+      }
+    }
+  } catch (error) {
+    logger.error('Error occurred while starting the platform', error);
+    throw error;
+  }
+  return platformContainer;
+}

package/src/platform/azure-platform.ts

@@ -0,0 +1,57 @@
+import { app } from '@azure/functions';
+import { SwaggerHandlingService } from 'http-controller';
+import { Container, inject, injectable } from 'inversify';
+import { LOGGER_FACTORY, LoggerFactory } from 'logger';
+import { PLATFORM_CONTAINER, TriggerHandlerClass } from 'shared';
+import { REGISTER_TRIGGER_HANDLER_FACTORY, RegisterTriggerHandlerFactory } from './register-trigger-handler.factory';
+import { STARTUP_SERVICE } from './startup.service';
+
+@injectable()
+export class AzurePlatform {
+  private readonly logger;
+
+  constructor(
+    @inject(LOGGER_FACTORY) loggerFactory: LoggerFactory,
+    @inject(PLATFORM_CONTAINER) private readonly platformContainer: Container,
+    @inject(REGISTER_TRIGGER_HANDLER_FACTORY) private readonly registerHandler: RegisterTriggerHandlerFactory,
+    private readonly swaggerHandlingService: SwaggerHandlingService,
+  ) {
+    this.logger = loggerFactory();
+  }
+
+  start(triggerHandlerClasses: TriggerHandlerClass[]) {
+    this.logger.info('Starting Azure platform');
+    this.registerStartupService();
+    this.registerSwaggerUi();
+    triggerHandlerClasses.forEach(azureFunctionType => {
+      this.registerHandler(azureFunctionType);
+    });
+    this.logger.info('Azure platform started');
+  }
+
+  private registerStartupService(): void {
+    this.logger.info('Registering startup service');
+    const startupService = this.platformContainer.get(STARTUP_SERVICE, { optional: true });
+    if (startupService !== undefined) {
+      app.hook.appStart(async () => {
+        await startupService.startup();
+      });
+      this.logger.info('Startup service registered');
+    } else {
+      this.logger.info('No startup service found');
+    }
+  }
+
+  private registerSwaggerUi() {
+    this.logger.info('Registering Swagger UI endpoints');
+    app.get('swaggerUi', {
+      route: 'spec/{fileName?}',
+      handler: async request => await this.swaggerHandlingService.handleSwaggerContent(request),
+    });
+    app.get('openApiDefinition', {
+      route: 'spec/definition/{definitionName}',
+      handler: request => this.swaggerHandlingService.handleOpenApiDefinition(request),
+    });
+    this.logger.info('Swagger UI endpoints registered');
+  }
+}

package/src/platform/index.ts

@@ -0,0 +1,18 @@
+import { ContainerModule } from 'inversify';
+import { LOGGER_NAME_PROVIDER } from 'logger';
+import { AzurePlatform } from './azure-platform';
+import {
+  REGISTER_TRIGGER_HANDLER_FACTORY,
+  bindRegisterTriggerHandlerFactory,
+} from './register-trigger-handler.factory';
+import { systemLoggerNameProvider } from './system-logger-name.provider';
+
+export * from './azure-platform';
+export * from './model';
+export { IStartupService, STARTUP_SERVICE } from './startup.service';
+
+export const PlatformModule = new ContainerModule(options => {
+  options.bind(AzurePlatform).toSelf();
+  options.bind(REGISTER_TRIGGER_HANDLER_FACTORY).toFactory(bindRegisterTriggerHandlerFactory);
+  options.bind(LOGGER_NAME_PROVIDER).toFactory(() => systemLoggerNameProvider);
+});

package/src/platform/model.ts

@@ -0,0 +1,19 @@
+import { RestApplication } from 'http-controller';
+import { ContainerModule } from 'inversify';
+import { LoggerConfiguration } from 'logger';
+import { TriggerHandlerClass } from 'shared';
+
+/**
+ * Represents the configuration for the platform, including trigger handlers, REST applications, modules, and optional logger configuration.
+ *
+ * @property triggerHandlerClasses The trigger handler classes to be registered with the platform.
+ * @property restApplications Optional REST applications to be registered with the platform.
+ * @property modules The container modules to be loaded into the platform container.
+ * @property loggerConfiguration Optional logger configuration for the platform.
+ */
+export interface PlatformConfiguration {
+  triggerHandlerClasses: TriggerHandlerClass[];
+  restApplications?: RestApplication[];
+  modules: ContainerModule[];
+  loggerConfiguration?: LoggerConfiguration;
+}