@geekmidas/events 0.1.0 → 1.0.0

package/src/Publisher.ts

@@ -1,87 +1,87 @@
 import type {
-  EventConnection,
-  EventPublisher,
-  PublishableMessage,
+	EventConnection,
+	EventPublisher,
+	PublishableMessage,
 } from './types';
 import { EventPublisherType } from './types';
 
 export class Publisher {
-  /**
-   * Create a publisher from a connection string
-   * This creates both a connection and a publisher
-   */
-  static async fromConnectionString<
-    TMessage extends PublishableMessage<string, any>,
-  >(
-    connectionStr: EventPublisherConnectionString,
-  ): Promise<EventPublisher<TMessage>> {
-    const url = new URL(connectionStr);
-    switch (url.protocol.replace(':', '')) {
-      case EventPublisherType.Basic: {
-        const { BasicConnection, BasicPublisher } = await import('./basic');
-        const connection =
-          await BasicConnection.fromConnectionString(connectionStr);
-        return new BasicPublisher<TMessage>(connection);
-      }
-      case EventPublisherType.RabbitMQ: {
-        const { RabbitMQPublisher } = await import('./rabbitmq');
-        return RabbitMQPublisher.fromConnectionString<TMessage>(connectionStr);
-      }
-      case EventPublisherType.SQS: {
-        const { SQSPublisher } = await import('./sqs');
-        return SQSPublisher.fromConnectionString<TMessage>(connectionStr);
-      }
-      case EventPublisherType.SNS: {
-        const { SNSPublisher } = await import('./sns');
-        return SNSPublisher.fromConnectionString<TMessage>(connectionStr);
-      }
-      // Future implementations for EventBridge, Kafka, etc.
-      default:
-        throw new Error(`Unsupported event publisher type: ${url.protocol}`);
-    }
-  }
+	/**
+	 * Create a publisher from a connection string
+	 * This creates both a connection and a publisher
+	 */
+	static async fromConnectionString<
+		TMessage extends PublishableMessage<string, any>,
+	>(
+		connectionStr: EventPublisherConnectionString,
+	): Promise<EventPublisher<TMessage>> {
+		const url = new URL(connectionStr);
+		switch (url.protocol.replace(':', '')) {
+			case EventPublisherType.Basic: {
+				const { BasicConnection, BasicPublisher } = await import('./basic');
+				const connection =
+					await BasicConnection.fromConnectionString(connectionStr);
+				return new BasicPublisher<TMessage>(connection);
+			}
+			case EventPublisherType.RabbitMQ: {
+				const { RabbitMQPublisher } = await import('./rabbitmq');
+				return RabbitMQPublisher.fromConnectionString<TMessage>(connectionStr);
+			}
+			case EventPublisherType.SQS: {
+				const { SQSPublisher } = await import('./sqs');
+				return SQSPublisher.fromConnectionString<TMessage>(connectionStr);
+			}
+			case EventPublisherType.SNS: {
+				const { SNSPublisher } = await import('./sns');
+				return SNSPublisher.fromConnectionString<TMessage>(connectionStr);
+			}
+			// Future implementations for EventBridge, Kafka, etc.
+			default:
+				throw new Error(`Unsupported event publisher type: ${url.protocol}`);
+		}
+	}
 
-  /**
-   * Create a publisher from an existing connection
-   * This allows sharing connections between publishers and subscribers
-   */
-  static async fromConnection<TMessage extends PublishableMessage<string, any>>(
-    connection: EventConnection,
-  ): Promise<EventPublisher<TMessage>> {
-    switch (connection.type) {
-      case EventPublisherType.Basic: {
-        const { BasicPublisher } = await import('./basic');
-        const { BasicConnection } = await import('./basic');
-        return new BasicPublisher<TMessage>(
-          connection as InstanceType<typeof BasicConnection>,
-        );
-      }
-      case EventPublisherType.RabbitMQ: {
-        const { RabbitMQPublisher } = await import('./rabbitmq');
-        const { RabbitMQConnection } = await import('./rabbitmq');
-        return new RabbitMQPublisher<TMessage>(
-          connection as InstanceType<typeof RabbitMQConnection>,
-        );
-      }
-      case EventPublisherType.SQS: {
-        const { SQSPublisher } = await import('./sqs');
-        const { SQSConnection } = await import('./sqs');
-        return new SQSPublisher<TMessage>(
-          connection as InstanceType<typeof SQSConnection>,
-        );
-      }
-      case EventPublisherType.SNS: {
-        const { SNSPublisher } = await import('./sns');
-        const { SNSConnection } = await import('./sns');
-        return new SNSPublisher<TMessage>(
-          connection as InstanceType<typeof SNSConnection>,
-        );
-      }
-      default:
-        throw new Error(`Unsupported connection type: ${connection.type}`);
-    }
-  }
+	/**
+	 * Create a publisher from an existing connection
+	 * This allows sharing connections between publishers and subscribers
+	 */
+	static async fromConnection<TMessage extends PublishableMessage<string, any>>(
+		connection: EventConnection,
+	): Promise<EventPublisher<TMessage>> {
+		switch (connection.type) {
+			case EventPublisherType.Basic: {
+				const { BasicPublisher } = await import('./basic');
+				const { BasicConnection } = await import('./basic');
+				return new BasicPublisher<TMessage>(
+					connection as InstanceType<typeof BasicConnection>,
+				);
+			}
+			case EventPublisherType.RabbitMQ: {
+				const { RabbitMQPublisher } = await import('./rabbitmq');
+				const { RabbitMQConnection } = await import('./rabbitmq');
+				return new RabbitMQPublisher<TMessage>(
+					connection as InstanceType<typeof RabbitMQConnection>,
+				);
+			}
+			case EventPublisherType.SQS: {
+				const { SQSPublisher } = await import('./sqs');
+				const { SQSConnection } = await import('./sqs');
+				return new SQSPublisher<TMessage>(
+					connection as InstanceType<typeof SQSConnection>,
+				);
+			}
+			case EventPublisherType.SNS: {
+				const { SNSPublisher } = await import('./sns');
+				const { SNSConnection } = await import('./sns');
+				return new SNSPublisher<TMessage>(
+					connection as InstanceType<typeof SNSConnection>,
+				);
+			}
+			default:
+				throw new Error(`Unsupported connection type: ${connection.type}`);
+		}
+	}
 }
 
 export type EventPublisherConnectionString =
-  `${EventPublisherType}://${string}`;
+	`${EventPublisherType}://${string}`;

package/src/Subscriber.ts

@@ -1,102 +1,102 @@
 import type {
-  EventConnection,
-  EventSubscriber,
-  PublishableMessage,
+	EventConnection,
+	EventSubscriber,
+	PublishableMessage,
 } from './types';
 import { EventPublisherType } from './types';
 
 export class Subscriber {
-  /**
-   * Create a subscriber from a connection string
-   * This creates both a connection and a subscriber
-   */
-  static async fromConnectionString<
-    TMessage extends PublishableMessage<string, any>,
-  >(
-    connectionStr: EventSubscriberConnectionString,
-  ): Promise<EventSubscriber<TMessage>> {
-    const url = new URL(connectionStr);
-    switch (url.protocol.replace(':', '')) {
-      case EventPublisherType.Basic: {
-        const { BasicConnection, BasicSubscriber } = await import('./basic');
-        const connection =
-          await BasicConnection.fromConnectionString(connectionStr);
-        return new BasicSubscriber<TMessage>(connection);
-      }
-      case EventPublisherType.RabbitMQ: {
-        const { RabbitMQSubscriber } = await import('./rabbitmq');
-        return RabbitMQSubscriber.fromConnectionString<TMessage>(connectionStr);
-      }
-      case EventPublisherType.SNS: {
-        const { SNSSubscriber } = await import('./sns');
-        return SNSSubscriber.fromConnectionString<TMessage>(connectionStr);
-      }
-      case EventPublisherType.SQS: {
-        const url = new URL(connectionStr);
-        const topicArn = url.searchParams.get('topicArn');
+	/**
+	 * Create a subscriber from a connection string
+	 * This creates both a connection and a subscriber
+	 */
+	static async fromConnectionString<
+		TMessage extends PublishableMessage<string, any>,
+	>(
+		connectionStr: EventSubscriberConnectionString,
+	): Promise<EventSubscriber<TMessage>> {
+		const url = new URL(connectionStr);
+		switch (url.protocol.replace(':', '')) {
+			case EventPublisherType.Basic: {
+				const { BasicConnection, BasicSubscriber } = await import('./basic');
+				const connection =
+					await BasicConnection.fromConnectionString(connectionStr);
+				return new BasicSubscriber<TMessage>(connection);
+			}
+			case EventPublisherType.RabbitMQ: {
+				const { RabbitMQSubscriber } = await import('./rabbitmq');
+				return RabbitMQSubscriber.fromConnectionString<TMessage>(connectionStr);
+			}
+			case EventPublisherType.SNS: {
+				const { SNSSubscriber } = await import('./sns');
+				return SNSSubscriber.fromConnectionString<TMessage>(connectionStr);
+			}
+			case EventPublisherType.SQS: {
+				const url = new URL(connectionStr);
+				const topicArn = url.searchParams.get('topicArn');
 
-        // If topicArn is present, use managed SNS→SQS subscription
-        if (topicArn) {
-          const { SNSSubscriber } = await import('./sns');
-          // Convert SQS connection string to SNS connection string
-          const snsConnectionStr = connectionStr.replace('sqs://', 'sns://');
-          return SNSSubscriber.fromConnectionString<TMessage>(snsConnectionStr);
-        }
+				// If topicArn is present, use managed SNS→SQS subscription
+				if (topicArn) {
+					const { SNSSubscriber } = await import('./sns');
+					// Convert SQS connection string to SNS connection string
+					const snsConnectionStr = connectionStr.replace('sqs://', 'sns://');
+					return SNSSubscriber.fromConnectionString<TMessage>(snsConnectionStr);
+				}
 
-        // Direct SQS subscriber
-        const { SQSSubscriber } = await import('./sqs');
-        const { SQSConnection } = await import('./sqs');
-        const connection =
-          await SQSConnection.fromConnectionString(connectionStr);
-        return new SQSSubscriber<TMessage>(connection);
-      }
-      // Future implementations for EventBridge, Kafka, etc.
-      default:
-        throw new Error(`Unsupported event subscriber type: ${url.protocol}`);
-    }
-  }
+				// Direct SQS subscriber
+				const { SQSSubscriber } = await import('./sqs');
+				const { SQSConnection } = await import('./sqs');
+				const connection =
+					await SQSConnection.fromConnectionString(connectionStr);
+				return new SQSSubscriber<TMessage>(connection);
+			}
+			// Future implementations for EventBridge, Kafka, etc.
+			default:
+				throw new Error(`Unsupported event subscriber type: ${url.protocol}`);
+		}
+	}
 
-  /**
-   * Create a subscriber from an existing connection
-   * This allows sharing connections between publishers and subscribers
-   */
-  static async fromConnection<TMessage extends PublishableMessage<string, any>>(
-    connection: EventConnection,
-  ): Promise<EventSubscriber<TMessage>> {
-    switch (connection.type) {
-      case EventPublisherType.Basic: {
-        const { BasicSubscriber } = await import('./basic');
-        const { BasicConnection } = await import('./basic');
-        return new BasicSubscriber<TMessage>(
-          connection as InstanceType<typeof BasicConnection>,
-        );
-      }
-      case EventPublisherType.RabbitMQ: {
-        const { RabbitMQSubscriber } = await import('./rabbitmq');
-        const { RabbitMQConnection } = await import('./rabbitmq');
-        return new RabbitMQSubscriber<TMessage>(
-          connection as InstanceType<typeof RabbitMQConnection>,
-        );
-      }
-      case EventPublisherType.SNS: {
-        const { SNSSubscriber } = await import('./sns');
-        const { SNSConnection } = await import('./sns');
-        return new SNSSubscriber<TMessage>(
-          connection as InstanceType<typeof SNSConnection>,
-        );
-      }
-      case EventPublisherType.SQS: {
-        const { SQSSubscriber } = await import('./sqs');
-        const { SQSConnection } = await import('./sqs');
-        return new SQSSubscriber<TMessage>(
-          connection as InstanceType<typeof SQSConnection>,
-        );
-      }
-      default:
-        throw new Error(`Unsupported connection type: ${connection.type}`);
-    }
-  }
+	/**
+	 * Create a subscriber from an existing connection
+	 * This allows sharing connections between publishers and subscribers
+	 */
+	static async fromConnection<TMessage extends PublishableMessage<string, any>>(
+		connection: EventConnection,
+	): Promise<EventSubscriber<TMessage>> {
+		switch (connection.type) {
+			case EventPublisherType.Basic: {
+				const { BasicSubscriber } = await import('./basic');
+				const { BasicConnection } = await import('./basic');
+				return new BasicSubscriber<TMessage>(
+					connection as InstanceType<typeof BasicConnection>,
+				);
+			}
+			case EventPublisherType.RabbitMQ: {
+				const { RabbitMQSubscriber } = await import('./rabbitmq');
+				const { RabbitMQConnection } = await import('./rabbitmq');
+				return new RabbitMQSubscriber<TMessage>(
+					connection as InstanceType<typeof RabbitMQConnection>,
+				);
+			}
+			case EventPublisherType.SNS: {
+				const { SNSSubscriber } = await import('./sns');
+				const { SNSConnection } = await import('./sns');
+				return new SNSSubscriber<TMessage>(
+					connection as InstanceType<typeof SNSConnection>,
+				);
+			}
+			case EventPublisherType.SQS: {
+				const { SQSSubscriber } = await import('./sqs');
+				const { SQSConnection } = await import('./sqs');
+				return new SQSSubscriber<TMessage>(
+					connection as InstanceType<typeof SQSConnection>,
+				);
+			}
+			default:
+				throw new Error(`Unsupported connection type: ${connection.type}`);
+		}
+	}
 }
 
 export type EventSubscriberConnectionString =
-  `${EventPublisherType}://${string}`;
+	`${EventPublisherType}://${string}`;

package/src/__tests__/EventConnection.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { EventConnectionFactory, EventPublisherType } from '../EventConnection';
+
+describe('EventConnectionFactory', () => {
+	describe('fromConnectionString', () => {
+		it('should create BasicConnection for basic:// protocol', async () => {
+			const connection =
+				await EventConnectionFactory.fromConnectionString('basic://memory');
+			expect(connection).toBeDefined();
+		});
+
+		it('should throw for unsupported protocol', async () => {
+			await expect(
+				EventConnectionFactory.fromConnectionString('unknown://localhost'),
+			).rejects.toThrow('Unsupported connection type: unknown');
+		});
+
+		it('should throw for invalid URL', async () => {
+			await expect(
+				EventConnectionFactory.fromConnectionString('not-a-url'),
+			).rejects.toThrow();
+		});
+	});
+});
+
+describe('EventPublisherType', () => {
+	it('should have Basic type', () => {
+		expect(EventPublisherType.Basic).toBe('basic');
+	});
+
+	it('should have RabbitMQ type', () => {
+		expect(EventPublisherType.RabbitMQ).toBe('rabbitmq');
+	});
+
+	it('should have SQS type', () => {
+		expect(EventPublisherType.SQS).toBe('sqs');
+	});
+
+	it('should have SNS type', () => {
+		expect(EventPublisherType.SNS).toBe('sns');
+	});
+});

package/src/__tests__/Publisher.spec.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import { BasicConnection, BasicPublisher } from '../basic';
+import { Publisher } from '../Publisher';
+import { SNSConnection } from '../sns/SNSConnection';
+import { SNSPublisher } from '../sns/SNSPublisher';
+import { SQSConnection } from '../sqs/SQSConnection';
+import { SQSPublisher } from '../sqs/SQSPublisher';
+import type { PublishableMessage } from '../types';
+
+type TestMessage = PublishableMessage<'test.event', { data: string }>;
+
+describe('Publisher', () => {
+	describe('fromConnectionString', () => {
+		it('should create Basic publisher from basic:// connection string', async () => {
+			const connectionStr = 'basic://localhost';
+
+			const publisher =
+				await Publisher.fromConnectionString<TestMessage>(connectionStr);
+
+			expect(publisher).toBeInstanceOf(BasicPublisher);
+		});
+
+		it('should create SQS publisher from sqs:// connection string', async () => {
+			const connectionStr =
+				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566';
+
+			const publisher =
+				await Publisher.fromConnectionString<TestMessage>(connectionStr);
+
+			expect(publisher).toBeInstanceOf(SQSPublisher);
+		});
+
+		it('should create SNS publisher from sns:// connection string', async () => {
+			const connectionStr =
+				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
+
+			const publisher =
+				await Publisher.fromConnectionString<TestMessage>(connectionStr);
+
+			expect(publisher).toBeInstanceOf(SNSPublisher);
+		});
+
+		it('should throw error for unsupported protocol', async () => {
+			const connectionStr = 'unsupported://localhost';
+
+			await expect(
+				Publisher.fromConnectionString<TestMessage>(connectionStr),
+			).rejects.toThrow('Unsupported event publisher type');
+		});
+	});
+
+	describe('fromConnection', () => {
+		it('should create Basic publisher from Basic connection', async () => {
+			const connection = new BasicConnection();
+			await connection.connect();
+
+			const publisher = await Publisher.fromConnection<TestMessage>(connection);
+
+			expect(publisher).toBeInstanceOf(BasicPublisher);
+
+			await connection.close();
+		});
+
+		it('should create SQS publisher from SQS connection', async () => {
+			const connection = await SQSConnection.fromConnectionString(
+				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566',
+			);
+
+			const publisher = await Publisher.fromConnection<TestMessage>(connection);
+
+			expect(publisher).toBeInstanceOf(SQSPublisher);
+		});
+
+		it('should create SNS publisher from SNS connection', async () => {
+			const connection = await SNSConnection.fromConnectionString(
+				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test',
+			);
+
+			const publisher = await Publisher.fromConnection<TestMessage>(connection);
+
+			expect(publisher).toBeInstanceOf(SNSPublisher);
+
+			await connection.close();
+		});
+
+		it('should throw error for unsupported connection type', async () => {
+			const fakeConnection = {
+				type: 'unsupported' as any,
+			};
+
+			await expect(
+				Publisher.fromConnection<TestMessage>(fakeConnection as any),
+			).rejects.toThrow('Unsupported connection type');
+		});
+	});
+});

package/src/__tests__/Subscriber.spec.ts

@@ -1,41 +1,109 @@
 import { describe, expect, it } from 'vitest';
+import { BasicConnection, BasicSubscriber } from '../basic';
 import { Subscriber } from '../Subscriber';
+import { SNSConnection } from '../sns/SNSConnection';
 import { SNSSubscriber } from '../sns/SNSSubscriber';
+import { SQSConnection } from '../sqs/SQSConnection';
 import { SQSSubscriber } from '../sqs/SQSSubscriber';
 import type { PublishableMessage } from '../types';
 
 type TestMessage = PublishableMessage<'test.event', { data: string }>;
 
 describe('Subscriber', () => {
-  describe('fromConnectionString', () => {
-    it('should create SQS subscriber without topicArn', async () => {
-      const connectionStr =
-        'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566';
+	describe('fromConnectionString', () => {
+		it('should create Basic subscriber from basic:// connection string', async () => {
+			const connectionStr = 'basic://localhost';
 
-      const subscriber =
-        await Subscriber.fromConnectionString<TestMessage>(connectionStr);
+			const subscriber =
+				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
 
-      expect(subscriber).toBeInstanceOf(SQSSubscriber);
-    });
+			expect(subscriber).toBeInstanceOf(BasicSubscriber);
+		});
 
-    it('should create SNS subscriber when topicArn is present in SQS connection string', async () => {
-      const connectionStr =
-        'sqs://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&queueName=test-queue&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
+		it('should create SQS subscriber without topicArn', async () => {
+			const connectionStr =
+				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566';
 
-      const subscriber =
-        await Subscriber.fromConnectionString<TestMessage>(connectionStr);
+			const subscriber =
+				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
 
-      expect(subscriber).toBeInstanceOf(SNSSubscriber);
-    });
+			expect(subscriber).toBeInstanceOf(SQSSubscriber);
+		});
 
-    it('should create SNS subscriber from sns:// connection string', async () => {
-      const connectionStr =
-        'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
+		it('should create SNS subscriber when topicArn is present in SQS connection string', async () => {
+			const connectionStr =
+				'sqs://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&queueName=test-queue&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
 
-      const subscriber =
-        await Subscriber.fromConnectionString<TestMessage>(connectionStr);
+			const subscriber =
+				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
 
-      expect(subscriber).toBeInstanceOf(SNSSubscriber);
-    });
-  });
+			expect(subscriber).toBeInstanceOf(SNSSubscriber);
+		});
+
+		it('should create SNS subscriber from sns:// connection string', async () => {
+			const connectionStr =
+				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test';
+
+			const subscriber =
+				await Subscriber.fromConnectionString<TestMessage>(connectionStr);
+
+			expect(subscriber).toBeInstanceOf(SNSSubscriber);
+		});
+
+		it('should throw error for unsupported protocol', async () => {
+			const connectionStr = 'unsupported://localhost';
+
+			await expect(
+				Subscriber.fromConnectionString<TestMessage>(connectionStr),
+			).rejects.toThrow('Unsupported event subscriber type');
+		});
+	});
+
+	describe('fromConnection', () => {
+		it('should create Basic subscriber from Basic connection', async () => {
+			const connection = new BasicConnection();
+			await connection.connect();
+
+			const subscriber =
+				await Subscriber.fromConnection<TestMessage>(connection);
+
+			expect(subscriber).toBeInstanceOf(BasicSubscriber);
+
+			await connection.close();
+		});
+
+		it('should create SQS subscriber from SQS connection', async () => {
+			const connection = await SQSConnection.fromConnectionString(
+				'sqs://?queueUrl=https://sqs.us-east-1.amazonaws.com/123456789/test-queue&region=us-east-1&endpoint=http://localhost:4566',
+			);
+
+			const subscriber =
+				await Subscriber.fromConnection<TestMessage>(connection);
+
+			expect(subscriber).toBeInstanceOf(SQSSubscriber);
+		});
+
+		it('should create SNS subscriber from SNS connection', async () => {
+			const connection = await SNSConnection.fromConnectionString(
+				'sns://?topicArn=arn:aws:sns:us-east-1:123456789:test-topic&region=us-east-1&endpoint=http://localhost:4566&accessKeyId=test&secretAccessKey=test',
+			);
+
+			const subscriber =
+				await Subscriber.fromConnection<TestMessage>(connection);
+
+			expect(subscriber).toBeInstanceOf(SNSSubscriber);
+
+			await connection.close();
+		});
+
+		it('should throw error for unsupported connection type', async () => {
+			const fakeConnection = {
+				type: 'unsupported' as any,
+			};
+
+			await expect(
+				Subscriber.fromConnection<TestMessage>(fakeConnection as any),
+			).rejects.toThrow('Unsupported connection type');
+		});
+	});
 });