@geekmidas/constructs 0.0.1

package/src/functions/AWSLambdaFunction.ts

@@ -0,0 +1,222 @@
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import middy, { type MiddlewareObj } from '@middy/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Context, Handler } from 'aws-lambda';
+import type { Function, FunctionHandler } from './Function';
+import { FunctionBuilder } from './FunctionBuilder';
+
+import { wrapError } from '@geekmidas/errors';
+import type { EventPublisher } from '@geekmidas/events';
+import type { Logger } from '@geekmidas/logger';
+import type {
+  ComposableStandardSchema,
+  InferComposableStandardSchema,
+  InferStandardSchema,
+} from '@geekmidas/schema';
+import type { Service, ServiceRecord } from '@geekmidas/services';
+import { FunctionExecutionWrapper } from './FunctionExecutionWrapper';
+
+export type AWSLambdaHandler<TEvent = any, TResult = any> = Handler<
+  TEvent,
+  TResult
+>;
+
+type FunctionEvent<
+  TEvent,
+  TInput extends ComposableStandardSchema | undefined,
+  TServices extends Service[],
+  TLogger extends Logger,
+> = TEvent & {
+  parsedInput: InferComposableStandardSchema<TInput>;
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+};
+
+type Middleware<
+  TEvent,
+  TInput extends ComposableStandardSchema | undefined,
+  TServices extends Service[],
+  TLogger extends Logger,
+  TOutSchema extends StandardSchemaV1 | undefined,
+> = MiddlewareObj<
+  FunctionEvent<TEvent, TInput, TServices, TLogger>,
+  InferComposableStandardSchema<TOutSchema>,
+  Error,
+  Context
+>;
+
+export class AWSLambdaFunction<
+  TInput extends ComposableStandardSchema | undefined = undefined,
+  TOutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> extends FunctionExecutionWrapper<
+  TInput,
+  TOutSchema,
+  TServices,
+  TLogger,
+  TEventPublisher,
+  TEventPublisherServiceName
+> {
+  constructor(
+    envParser: EnvironmentParser<{}>,
+    readonly fn: Function<
+      TInput,
+      TServices,
+      TLogger,
+      TOutSchema,
+      FunctionHandler<TInput, TServices, TLogger, TOutSchema>,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ) {
+    super(envParser, fn);
+  }
+
+  private error<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema
+  > {
+    return {
+      onError: (req) => {
+        const logger = req.event?.logger || this.fn.logger;
+        logger.error(req.error || {}, 'Error processing function');
+
+        // Re-throw the wrapped error to let Lambda handle it
+        throw wrapError(req.error);
+      },
+    };
+  }
+
+  private baseInput<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema
+  > {
+    return {
+      before: (req) => {},
+    };
+  }
+
+  private input<
+    TEvent extends { input: InferComposableStandardSchema<TInput> },
+  >(): Middleware<TEvent, TInput, TServices, TLogger, TOutSchema> {
+    return {
+      before: async (req) => {
+        try {
+          // Parse input if schema is provided
+          if (this.fn.input) {
+            const parsedInput =
+              await FunctionBuilder.parseComposableStandardSchema(
+                req.event,
+                this.fn.input,
+              );
+
+            req.event.parsedInput =
+              parsedInput as InferComposableStandardSchema<TInput>;
+          } else {
+            // If no schema, pass the event as-is
+            req.event.parsedInput = req.event as any;
+          }
+        } catch (error) {
+          this.logger.error(
+            { error, event: req.event },
+            'Failed to parse input',
+          );
+          throw error;
+        }
+      },
+    };
+  }
+
+  private loggerMiddleware<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema
+  > {
+    return {
+      before: (req) => {
+        this._logger = this.fn.logger.child({
+          fn: {
+            name: req.context.functionName,
+            version: req.context.functionVersion,
+            memory: req.context.memoryLimitInMB,
+          },
+          req: {
+            id: req.context.awsRequestId,
+          },
+        }) as TLogger;
+
+        req.event.logger = this._logger;
+      },
+    };
+  }
+
+  private services<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema
+  > {
+    return {
+      before: async (req) => {
+        req.event.services = await this.getServices();
+      },
+    };
+  }
+
+  private events<TEvent>(): Middleware<
+    TEvent,
+    TInput,
+    TServices,
+    TLogger,
+    TOutSchema
+  > {
+    return {
+      after: async (req) => {
+        const response = (req.response ||
+          undefined) as InferStandardSchema<TOutSchema>;
+        await this.publishEvents(response);
+      },
+    };
+  }
+
+  private async _handler<TEvent>(
+    event: FunctionEvent<TEvent, TInput, TServices, TLogger>,
+  ) {
+    // Execute the function with the parsed context
+    const result = await this.fn['fn']({
+      input: event.parsedInput,
+      services: event.services,
+      logger: event.logger,
+    });
+
+    // Parse output if schema is provided
+    const output = await this.fn.parseOutput(result);
+
+    return output;
+  }
+
+  get handler(): AWSLambdaHandler {
+    const handler = this._handler.bind(this);
+
+    // Apply middleware in order
+    return middy(handler)
+      .use(this.loggerMiddleware())
+      .use(this.baseInput())
+      .use(this.error())
+      .use(this.services())
+      .use(this.input())
+      .use(this.events()) as unknown as AWSLambdaHandler;
+  }
+}

package/src/functions/BaseFunctionBuilder.ts

@@ -0,0 +1,110 @@
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import get from 'lodash.get';
+import { ConstructType } from '../Construct';
+
+import type { EventPublisher, MappedEvent } from '@geekmidas/events';
+import type {
+  ComposableStandardSchema,
+  InferComposableStandardSchema,
+} from '@geekmidas/schema';
+
+const DEFAULT_LOGGER = new ConsoleLogger() as any;
+
+export abstract class BaseFunctionBuilder<
+  TInput extends ComposableStandardSchema,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> {
+  protected inputSchema?: TInput;
+  protected outputSchema?: OutSchema;
+  protected _timeout?: number;
+
+  public _services: TServices = [] as Service[] as TServices;
+  public _logger: TLogger = DEFAULT_LOGGER;
+
+  protected _events: MappedEvent<TEventPublisher, OutSchema>[] = [];
+  protected _publisher?: Service<TEventPublisherServiceName, TEventPublisher>;
+
+  static isStandardSchemaV1(s: unknown): s is StandardSchemaV1 {
+    const schema = (s as StandardSchemaV1)['~standard'];
+
+    return schema && typeof schema.validate === 'function';
+  }
+
+  static async parseComposableStandardSchema<
+    T extends ComposableStandardSchema | undefined,
+  >(data: unknown, schema: T): Promise<InferComposableStandardSchema<T>> {
+    if (BaseFunctionBuilder.isStandardSchemaV1(schema)) {
+      const validated = await schema['~standard'].validate(data);
+
+      if (validated.issues) {
+        throw validated.issues;
+      }
+
+      return validated.value as InferComposableStandardSchema<T>;
+    }
+
+    const result: any = {};
+    for (const key in schema) {
+      const item = schema[key];
+      if (BaseFunctionBuilder.isStandardSchemaV1(item)) {
+        const value = get(data, key);
+        const validated = await item['~standard'].validate(value);
+
+        if (validated.issues) {
+          throw validated.issues;
+        }
+
+        result[key] = validated.value;
+      }
+    }
+
+    return result as InferComposableStandardSchema<T>;
+  }
+
+  constructor(public type = ConstructType.Function) {}
+
+  abstract services<T extends Service[]>(services: T): any;
+
+  abstract logger<T extends Logger>(logger: T): any;
+
+  timeout(timeout: number): this {
+    this._timeout = timeout;
+    return this;
+  }
+
+  abstract output<T extends StandardSchemaV1>(schema: T): any;
+
+  abstract input<T extends ComposableStandardSchema>(schema: T): any;
+
+  event<TEvent extends MappedEvent<TEventPublisher, OutSchema>>(
+    event: TEvent,
+  ): this {
+    this._events.push(event);
+    return this;
+  }
+
+  publisher<T extends EventPublisher<any>, TName extends string>(
+    publisher: Service<TName, T>,
+  ): BaseFunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName> {
+    this._publisher = publisher as unknown as Service<
+      TEventPublisherServiceName,
+      TEventPublisher
+    >;
+
+    return this as unknown as BaseFunctionBuilder<
+      TInput,
+      OutSchema,
+      TServices,
+      TLogger,
+      T,
+      TName
+    >;
+  }
+}

package/src/functions/Function.ts

@@ -0,0 +1,160 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import uniqBy from 'lodash.uniqby';
+
+import type { Service, ServiceRecord } from '@geekmidas/services';
+import { Construct, ConstructType } from '../Construct';
+
+import type { EventPublisher, MappedEvent } from '@geekmidas/events';
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type {
+  ComposableStandardSchema,
+  InferComposableStandardSchema,
+  InferStandardSchema,
+} from '@geekmidas/schema';
+
+import { UnprocessableEntityError } from '@geekmidas/errors';
+import { parseSchema } from '@geekmidas/schema/parser';
+
+const DEFAULT_LOGGER = new ConsoleLogger() as any;
+
+export class FunctionFactory<
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+> {
+  private defaultServices: TServices;
+  constructor(
+    defaultServices: TServices,
+    private defaultLogger: TLogger = DEFAULT_LOGGER,
+  ) {
+    // Initialize default services
+    this.defaultServices = uniqBy(
+      defaultServices,
+      (s) => s.serviceName,
+    ) as TServices;
+  }
+
+  // Create a new factory with services
+  services<S extends Service[]>(
+    services: S,
+  ): FunctionFactory<[...S, ...TServices], TLogger> {
+    return new FunctionFactory<[...S, ...TServices], TLogger>(
+      [...services, ...this.defaultServices],
+      this.defaultLogger,
+    );
+  }
+
+  logger<L extends Logger>(logger: L): FunctionFactory<TServices, L> {
+    return new FunctionFactory<TServices, L>(this.defaultServices, logger);
+  }
+}
+
+export class Function<
+  TInput extends ComposableStandardSchema | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+  Fn extends FunctionHandler<
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema
+  > = FunctionHandler<TInput, TServices, TLogger, OutSchema>,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> extends Construct<
+  TLogger,
+  TEventPublisherServiceName,
+  TEventPublisher,
+  OutSchema,
+  TServices
+> {
+  __IS_FUNCTION__ = true;
+
+  static isFunction(obj: any): obj is Function<any, any, any, any, any> {
+    return Boolean(
+      obj &&
+        obj.__IS_FUNCTION__ === true &&
+        obj.type === ConstructType.Function,
+    );
+  }
+
+  /**
+   * Validates data against a StandardSchema.
+   *
+   * @param schema - The StandardSchema to validate against
+   * @param data - The data to validate
+   * @returns Validation result with value or issues
+   */
+  static validate<T extends StandardSchemaV1>(schema: T, data: unknown) {
+    return schema['~standard'].validate(data);
+  }
+
+  /**
+   * Parses and validates data against a schema, throwing an error if validation fails.
+   *
+   * @param schema - The StandardSchema to validate against
+   * @param data - The data to parse and validate
+   * @returns The validated data with proper typing
+   * @throws {UnprocessableEntityError} When validation fails
+   */
+  static async parseSchema<T extends StandardSchemaV1>(
+    schema: T,
+    data: unknown,
+  ): Promise<InferStandardSchema<T>> {
+    try {
+      return await parseSchema(schema, data);
+    } catch (issues) {
+      throw new UnprocessableEntityError('Validation failed', issues);
+    }
+  }
+
+  /**
+   * Parses and validates the endpoint output against the output schema.
+   *
+   * @param output - The raw output data to validate
+   * @returns The validated output data
+   * @throws {UnprocessableEntityError} When output validation fails
+   */
+  async parseOutput(output: unknown): Promise<InferStandardSchema<OutSchema>> {
+    return Function.parseSchema(
+      this.outputSchema as StandardSchemaV1,
+      output,
+    ) as Promise<InferStandardSchema<OutSchema>>;
+  }
+
+  constructor(
+    protected readonly fn: Fn,
+    readonly timeout = 30000, // Default timeout of 30 seconds
+    type: ConstructType = ConstructType.Function,
+    public input?: TInput,
+    outputSchema?: OutSchema,
+    services: TServices = [] as unknown as TServices,
+    logger: TLogger = DEFAULT_LOGGER,
+    publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
+    events: MappedEvent<TEventPublisher, OutSchema>[] = [],
+  ) {
+    super(type, logger, services, events, publisherService, outputSchema);
+  }
+}
+
+export type FunctionHandler<
+  TInput extends ComposableStandardSchema | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+> = (
+  ctx: FunctionContext<TInput, TServices, TLogger>,
+) => OutSchema extends StandardSchemaV1
+  ? InferStandardSchema<OutSchema> | Promise<InferStandardSchema<OutSchema>>
+  : any | Promise<any>;
+
+export type FunctionContext<
+  Input extends ComposableStandardSchema | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+> = {
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+  input: InferComposableStandardSchema<Input>;
+};

package/src/functions/FunctionBuilder.ts

@@ -0,0 +1,182 @@
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import type { Service } from '@geekmidas/services';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import uniqBy from 'lodash.uniqby';
+import { ConstructType } from '../Construct';
+import { BaseFunctionBuilder } from './BaseFunctionBuilder';
+import { Function, type FunctionHandler } from './Function';
+
+import type { EventPublisher } from '@geekmidas/events';
+import type { ComposableStandardSchema } from '@geekmidas/schema';
+
+const DEFAULT_LOGGER = new ConsoleLogger() as any;
+
+export class FunctionBuilder<
+  TInput extends ComposableStandardSchema,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> extends BaseFunctionBuilder<
+  TInput,
+  OutSchema,
+  TServices,
+  TLogger,
+  TEventPublisher,
+  TEventPublisherServiceName
+> {
+  constructor(public type = ConstructType.Function) {
+    super(type);
+  }
+
+  timeout(timeout: number): this {
+    this._timeout = timeout;
+    return this;
+  }
+
+  output<T extends StandardSchemaV1>(
+    schema: T,
+  ): FunctionBuilder<
+    TInput,
+    T,
+    TServices,
+    TLogger,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this.outputSchema = schema as unknown as OutSchema;
+
+    return this as unknown as FunctionBuilder<
+      TInput,
+      T,
+      TServices,
+      TLogger,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  input<T extends ComposableStandardSchema>(
+    schema: T,
+  ): FunctionBuilder<
+    T,
+    OutSchema,
+    TServices,
+    TLogger,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this.inputSchema = schema as unknown as TInput;
+
+    return this as unknown as FunctionBuilder<
+      T,
+      OutSchema,
+      TServices,
+      TLogger,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  services<T extends Service[]>(
+    services: T,
+  ): FunctionBuilder<
+    TInput,
+    OutSchema,
+    [...TServices, ...T],
+    TLogger,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this._services = uniqBy(
+      [...this._services, ...services],
+      (s) => s.serviceName,
+    ) as TServices;
+
+    return this as unknown as FunctionBuilder<
+      TInput,
+      OutSchema,
+      [...TServices, ...T],
+      TLogger,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  logger<T extends Logger>(
+    logger: T,
+  ): FunctionBuilder<
+    TInput,
+    OutSchema,
+    TServices,
+    T,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    this._logger = logger as unknown as TLogger;
+
+    return this as unknown as FunctionBuilder<
+      TInput,
+      OutSchema,
+      TServices,
+      T,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >;
+  }
+
+  publisher<T extends EventPublisher<any>, TName extends string>(
+    publisher: Service<TName, T>,
+  ): FunctionBuilder<TInput, OutSchema, TServices, TLogger, T, TName> {
+    this._publisher = publisher as unknown as Service<
+      TEventPublisherServiceName,
+      TEventPublisher
+    >;
+
+    return this as unknown as FunctionBuilder<
+      TInput,
+      OutSchema,
+      TServices,
+      TLogger,
+      T,
+      TName
+    >;
+  }
+
+  handle(
+    fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>,
+  ): Function<
+    TInput,
+    TServices,
+    TLogger,
+    OutSchema,
+    FunctionHandler<TInput, TServices, TLogger, OutSchema>,
+    TEventPublisher,
+    TEventPublisherServiceName
+  > {
+    const func = new Function(
+      fn,
+      this._timeout,
+      this.type,
+      this.inputSchema,
+      this.outputSchema,
+      this._services,
+      this._logger,
+      this._publisher,
+      this._events,
+    );
+
+    // Reset builder state after creating the function to prevent pollution
+    this._services = [] as Service[] as TServices;
+    this._logger = DEFAULT_LOGGER;
+    this._events = [];
+    this._publisher = undefined;
+    this.inputSchema = undefined;
+    this.outputSchema = undefined;
+    this._timeout = undefined;
+
+    return func;
+  }
+}