@geekmidas/constructs 0.0.1

package/src/__tests__/publisher.spec.ts

@@ -0,0 +1,454 @@
+import type { Logger } from '@geekmidas/logger';
+import { type Service, ServiceDiscovery } from '@geekmidas/services';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
+import { e } from '../endpoints';
+import { publishConstructEvents } from '../publisher';
+
+// Test event types
+type TestEvent =
+  | PublishableMessage<'user.created', { userId: string; email: string }>
+  | PublishableMessage<'user.updated', { userId: string; changes: string[] }>
+  | PublishableMessage<'user.deleted', { userId: string }>;
+
+describe('publishEndpointEvents', () => {
+  const mockLogger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn(() => mockLogger),
+  };
+  const debugSpy = mockLogger.debug as any;
+  const warnSpy = mockLogger.warn as any;
+  const errorSpy = mockLogger.error as any;
+
+  const serviceDiscovery = ServiceDiscovery.getInstance(
+    mockLogger,
+    new EnvironmentParser({}),
+  );
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return early when no events are defined', async () => {
+    const endpoint = e
+      .logger(mockLogger)
+      .post('/test')
+      .output(z.object({ success: z.boolean() }))
+      .handle(async () => ({ success: true }));
+
+    await publishConstructEvents(
+      endpoint,
+      { success: true },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(debugSpy).toHaveBeenCalledWith('No events to publish');
+  });
+
+  it('should return early when events array is empty', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn(),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(z.object({ success: z.boolean() }))
+      .handle(async () => ({ success: true }));
+
+    await publishConstructEvents(
+      endpoint,
+      { success: true },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(debugSpy).toHaveBeenCalledWith('No events to publish');
+    expect(mockPublisher.publish).not.toHaveBeenCalled();
+  });
+
+  it('should warn when publisher is not available', async () => {
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .post('/test')
+      .output(outputSchema)
+
+      .event({
+        // @ts-ignore
+        type: 'user.created',
+        // @ts-ignore
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(warnSpy).toHaveBeenCalledWith('No publisher service available');
+  });
+
+  it('should publish single event successfully', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(debugSpy).toHaveBeenCalledWith(
+      { event: 'user.created' },
+      'Processing event',
+    );
+    expect(debugSpy).toHaveBeenCalledWith(
+      { eventCount: 1 },
+      'Publishing events',
+    );
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '123', email: 'test@example.com' },
+      },
+    ]);
+  });
+
+  it('should publish multiple events successfully', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .publisher(mockPublisherService)
+
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+      })
+      .event({
+        type: 'user.updated',
+        payload: (response) => ({ userId: response.id, changes: ['email'] }),
+      })
+
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '123', email: 'test@example.com' },
+      },
+      {
+        type: 'user.updated',
+        payload: { userId: '123', changes: ['email'] },
+      },
+    ]);
+  });
+
+  it('should respect when condition for events', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({
+      id: z.string(),
+      email: z.string(),
+      isNew: z.boolean(),
+    });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+        when: (response) => response.isNew === true,
+      })
+      .event({
+        type: 'user.updated',
+        payload: (response) => ({ userId: response.id, changes: ['email'] }),
+        when: (response) => response.isNew === false,
+      })
+      .handle(async () => ({
+        id: '123',
+        email: 'test@example.com',
+        isNew: false,
+      }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+        isNew: false,
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    // Only the user.updated event should be published
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.updated',
+        payload: { userId: '123', changes: ['email'] },
+      },
+    ]);
+  });
+
+  it('should not publish any events when all when conditions are false', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+        when: () => false,
+      })
+      .event({
+        type: 'user.updated',
+        payload: (response) => ({ userId: response.id, changes: ['email'] }),
+        when: () => false,
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(mockPublisher.publish).not.toHaveBeenCalled();
+  });
+
+  it('should handle async payload functions', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          // Simulate async operation
+          userId: response.id,
+          email: response.email,
+        }),
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '123', email: 'test@example.com' },
+      },
+    ]);
+  });
+
+  it('should catch and log publish errors', async () => {
+    const publishError = new Error('Failed to connect to event bus');
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockRejectedValue(publishError),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    // Should not throw
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      publishError,
+      'Failed to publish events',
+    );
+  });
+
+  it('should preserve additional event properties', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = e
+      .logger(mockLogger)
+      .publisher(mockPublisherService)
+      .post('/test')
+      .output(outputSchema)
+      .event({
+        type: 'user.created',
+        payload: (response) => ({
+          userId: response.id,
+          email: response.email,
+        }),
+        // Additional properties that should be preserved
+        metadata: { source: 'api', version: '1.0' },
+        priority: 'high',
+      })
+      .handle(async () => ({ id: '123', email: 'test@example.com' }));
+
+    await publishConstructEvents(
+      endpoint,
+      {
+        id: '123',
+        email: 'test@example.com',
+      },
+      serviceDiscovery as ServiceDiscovery<any, any>,
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '123', email: 'test@example.com' },
+        metadata: { source: 'api', version: '1.0' },
+        priority: 'high',
+      },
+    ]);
+  });
+});

package/src/adaptors/aws.ts

@@ -0,0 +1,4 @@
+export { AmazonApiGatewayV1Endpoint } from '../endpoints/AmazonApiGatewayV1EndpointAdaptor';
+export { AmazonApiGatewayV2Endpoint } from '../endpoints/AmazonApiGatewayV2EndpointAdaptor';
+export { AWSLambdaFunction } from '../functions/AWSLambdaFunction';
+export { AWSLambdaSubscriber } from '../subscribers/AWSLambdaSubscriberAdaptor';

package/src/adaptors/hono.ts

@@ -0,0 +1 @@
+export { HonoEndpoint } from '../endpoints/HonoEndpointAdaptor';

package/src/crons/Cron.ts

@@ -0,0 +1,137 @@
+import type { Logger } from '@geekmidas/logger';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import { ConstructType } from '../Construct';
+import { Function, type FunctionHandler } from '../functions';
+
+import type { EventPublisher } from '@geekmidas/events';
+import type { ComposableStandardSchema } from '@geekmidas/schema';
+import type { Service } from '@geekmidas/services';
+
+export class Cron<
+  TInput extends ComposableStandardSchema | undefined = undefined,
+  TServices extends Service[] = [],
+  TLogger extends Logger = Logger,
+  OutSchema extends StandardSchemaV1 | undefined = undefined,
+  TEventPublisher extends EventPublisher<any> | undefined = undefined,
+  TEventPublisherServiceName extends string = string,
+> extends Function<
+  TInput,
+  TServices,
+  TLogger,
+  OutSchema,
+  FunctionHandler<TInput, TServices, TLogger, OutSchema>,
+  TEventPublisher,
+  TEventPublisherServiceName
+> {
+  static isCron(obj: any): obj is Cron<any, any, any, any> {
+    return Boolean(
+      obj &&
+        (obj as Function).__IS_FUNCTION__ === true &&
+        obj.type === ConstructType.Cron,
+    );
+  }
+
+  constructor(
+    fn: FunctionHandler<TInput, TServices, TLogger, OutSchema>,
+    timeout?: number,
+    protected _schedule?: ScheduleExpression,
+    input?: TInput,
+    outputSchema?: OutSchema,
+    services: TServices = [] as unknown as TServices,
+    logger?: TLogger,
+    publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
+    events: any[] = [],
+  ) {
+    super(
+      fn,
+      timeout,
+      ConstructType.Cron,
+      input,
+      outputSchema,
+      services,
+      logger,
+      publisherService,
+      events,
+    );
+  }
+
+  get schedule(): ScheduleExpression | undefined {
+    return this._schedule;
+  }
+}
+
+export type RateExpression = `rate(${string})`;
+
+type CronMinute =
+  | '*'
+  | number
+  | `${number}`
+  | `${number}-${number}`
+  | `${number}/${number}`
+  | `*/${number}`
+  | `${number},${number}`
+  | string; // Allow more complex patterns
+
+type CronHour =
+  | '*'
+  | number
+  | `${number}`
+  | `${number}-${number}`
+  | `${number}/${number}`
+  | `*/${number}`
+  | `${number},${number}`
+  | string; // Allow more complex patterns
+
+type CronDay =
+  | '*'
+  | number
+  | `${number}`
+  | `${number}-${number}`
+  | `${number}/${number}`
+  | `*/${number}`
+  | `${number},${number}`
+  | string; // Allow more complex patterns
+
+type CronMonth =
+  | '*'
+  | number
+  | `${number}`
+  | `${number}-${number}`
+  | `${number}/${number}`
+  | `*/${number}`
+  | 'JAN'
+  | 'FEB'
+  | 'MAR'
+  | 'APR'
+  | 'MAY'
+  | 'JUN'
+  | 'JUL'
+  | 'AUG'
+  | 'SEP'
+  | 'OCT'
+  | 'NOV'
+  | 'DEC'
+  | string; // Allow more complex patterns
+
+type CronWeekday =
+  | '*'
+  | number
+  | `${number}`
+  | `${number}-${number}`
+  | `${number}/${number}`
+  | `*/${number}`
+  | 'SUN'
+  | 'MON'
+  | 'TUE'
+  | 'WED'
+  | 'THU'
+  | 'FRI'
+  | 'SAT'
+  | `${string}-${string}` // Allow patterns like MON-FRI
+  | string; // Allow more complex patterns
+
+export type CronExpression =
+  `cron(${CronMinute} ${CronHour} ${CronDay} ${CronMonth} ${CronWeekday})`;
+
+export type ScheduleExpression = RateExpression | CronExpression;