lonnymq 1.1.0 → 1.2.0

package/dist/index.d.mts

@@ -8,59 +8,69 @@ interface Client {
   query(query: string, params: Array<unknown>): Promise<QueryResult>;
 }
 type Adaptor<T> = (client: T) => Client;
-//#endregion
-//#region src/command/channel-policy/clear.d.ts
-declare class Clear {
+declare namespace release_d_exports {
+  export { Release, Result$5 as Result, ResultChannelNotFound$1 as ResultChannelNotFound, ResultChannelReleased };
+}
+type ResultChannelNotFound$1 = {
+  resultType: "CHANNEL_NOT_FOUND";
+};
+type ResultChannelReleased = {
+  resultType: "CHANNEL_RELEASED";
+};
+type Result$5 = ResultChannelNotFound$1 | ResultChannelReleased;
+declare class Release {
   readonly schema: string;
-  readonly channelId: string;
+  readonly channel: string;
   readonly createdAt: Date;
   constructor(params: {
     schema: string;
-    channelId: string;
+    channel: string;
   });
-  execute(databaseClient: Client): Promise<void>;
+  execute(databaseClient: Client): Promise<Result$5>;
 }
 //#endregion
-//#region src/command/channel-policy/set.d.ts
+//#region src/command/channel/set.d.ts
 declare class Set {
   readonly schema: string;
-  readonly channelId: string;
-  readonly maxConcurrency: number | null;
-  readonly maxSize: number | null;
-  readonly releaseIntervalMs: number | null;
+  readonly channel: string;
+  readonly maxConcurrency: number;
+  readonly maxSize: number;
+  readonly releaseIntervalMs: number;
   readonly createdAt: Date;
   constructor(params: {
     schema: string;
-    channelId: string;
-    maxConcurrency?: number | null;
-    maxSize?: number | null;
-    releaseIntervalMs?: number | null;
+    channel: string;
+    maxConcurrency: number;
+    maxSize: number;
+    releaseIntervalMs: number;
   });
   execute(databaseClient: Client): Promise<void>;
 }
 declare namespace index_d_exports$5 {
-  export { Clear, Set };
+  export { Release, Set, release_d_exports as release };
 }
 declare namespace create_d_exports {
-  export { Create, Result$4 as Result, ResultMessageCreated, ResultMessageDropped };
+  export { Create, Result$4 as Result, ResultChannelNotFound, ResultMessageCreated, ResultMessageDropped };
 }
 type ResultMessageCreated = {
   resultType: "MESSAGE_CREATED";
   id: bigint;
-  channelSize: number;
 };
 type ResultMessageDropped = {
   resultType: "MESSAGE_DROPPED";
 };
-type Result$4 = ResultMessageCreated | ResultMessageDropped;
+type ResultChannelNotFound = {
+  resultType: "CHANNEL_NOT_FOUND";
+};
+type Result$4 = ResultMessageCreated | ResultMessageDropped | ResultChannelNotFound;
 declare class Create {
   readonly schema: string;
-  readonly channelId: string;
+  readonly channel: string;
   readonly content: Buffer;
   readonly dequeueAt: number | null;
   constructor(params: {
     schema: string;
-    channelId: string;
+    channel: string;
     content: Buffer;
     dequeueAt: number | null;
   });
@@ -72,7 +82,6 @@ declare namespace dequeue_d_exports {
 type ResultMessageDequeued = {
   resultType: "MESSAGE_DEQUEUED";
   id: bigint;
-  channelId: string;
   isUnlocked: boolean;
   content: Buffer;
   state: Buffer | null;
@@ -91,8 +100,8 @@ declare class Dequeue {
   });
   execute(databaseClient: Client): Promise<Result$3>;
 }
-declare namespace retire_d_exports {
-  export { Result$2 as Result, ResultMessageNotFound$2 as ResultMessageNotFound, ResultMessageRetired, ResultStateInvalid$2 as ResultStateInvalid, Retire };
+declare namespace complete_d_exports {
+  export { Complete, Result$2 as Result, ResultMessageCompleted, ResultMessageNotFound$2 as ResultMessageNotFound, ResultStateInvalid$2 as ResultStateInvalid };
 }
 type ResultMessageNotFound$2 = {
   resultType: "MESSAGE_NOT_FOUND";
@@ -100,11 +109,11 @@ type ResultMessageNotFound$2 = {
 type ResultStateInvalid$2 = {
   resultType: "STATE_INVALID";
 };
-type ResultMessageRetired = {
-  resultType: "MESSAGE_RETIRED";
+type ResultMessageCompleted = {
+  resultType: "MESSAGE_COMPLETED";
 };
-type Result$2 = ResultMessageNotFound$2 | ResultStateInvalid$2 | ResultMessageRetired;
-declare class Retire {
+type Result$2 = ResultMessageNotFound$2 | ResultStateInvalid$2 | ResultMessageCompleted;
+declare class Complete {
   readonly schema: string;
   readonly id: bigint;
   readonly numAttempts: number;
@@ -170,21 +179,21 @@ declare class Heartbeat {
   execute(databaseClient: Client): Promise<Result>;
 }
 declare namespace index_d_exports$4 {
-  export { Create, Defer, Dequeue, Heartbeat, Retire, create_d_exports as create, defer_d_exports as defer, dequeue_d_exports as dequeue, heartbeat_d_exports as heartbeat, retire_d_exports as retire };
+  export { Complete, Create, Defer, Dequeue, Heartbeat, complete_d_exports as complete, create_d_exports as create, defer_d_exports as defer, dequeue_d_exports as dequeue, heartbeat_d_exports as heartbeat };
 }
 declare namespace index_d_exports {
-  export { index_d_exports$5 as channelPolicy, index_d_exports$4 as message };
+  export { index_d_exports$5 as channel, index_d_exports$4 as message };
 }
 //#endregion
 //#region src/queue/module/channel/message.d.ts
-declare class Message$2<T> {
+declare class Message$1<T> {
   private readonly schema;
-  private readonly channelId;
+  private readonly channel;
   private readonly adaptor;
   constructor(params: {
     schema: string;
     adaptor: Adaptor<T>;
-    channelId: string;
+    channel: string;
   });
   create(params: {
     databaseClient: T;
@@ -192,16 +201,18 @@ declare class Message$2<T> {
     dequeueAt?: number;
   }): Promise<Result$4>;
 }
-//#endregion
-//#region src/queue/module/channel/policy.d.ts
-declare class Policy<T> {
+declare namespace index_d_exports$3 {
+  export { Channel, Message$1 as Message };
+}
+declare class Channel<T> {
   private readonly schema;
   private readonly adaptor;
-  private readonly channelId;
+  private readonly channel;
+  readonly message: Message$1<T>;
   constructor(params: {
     schema: string;
     adaptor: Adaptor<T>;
-    channelId: string;
+    channel: string;
   });
   set(params: {
     databaseClient: T;
@@ -209,50 +220,23 @@ declare class Policy<T> {
     maxSize?: number | null;
     releaseIntervalMs?: number | null;
   }): Promise<void>;
-  clear(params: {
+  release(params: {
     databaseClient: T;
-  }): Promise<void>;
-}
-declare namespace index_d_exports$3 {
-  export { Channel, Message$2 as Message, Policy };
-}
-declare class Channel<T> {
-  readonly policy: Policy<T>;
-  readonly message: Message$2<T>;
-  constructor(params: {
-    schema: string;
-    adaptor: Adaptor<T>;
-    channelId: string;
-  });
-}
-//#endregion
-//#region src/queue/module/message.d.ts
-declare class Message$1<T> {
-  private readonly schema;
-  private readonly adaptor;
-  constructor(params: {
-    schema: string;
-    adaptor: Adaptor<T>;
-  });
-  create(params: {
-    databaseClient: T;
-    content: Buffer;
-    dequeueAt?: number;
-  }): Promise<Result$4>;
+  }): Promise<Result$5>;
 }
 declare namespace index_d_exports$2 {
-  export { Channel, Message$1 as Message, index_d_exports$3 as channel };
+  export { Channel, index_d_exports$3 as channel };
 }
 declare namespace event_d_exports {
-  export { DecodeResult, DecodeResultMessageCreated, DecodeResultMessageDeferred, DecodeResultMessageRetired, decode };
+  export { DecodeResult, DecodeResultMessageCompleted, DecodeResultMessageCreated, DecodeResultMessageDeferred, decode };
 }
 type DecodeResultMessageCreated = {
   eventType: "MESSAGE_CREATED";
   id: string;
   dequeueAt: number;
 };
-type DecodeResultMessageRetired = {
-  eventType: "MESSAGE_RETIRED";
+type DecodeResultMessageCompleted = {
+  eventType: "MESSAGE_COMPLETED";
   id: string;
 };
 type DecodeResultMessageDeferred = {
@@ -260,7 +244,7 @@ type DecodeResultMessageDeferred = {
   id: string;
   dequeueAt: number;
 };
-type DecodeResult = DecodeResultMessageCreated | DecodeResultMessageRetired | DecodeResultMessageDeferred;
+type DecodeResult = DecodeResultMessageCreated | DecodeResultMessageCompleted | DecodeResultMessageDeferred;
 declare const decode: (payload: string) => DecodeResult;
 //#endregion
 //#region src/queue/message.d.ts
@@ -269,7 +253,6 @@ declare class Message<T> {
   private readonly adaptor;
   readonly id: bigint;
   readonly isUnlocked: boolean;
-  readonly channelId: string;
   readonly content: Buffer;
   readonly state: Buffer | null;
   readonly numAttempts: number;
@@ -277,7 +260,6 @@ declare class Message<T> {
     schema: string;
     adaptor: Adaptor<T>;
     id: bigint;
-    channelId: string;
     isUnlocked: boolean;
     content: Buffer;
     state: Buffer | null;
@@ -288,7 +270,7 @@ declare class Message<T> {
     state?: Buffer;
     dequeueAt?: number;
   }): Promise<Result$1>;
-  retire(params: {
+  complete(params: {
     databaseClient: T;
   }): Promise<Result$2>;
   heartbeat(params: {
@@ -308,20 +290,21 @@ type DequeueResult<T> = {
 type Params<T> = T extends Client ? {
   schema: string;
   adaptor?: Adaptor<T>;
+  lockMs: number;
 } : {
   schema: string;
   adaptor: Adaptor<T>;
+  lockMs: number;
 };
 declare class Queue<T = Client> {
   readonly schema: string;
-  readonly message: Message$1<T>;
+  readonly lockMs: number;
   private readonly adaptor;
   constructor(params: Params<T>);
   dequeue(params: {
     databaseClient: T;
-    lockMs: number;
   }): Promise<DequeueResult<T>>;
-  channel(channelId: string): Channel<T>;
+  channel(channel: string): Channel<T>;
   install(params?: {
     eventChannel?: string;
   }): string[];