lonnymq 1.0.2 → 1.1.0

package/dist/index.d.mts

@@ -0,0 +1,331 @@
+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;
+//#endregion
+//#region src/command/channel-policy/clear.d.ts
+declare class Clear {
+  readonly schema: string;
+  readonly channelId: string;
+  readonly createdAt: Date;
+  constructor(params: {
+    schema: string;
+    channelId: string;
+  });
+  execute(databaseClient: Client): Promise<void>;
+}
+//#endregion
+//#region src/command/channel-policy/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 createdAt: Date;
+  constructor(params: {
+    schema: string;
+    channelId: string;
+    maxConcurrency?: number | null;
+    maxSize?: number | null;
+    releaseIntervalMs?: number | null;
+  });
+  execute(databaseClient: Client): Promise<void>;
+}
+declare namespace index_d_exports$5 {
+  export { Clear, Set };
+}
+declare namespace create_d_exports {
+  export { Create, Result$4 as Result, ResultMessageCreated, ResultMessageDropped };
+}
+type ResultMessageCreated = {
+  resultType: "MESSAGE_CREATED";
+  id: bigint;
+  channelSize: number;
+};
+type ResultMessageDropped = {
+  resultType: "MESSAGE_DROPPED";
+};
+type Result$4 = ResultMessageCreated | ResultMessageDropped;
+declare class Create {
+  readonly schema: string;
+  readonly channelId: string;
+  readonly content: Buffer;
+  readonly dequeueAt: number | null;
+  constructor(params: {
+    schema: string;
+    channelId: 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;
+  channelId: string;
+  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 retire_d_exports {
+  export { Result$2 as Result, ResultMessageNotFound$2 as ResultMessageNotFound, ResultMessageRetired, ResultStateInvalid$2 as ResultStateInvalid, Retire };
+}
+type ResultMessageNotFound$2 = {
+  resultType: "MESSAGE_NOT_FOUND";
+};
+type ResultStateInvalid$2 = {
+  resultType: "STATE_INVALID";
+};
+type ResultMessageRetired = {
+  resultType: "MESSAGE_RETIRED";
+};
+type Result$2 = ResultMessageNotFound$2 | ResultStateInvalid$2 | ResultMessageRetired;
+declare class Retire {
+  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 { 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 };
+}
+declare namespace index_d_exports {
+  export { index_d_exports$5 as channelPolicy, index_d_exports$4 as message };
+}
+//#endregion
+//#region src/queue/module/channel/message.d.ts
+declare class Message$2<T> {
+  private readonly schema;
+  private readonly channelId;
+  private readonly adaptor;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    channelId: string;
+  });
+  create(params: {
+    databaseClient: T;
+    content: Buffer;
+    dequeueAt?: number;
+  }): Promise<Result$4>;
+}
+//#endregion
+//#region src/queue/module/channel/policy.d.ts
+declare class Policy<T> {
+  private readonly schema;
+  private readonly adaptor;
+  private readonly channelId;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    channelId: string;
+  });
+  set(params: {
+    databaseClient: T;
+    maxConcurrency?: number | null;
+    maxSize?: number | null;
+    releaseIntervalMs?: number | null;
+  }): Promise<void>;
+  clear(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>;
+}
+declare namespace index_d_exports$2 {
+  export { Channel, Message$1 as Message, index_d_exports$3 as channel };
+}
+declare namespace event_d_exports {
+  export { DecodeResult, DecodeResultMessageCreated, DecodeResultMessageDeferred, DecodeResultMessageRetired, decode };
+}
+type DecodeResultMessageCreated = {
+  eventType: "MESSAGE_CREATED";
+  id: string;
+  dequeueAt: number;
+};
+type DecodeResultMessageRetired = {
+  eventType: "MESSAGE_RETIRED";
+  id: string;
+};
+type DecodeResultMessageDeferred = {
+  eventType: "MESSAGE_DEFERRED";
+  id: string;
+  dequeueAt: number;
+};
+type DecodeResult = DecodeResultMessageCreated | DecodeResultMessageRetired | 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 channelId: string;
+  readonly content: Buffer;
+  readonly state: Buffer | null;
+  readonly numAttempts: number;
+  constructor(params: {
+    schema: string;
+    adaptor: Adaptor<T>;
+    id: bigint;
+    channelId: string;
+    isUnlocked: boolean;
+    content: Buffer;
+    state: Buffer | null;
+    numAttempts: number;
+  });
+  defer(params: {
+    databaseClient: T;
+    state?: Buffer;
+    dequeueAt?: number;
+  }): Promise<Result$1>;
+  retire(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>;
+} : {
+  schema: string;
+  adaptor: Adaptor<T>;
+};
+declare class Queue<T = Client> {
+  readonly schema: string;
+  readonly message: Message$1<T>;
+  private readonly adaptor;
+  constructor(params: Params<T>);
+  dequeue(params: {
+    databaseClient: T;
+    lockMs: number;
+  }): Promise<DequeueResult<T>>;
+  channel(channelId: 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 };