lonnymq 1.0.2 → 1.2.0

package/dist/index.d.mts

@@ -0,0 +1,314 @@
+declare namespace database_d_exports {
+  export { Adaptor, Client, QueryResult };
+}
+type QueryResult = {
+  rows: Array<Record<string, unknown>>;
+};
+interface Client {
+  query(query: string, params: Array<unknown>): Promise<QueryResult>;
+}
+type Adaptor<T> = (client: T) => Client;
+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 channel: string;
+  readonly createdAt: Date;
+  constructor(params: {
+    schema: string;
+    channel: string;
+  });
+  execute(databaseClient: Client): Promise<Result$5>;
+}
+//#endregion
+//#region src/command/channel/set.d.ts
+declare class Set {
+  readonly schema: string;
+  readonly channel: string;
+  readonly maxConcurrency: number;
+  readonly maxSize: number;
+  readonly releaseIntervalMs: number;
+  readonly createdAt: Date;
+  constructor(params: {
+    schema: string;
+    channel: string;
+    maxConcurrency: number;
+    maxSize: number;
+    releaseIntervalMs: number;
+  });
+  execute(databaseClient: Client): Promise<void>;
+}
+declare namespace index_d_exports$5 {
+  export { Release, Set, release_d_exports as release };
+}
+declare namespace create_d_exports {
+  export { Create, Result$4 as Result, ResultChannelNotFound, ResultMessageCreated, ResultMessageDropped };
+}
+type ResultMessageCreated = {
+  resultType: "MESSAGE_CREATED";
+  id: bigint;
+};
+type ResultMessageDropped = {
+  resultType: "MESSAGE_DROPPED";
+};
+type ResultChannelNotFound = {
+  resultType: "CHANNEL_NOT_FOUND";
+};
+type Result$4 = ResultMessageCreated | ResultMessageDropped | ResultChannelNotFound;
+declare class Create {
+  readonly schema: string;
+  readonly channel: string;
+  readonly content: Buffer;
+  readonly dequeueAt: number | null;
+  constructor(params: {
+    schema: string;
+    channel: string;
+    content: Buffer;
+    dequeueAt: number | null;
+  });
+  execute(databaseClient: Client): Promise<Result$4>;
+}
+declare namespace dequeue_d_exports {
+  export { Dequeue, Result$3 as Result, ResultMessageDequeued, ResultMessageNotAvailable };
+}
+type ResultMessageDequeued = {
+  resultType: "MESSAGE_DEQUEUED";
+  id: bigint;
+  isUnlocked: boolean;
+  content: Buffer;
+  state: Buffer | null;
+  numAttempts: number;
+};
+type ResultMessageNotAvailable = {
+  resultType: "MESSAGE_NOT_AVAILABLE";
+};
+type Result$3 = ResultMessageDequeued | ResultMessageNotAvailable;
+declare class Dequeue {
+  readonly schema: string;
+  readonly lockMs: number;
+  constructor(params: {
+    schema: string;
+    lockMs: number;
+  });
+  execute(databaseClient: Client): Promise<Result$3>;
+}
+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";
+};
+type ResultStateInvalid$2 = {
+  resultType: "STATE_INVALID";
+};
+type ResultMessageCompleted = {
+  resultType: "MESSAGE_COMPLETED";
+};
+type Result$2 = ResultMessageNotFound$2 | ResultStateInvalid$2 | ResultMessageCompleted;
+declare class Complete {
+  readonly schema: string;
+  readonly id: bigint;
+  readonly numAttempts: number;
+  constructor(params: {
+    schema: string;
+    numAttempts: number;
+    id: bigint;
+  });
+  execute(databaseClient: Client): Promise<Result$2>;
+}
+declare namespace defer_d_exports {
+  export { Defer, Result$1 as Result, ResultMessageDeferred, ResultMessageNotFound$1 as ResultMessageNotFound, ResultStateInvalid$1 as ResultStateInvalid };
+}
+type ResultMessageNotFound$1 = {
+  resultType: "MESSAGE_NOT_FOUND";
+};
+type ResultStateInvalid$1 = {
+  resultType: "STATE_INVALID";
+};
+type ResultMessageDeferred = {
+  resultType: "MESSAGE_DEFERRED";
+};
+type Result$1 = ResultMessageNotFound$1 | ResultStateInvalid$1 | ResultMessageDeferred;
+declare class Defer {
+  readonly schema: string;
+  readonly id: bigint;
+  readonly numAttempts: number;
+  readonly state: Buffer | null;
+  readonly dequeueAt: number | null;
+  constructor(params: {
+    schema: string;
+    id: bigint;
+    numAttempts: number;
+    state: Buffer | null;
+    dequeueAt: number | null;
+  });
+  execute(databaseClient: Client): Promise<Result$1>;
+}
+declare namespace heartbeat_d_exports {
+  export { Heartbeat, Result, ResultMessageHeartbeated, ResultMessageNotFound, ResultStateInvalid };
+}
+type ResultMessageNotFound = {
+  resultType: "MESSAGE_NOT_FOUND";
+};
+type ResultStateInvalid = {
+  resultType: "MESSAGE_STATE_INVALID";
+};
+type ResultMessageHeartbeated = {
+  resultType: "MESSAGE_HEARTBEATED";
+};
+type Result = ResultMessageNotFound | ResultStateInvalid | ResultMessageHeartbeated;
+declare class Heartbeat {
+  readonly schema: string;
+  readonly id: bigint;
+  readonly numAttempts: number;
+  readonly lockMs: number;
+  constructor(params: {
+    schema: string;
+    id: bigint;
+    numAttempts: number;
+    lockMs: number;
+  });
+  execute(databaseClient: Client): Promise<Result>;
+}
+declare namespace index_d_exports$4 {
+  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 channel, index_d_exports$4 as message };
+}
+//#endregion
+//#region src/queue/module/channel/message.d.ts
+declare class Message$1<T> {
+  private readonly schema;
+  private readonly channel;
+  private readonly adaptor;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    channel: string;
+  });
+  create(params: {
+    databaseClient: T;
+    content: Buffer;
+    dequeueAt?: number;
+  }): Promise<Result$4>;
+}
+declare namespace index_d_exports$3 {
+  export { Channel, Message$1 as Message };
+}
+declare class Channel<T> {
+  private readonly schema;
+  private readonly adaptor;
+  private readonly channel;
+  readonly message: Message$1<T>;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    channel: string;
+  });
+  set(params: {
+    databaseClient: T;
+    maxConcurrency?: number | null;
+    maxSize?: number | null;
+    releaseIntervalMs?: number | null;
+  }): Promise<void>;
+  release(params: {
+    databaseClient: T;
+  }): Promise<Result$5>;
+}
+declare namespace index_d_exports$2 {
+  export { Channel, index_d_exports$3 as channel };
+}
+declare namespace event_d_exports {
+  export { DecodeResult, DecodeResultMessageCompleted, DecodeResultMessageCreated, DecodeResultMessageDeferred, decode };
+}
+type DecodeResultMessageCreated = {
+  eventType: "MESSAGE_CREATED";
+  id: string;
+  dequeueAt: number;
+};
+type DecodeResultMessageCompleted = {
+  eventType: "MESSAGE_COMPLETED";
+  id: string;
+};
+type DecodeResultMessageDeferred = {
+  eventType: "MESSAGE_DEFERRED";
+  id: string;
+  dequeueAt: number;
+};
+type DecodeResult = DecodeResultMessageCreated | DecodeResultMessageCompleted | DecodeResultMessageDeferred;
+declare const decode: (payload: string) => DecodeResult;
+//#endregion
+//#region src/queue/message.d.ts
+declare class Message<T> {
+  private readonly schema;
+  private readonly adaptor;
+  readonly id: bigint;
+  readonly isUnlocked: boolean;
+  readonly content: Buffer;
+  readonly state: Buffer | null;
+  readonly numAttempts: number;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    id: bigint;
+    isUnlocked: boolean;
+    content: Buffer;
+    state: Buffer | null;
+    numAttempts: number;
+  });
+  defer(params: {
+    databaseClient: T;
+    state?: Buffer;
+    dequeueAt?: number;
+  }): Promise<Result$1>;
+  complete(params: {
+    databaseClient: T;
+  }): Promise<Result$2>;
+  heartbeat(params: {
+    databaseClient: T;
+    lockMs: number;
+  }): Promise<Result>;
+}
+declare namespace index_d_exports$1 {
+  export { DequeueResult, Message, Params, Queue, index_d_exports$2 as module };
+}
+type DequeueResult<T> = {
+  resultType: "MESSAGE_NOT_AVAILABLE";
+} | {
+  resultType: "MESSAGE_DEQUEUED";
+  message: Message<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 lockMs: number;
+  private readonly adaptor;
+  constructor(params: Params<T>);
+  dequeue(params: {
+    databaseClient: T;
+  }): Promise<DequeueResult<T>>;
+  channel(channel: string): Channel<T>;
+  install(params?: {
+    eventChannel?: string;
+  }): string[];
+  static decode(payload: string): DecodeResult;
+}
+//#endregion
+export { Queue, type index_d_exports as command, type database_d_exports as database, type event_d_exports as event, type index_d_exports$1 as queue };