@spinajs/queue 2.0.180 → 2.0.181

package/lib/mjs/interfaces.d.ts

@@ -1,214 +1,214 @@
-import { AsyncService, Constructor, IInstanceCheck, IMappableService } from '@spinajs/di';
-import { DateTime } from 'luxon';
-import { Log } from '@spinajs/log';
-export declare enum QueueMessageType {
-    Job = "JOB",
-    Event = "EVENT"
-}
-export interface IQueueMessage {
-    CreatedAt: DateTime;
-    Name: string;
-    Type: QueueMessageType;
-    Persistent: boolean;
-    Priority: number;
-    /**
-     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
-     */
-    ScheduleDelay?: number;
-    /**
-     * The time in milliseconds to wait after the start time to wait before scheduling the message again
-     */
-    SchedulePeriod?: number;
-    /**
-     * The number of times to repeat scheduling a message for delivery
-     */
-    ScheduleRepeat?: number;
-    /**
-     * Use a Cron entry to set the schedule
-     */
-    ScheduleCron?: string;
-}
-export interface IQueueJob extends IQueueMessage {
-    RetryCount: number;
-    JobId?: string;
-}
-export declare abstract class QueueService extends AsyncService {
-    protected Configuration: IQueueConfiguration;
-    abstract emit(event: IQueueMessage | QueueEvent | QueueJob): Promise<void>;
-    abstract consume<T extends QueueMessage>(event: Constructor<QueueMessage>, callback?: (message: T) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
-    abstract stopConsuming(event: Constructor<QueueMessage>): Promise<void>;
-    abstract get(connection?: string): QueueClient;
-    protected getConnectionsForMessage(event: IQueueMessage | Constructor<QueueMessage>): string[];
-}
-export declare function isJob(event: IQueueMessage): event is QueueJob;
-/**
- * Events are messages send via queue, we do not want to track it, dont care about result, no retry policy on failed execution etc.
- */
-export declare abstract class QueueMessage implements IQueueMessage {
-    [key: string]: any;
-    CreatedAt: DateTime;
-    Name: string;
-    Type: QueueMessageType;
-    Persistent: boolean;
-    Priority: number;
-    /**
-     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
-     */
-    ScheduleDelay: number;
-    /**
-     * The time in milliseconds to wait after the start time to wait before scheduling the message again
-     */
-    SchedulePeriod: number;
-    /**
-     * The number of times to repeat scheduling a message for delivery
-     */
-    ScheduleRepeat: number;
-    /**
-     * Use a Cron entry to set the schedule
-     */
-    ScheduleCron: string;
-    constructor();
-    hydrate(payload: any): void;
-}
-/**
- * events provides a simple observer implementation, allowing you to subscribe and listen
- * for various events that occur in your application. Events serve as a great way to decouple
- * various aspects of your application, since a single event can have multiple listeners that do not depend on each other.
- *
- * we can register multiple listeners for a single event and the event helper will dispatch the event to all of its registered
- * listeners without us calling them explicitly. where in case of Jobs we would have to call them each one explicitly.
- */
-export declare abstract class QueueEvent extends QueueMessage {
-    constructor();
-    static emit<T extends typeof QueueMessage>(this: T, val: Partial<InstanceType<T>>, options?: IMessageOptions): Promise<void>;
-}
-/**
- * Jobs are executed only once even if multiple listeners waiting for it. usually used for single method call
- * or time consuming tasks, that need to checked for result and tracked
- *
- * Job results are preserved
- */
-export declare abstract class QueueJob extends QueueMessage implements IQueueJob {
-    JobId: string;
-    /**
-     * Retry count on job failure
-     */
-    RetryCount: number;
-    constructor();
-    abstract execute(progress: (p: number) => Promise<void>): Promise<unknown>;
-    static emit<T extends typeof QueueMessage>(this: T, val: Partial<InstanceType<T>>, options?: IMessageOptions): Promise<void>;
-}
-export declare abstract class QueueClient extends AsyncService implements IInstanceCheck, IMappableService {
-    Options: IQueueConnectionOptions;
-    protected Log: Log;
-    protected Routing: IQueueMessageRoutingOptions;
-    get Name(): string;
-    get ServiceName(): string;
-    constructor(Options: IQueueConnectionOptions);
-    __checkInstance__(creationOptions: any): boolean;
-    /**
-     *
-     * Dispatches event to queue
-     *
-     * @param event - event to dispatch
-     */
-    abstract emit(event: IQueueMessage): Promise<void>;
-    /**
-     *
-     * Subscribes to ALL channels that event is assignet to in routing table
-     *
-     */
-    abstract subscribe(event: Constructor<QueueMessage>, callback: (e: IQueueMessage) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
-    /**
-     * Subscribes for specific channel in queue server
-     *
-     * @param channel - specified channel to subscribe
-     * @param callback - callback executet when message arrives
-     * @param subscriptionId - id to identify subscription when using durable events
-     * @param durable - is durable event ?
-     */
-    abstract subscribe(channel: string, callback: (e: IQueueMessage) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
-    abstract unsubscribe(event: Constructor<QueueMessage>): void;
-    abstract unsubscribe(channel: string): void;
-    /**
-     *
-     * Gets event channel from routing table or default if non is set
-     *
-     * @param event - event to check
-     */
-    getChannelForMessage(event: IQueueMessage | Constructor<QueueMessage>): string[];
-}
-export interface IQueueMessageRoutingOptions {
-    [key: string]: string | IMessageRoutingOption | string[] | IMessageRoutingOption[];
-}
-export interface IQueueConfiguration {
-    default: string;
-    /**
-     * Message routing eg. where event/job with given type ( name ) will be send to
-     * eg. job Email will be sent to /task/mails channel in broker
-     * If no routing for message is provided, it will be sent to default one.
-     *
-     * Also here deat letter channel for message can be configured
-     *
-     * Message can be router in multiple destinations
-     */
-    routing?: IQueueMessageRoutingOptions;
-    connections: IQueueConnectionOptions[];
-}
-export interface IMessageRoutingOption {
-    channel?: string;
-    deadLetterChannel?: string;
-    connection?: string;
-}
-export interface IQueueConnectionOptions {
-    transport: string;
-    name: string;
-    login?: string;
-    password?: string;
-    host?: string;
-    port?: number;
-    queue?: string;
-    options?: any;
-    type: 'event' | 'job';
-    debug?: boolean;
-    /**
-     * Default topic ( events ) channel in broker
-     * If no routing for specified event is provided
-     * it will be send to this channel
-     */
-    defaultTopicChannel?: string;
-    /**
-     * Default queue ( job ) channel in broker
-     * If no routing for specified job is provided
-     * it will be send to this channel
-     */
-    defaultQueueChannel?: string;
-    /**
-     * If job fails at client side and we dont send ack
-     * broker will try to send job again ( and probably will fail again )
-     * In such event, it will reschedule job to deat letter queue for further processing
-     * and for unblocking source queue
-     */
-    defaultQueueDeadLetterChannel?: string;
-}
-export interface IMessageOptions {
-    Persistent: boolean;
-    Priority: number;
-    /**
-     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
-     */
-    ScheduleDelay: number;
-    /**
-     * The time in milliseconds to wait after the start time to wait before scheduling the message again
-     */
-    SchedulePeriod: number;
-    /**
-     * The number of times to repeat scheduling a message for delivery
-     */
-    ScheduleRepeat: number;
-    /**
-     * Use a Cron entry to set the schedule
-     */
-    ScheduleCron: string;
-}
+import { AsyncService, Constructor, IInstanceCheck, IMappableService } from '@spinajs/di';
+import { DateTime } from 'luxon';
+import { Log } from '@spinajs/log';
+export declare enum QueueMessageType {
+    Job = "JOB",
+    Event = "EVENT"
+}
+export interface IQueueMessage {
+    CreatedAt: DateTime;
+    Name: string;
+    Type: QueueMessageType;
+    Persistent: boolean;
+    Priority: number;
+    /**
+     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
+     */
+    ScheduleDelay?: number;
+    /**
+     * The time in milliseconds to wait after the start time to wait before scheduling the message again
+     */
+    SchedulePeriod?: number;
+    /**
+     * The number of times to repeat scheduling a message for delivery
+     */
+    ScheduleRepeat?: number;
+    /**
+     * Use a Cron entry to set the schedule
+     */
+    ScheduleCron?: string;
+}
+export interface IQueueJob extends IQueueMessage {
+    RetryCount: number;
+    JobId?: string;
+}
+export declare abstract class QueueService extends AsyncService {
+    protected Configuration: IQueueConfiguration;
+    abstract emit(event: IQueueMessage | QueueEvent | QueueJob): Promise<void>;
+    abstract consume<T extends QueueMessage>(event: Constructor<QueueMessage>, callback?: (message: T) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
+    abstract stopConsuming(event: Constructor<QueueMessage>): Promise<void>;
+    abstract get(connection?: string): QueueClient;
+    protected getConnectionsForMessage(event: IQueueMessage | Constructor<QueueMessage>): string[];
+}
+export declare function isJob(event: IQueueMessage): event is QueueJob;
+/**
+ * Events are messages send via queue, we do not want to track it, dont care about result, no retry policy on failed execution etc.
+ */
+export declare abstract class QueueMessage implements IQueueMessage {
+    [key: string]: any;
+    CreatedAt: DateTime;
+    Name: string;
+    Type: QueueMessageType;
+    Persistent: boolean;
+    Priority: number;
+    /**
+     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
+     */
+    ScheduleDelay: number;
+    /**
+     * The time in milliseconds to wait after the start time to wait before scheduling the message again
+     */
+    SchedulePeriod: number;
+    /**
+     * The number of times to repeat scheduling a message for delivery
+     */
+    ScheduleRepeat: number;
+    /**
+     * Use a Cron entry to set the schedule
+     */
+    ScheduleCron: string;
+    constructor();
+    hydrate(payload: any): void;
+}
+/**
+ * events provides a simple observer implementation, allowing you to subscribe and listen
+ * for various events that occur in your application. Events serve as a great way to decouple
+ * various aspects of your application, since a single event can have multiple listeners that do not depend on each other.
+ *
+ * we can register multiple listeners for a single event and the event helper will dispatch the event to all of its registered
+ * listeners without us calling them explicitly. where in case of Jobs we would have to call them each one explicitly.
+ */
+export declare abstract class QueueEvent extends QueueMessage {
+    constructor();
+    static emit<T extends typeof QueueMessage>(this: T, val: Partial<InstanceType<T>>, options?: IMessageOptions): Promise<void>;
+}
+/**
+ * Jobs are executed only once even if multiple listeners waiting for it. usually used for single method call
+ * or time consuming tasks, that need to checked for result and tracked
+ *
+ * Job results are preserved
+ */
+export declare abstract class QueueJob extends QueueMessage implements IQueueJob {
+    JobId: string;
+    /**
+     * Retry count on job failure
+     */
+    RetryCount: number;
+    constructor();
+    abstract execute(progress: (p: number) => Promise<void>): Promise<unknown>;
+    static emit<T extends typeof QueueMessage>(this: T, val: Partial<InstanceType<T>>, options?: IMessageOptions): Promise<void>;
+}
+export declare abstract class QueueClient extends AsyncService implements IInstanceCheck, IMappableService {
+    Options: IQueueConnectionOptions;
+    protected Log: Log;
+    protected Routing: IQueueMessageRoutingOptions;
+    get Name(): string;
+    get ServiceName(): string;
+    constructor(Options: IQueueConnectionOptions);
+    __checkInstance__(creationOptions: any): boolean;
+    /**
+     *
+     * Dispatches event to queue
+     *
+     * @param event - event to dispatch
+     */
+    abstract emit(event: IQueueMessage): Promise<void>;
+    /**
+     *
+     * Subscribes to ALL channels that event is assignet to in routing table
+     *
+     */
+    abstract subscribe(event: Constructor<QueueMessage>, callback: (e: IQueueMessage) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
+    /**
+     * Subscribes for specific channel in queue server
+     *
+     * @param channel - specified channel to subscribe
+     * @param callback - callback executet when message arrives
+     * @param subscriptionId - id to identify subscription when using durable events
+     * @param durable - is durable event ?
+     */
+    abstract subscribe(channel: string, callback: (e: IQueueMessage) => Promise<void>, subscriptionId?: string, durable?: boolean): Promise<void>;
+    abstract unsubscribe(event: Constructor<QueueMessage>): void;
+    abstract unsubscribe(channel: string): void;
+    /**
+     *
+     * Gets event channel from routing table or default if non is set
+     *
+     * @param event - event to check
+     */
+    getChannelForMessage(event: IQueueMessage | Constructor<QueueMessage>): string[];
+}
+export interface IQueueMessageRoutingOptions {
+    [key: string]: string | IMessageRoutingOption | string[] | IMessageRoutingOption[];
+}
+export interface IQueueConfiguration {
+    default: string;
+    /**
+     * Message routing eg. where event/job with given type ( name ) will be send to
+     * eg. job Email will be sent to /task/mails channel in broker
+     * If no routing for message is provided, it will be sent to default one.
+     *
+     * Also here deat letter channel for message can be configured
+     *
+     * Message can be router in multiple destinations
+     */
+    routing?: IQueueMessageRoutingOptions;
+    connections: IQueueConnectionOptions[];
+}
+export interface IMessageRoutingOption {
+    channel?: string;
+    deadLetterChannel?: string;
+    connection?: string;
+}
+export interface IQueueConnectionOptions {
+    transport: string;
+    name: string;
+    login?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    queue?: string;
+    options?: any;
+    type: 'event' | 'job';
+    debug?: boolean;
+    /**
+     * Default topic ( events ) channel in broker
+     * If no routing for specified event is provided
+     * it will be send to this channel
+     */
+    defaultTopicChannel?: string;
+    /**
+     * Default queue ( job ) channel in broker
+     * If no routing for specified job is provided
+     * it will be send to this channel
+     */
+    defaultQueueChannel?: string;
+    /**
+     * If job fails at client side and we dont send ack
+     * broker will try to send job again ( and probably will fail again )
+     * In such event, it will reschedule job to deat letter queue for further processing
+     * and for unblocking source queue
+     */
+    defaultQueueDeadLetterChannel?: string;
+}
+export interface IMessageOptions {
+    Persistent: boolean;
+    Priority: number;
+    /**
+     * The time in milliseconds that a message will wait before being scheduled to be delivered by the broker
+     */
+    ScheduleDelay: number;
+    /**
+     * The time in milliseconds to wait after the start time to wait before scheduling the message again
+     */
+    SchedulePeriod: number;
+    /**
+     * The number of times to repeat scheduling a message for delivery
+     */
+    ScheduleRepeat: number;
+    /**
+     * Use a Cron entry to set the schedule
+     */
+    ScheduleCron: string;
+}
 //# sourceMappingURL=interfaces.d.ts.map