tspace-mysql 1.9.3 → 1.9.4-beta.2

package/dist/lib/core/Queue/types.d.ts

@@ -0,0 +1,40 @@
+import { Worker } from "./worker";
+import type { T } from "..";
+import type { Job, QueueContract } from ".";
+export type JobInternal = Job & {
+    __job: T.Result<Worker>;
+};
+export type Handler = (job: Job) => any | Promise<any>;
+export type State = {
+    handler: Handler;
+    idle: number;
+    sleeping: boolean;
+    running: number;
+    opts: Required<QueueProcessOptions>;
+};
+export type QueueAddOptions = {
+    delayMs?: number;
+    priority?: number;
+    metadata?: Record<string, any>;
+    maxAttempts?: number;
+};
+export type QueueProcessOptions = {
+    interval?: number;
+    concurrency?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 15 | 20 | 25 | 30;
+};
+export type BufferedJob = {
+    jobData: T.Result<Worker>;
+    resolve: (value: any) => void;
+    reject: (reason?: any) => void;
+};
+export type JobStatus = 'pending' | 'active' | 'completed' | 'failed';
+type QueueEvents = QueueContract extends {
+    events: infer E;
+} ? E : never;
+type QueueJobs = QueueContract extends {
+    jobs: infer J;
+} ? J : never;
+export type EventName = QueueEvents extends Record<string, readonly string[]> ? keyof QueueEvents & string : string;
+export type EventJobName<E extends EventName> = QueueEvents extends Record<string, readonly string[]> ? E extends keyof QueueEvents ? QueueEvents[E][number] extends never ? string : QueueEvents[E][number] : string : string;
+export type JobName = QueueJobs extends readonly string[] ? QueueJobs[number] extends never ? string : QueueJobs[number] : string;
+export {};

package/dist/lib/core/Queue/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/lib/core/Queue/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/core/Queue/types.ts"],"names":[],"mappings":""}

package/dist/lib/core/Queue/worker.d.ts

@@ -0,0 +1,103 @@
+import type { T } from "../UtilityTypes";
+import { Blueprint } from "../Blueprint";
+import { Model } from "../Model";
+import type { Handler, QueueAddOptions, QueueProcessOptions } from "./types";
+declare const schema: {
+    id: Blueprint<number>;
+    uuid: Blueprint<string | null>;
+    name: Blueprint<string>;
+    status: Blueprint<T.Default<NonNullable<"pending" | "active" | "completed" | "failed">>>;
+    priority: Blueprint<T.Default<number>>;
+    payload: Blueprint<string | null>;
+    result: Blueprint<string | null>;
+    error: Blueprint<string | null>;
+    metadata: Blueprint<string | null>;
+    attempts: Blueprint<T.Default<number>>;
+    max_attempts: Blueprint<T.Default<number>>;
+    delay_ms: Blueprint<T.Default<number>>;
+    locked_by: Blueprint<string | null>;
+    locked_at: Blueprint<T.DateTime | null>;
+    available_at: Blueprint<NonNullable<T.DateTime>>;
+    completed_at: Blueprint<T.DateTime | null>;
+    created_at: Blueprint<T.DateTime | null>;
+    updated_at: Blueprint<T.DateTime | null>;
+};
+export declare class Worker extends Model<T.Schema<typeof schema>> {
+    private HOSTNAME;
+    private INSPECT_EXEC;
+    private STOPPING;
+    private IS_FLUSHING;
+    private ACTIVE_JOBS;
+    private MAX_IDLE_RETRIES;
+    private BATCH_SIZE;
+    private MAX_WAIT_MS;
+    private POLL;
+    private BUFFER;
+    private WORKER_STATE;
+    private EVENT_SUBSCRIBERS;
+    protected boot(): void;
+    initialize(opts?: {
+        inspect?: boolean;
+        flush?: boolean;
+        hostname?: string;
+        maxIdleRetries?: number;
+        poll?: {
+            enabled?: boolean;
+            interval?: number;
+        };
+    }): Promise<this>;
+    shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    getJobOverallStats(name?: string): Promise<{
+        total: number;
+        completed: number;
+        active: number;
+        pending: number;
+        failed: number;
+    }>;
+    getJobStats(name?: string): Promise<{
+        name: string;
+        completed: number;
+        active: number;
+        pending: number;
+        failed: number;
+    }[]>;
+    getJobs(name?: string): Promise<{
+        [x: string]: unknown;
+        id: number;
+        uuid: string | null;
+        name: string;
+        status: "pending" | "active" | "completed" | "failed";
+        priority: number;
+        payload: string | null;
+        result: string | null;
+        error: string | null;
+        metadata: string | null;
+        attempts: number;
+        max_attempts: number;
+        delay_ms: number;
+        locked_by: string | null;
+        locked_at: T.DateTime | null;
+        available_at: NonNullable<T.DateTime>;
+        completed_at: T.DateTime | null;
+        created_at: T.DateTime | null;
+        updated_at: T.DateTime | null;
+    }[]>;
+    getNames(): Promise<any[]>;
+    add(name: string, payload: any, opts?: QueueAddOptions): Promise<void>;
+    process(name: string, handler: Handler, opts?: QueueProcessOptions): Promise<void>;
+    publish(event: string, payload: any, opts?: QueueAddOptions): Promise<void>;
+    subscribe(event: string, name: string, handler: Handler, opts?: QueueProcessOptions): Promise<void>;
+    private _runJob;
+    private _executeJob;
+    private _dequeueMany;
+    private _flushBuffer;
+    private _wakeWorker;
+    private _pollWorkerJobs;
+    private _initializeWorkerJobs;
+    private _getPendingOrFailedJobs;
+    private _safeJsonParse;
+    private _safeJsonStringify;
+    private _sleep;
+}
+export {};