@supergrowthai/tq 1.0.1-canary.03bf985

package/dist/src/core/TaskStore.d.ts

@@ -0,0 +1,63 @@
+import { CronTask, IDatabaseAdapter } from '../adapters/index.js';
+declare class TaskStore<ID = any> {
+    private databaseAdapter;
+    constructor(databaseAdapter: IDatabaseAdapter<ID>);
+    /**
+     * Adds multiple tasks to the scheduled queue
+     */
+    addTasksToScheduled(tasks: CronTask<any>[]): Promise<any>;
+    /**
+     * Gets mature tasks that are ready to be processed
+     * Implements a two-phase approach:
+     * 1. Reset stale processing tasks
+     * 2. Fetch and mark new mature tasks
+     */
+    getMatureTasks(timestamp: number): Promise<CronTask<any>[]>;
+    /**
+     * Marks tasks as processing with current timestamp
+     */
+    markTasksAsProcessing(taskIds: ID[]): Promise<void>;
+    /**
+     * Marks tasks as executed/completed
+     */
+    markTasksAsExecuted(taskIds: ID[]): Promise<void>;
+    /**
+     * Marks tasks as failed and increments retry count
+     */
+    markTasksAsFailed(taskIds: ID[]): Promise<void>;
+    /**
+     * Updates multiple tasks with specific updates
+     */
+    updateTasks(updates: Array<{
+        id: ID;
+        updates: Partial<CronTask<any>>;
+    }>): Promise<void>;
+    /**
+     * Gets tasks by their IDs
+     */
+    getTasksByIds(taskIds: ID[]): Promise<CronTask<any>[]>;
+    /**
+     * Gets cleanup statistics
+     */
+    getCleanupStats(): Promise<{
+        orphanedTasks: number;
+        expiredTasks: number;
+    }>;
+    /**
+     * Cleans up orphaned and expired tasks
+     */
+    cleanupTasks(): Promise<void>;
+    /**
+     * Updates tasks for retry with new execution time and retry count
+     */
+    updateTasksForRetry(tasks: CronTask<any>[]): Promise<void>;
+    /**
+     * Marks tasks as successful/completed
+     */
+    markTasksAsSuccess(tasks: CronTask<any>[]): Promise<void>;
+    /**
+     * Marks tasks as ignored (same as failed for now)
+     */
+    markTasksAsIgnored(tasks: CronTask<any>[]): Promise<void>;
+}
+export { TaskStore };

package/dist/src/core/async/AsyncActions.d.ts

@@ -0,0 +1,22 @@
+import { TaskStore } from '../TaskStore.js';
+import { Actions } from '../Actions.js';
+import { IMessageQueue } from '@supergrowthai/mq';
+import { CronTask } from '../../adapters';
+import { TaskQueuesManager } from '../TaskQueuesManager.js';
+export declare class AsyncActions<ID = any> {
+    private messageQueue;
+    private taskStore;
+    private taskQueue;
+    private generateId;
+    private readonly actions;
+    private readonly taskId;
+    constructor(messageQueue: IMessageQueue, taskStore: TaskStore<ID>, taskQueue: TaskQueuesManager, actions: Actions, task: CronTask<any>, generateId: () => ID);
+    /**
+     * Called when the async promise completes to execute the collected actions
+     */
+    onPromiseFulfilled(): Promise<void>;
+    /**
+     * Schedule new tasks - replicates the logic from task-handler's addTasks
+     */
+    private scheduleNewTasks;
+}

package/dist/src/core/async/AsyncTaskManager.d.ts

@@ -0,0 +1,19 @@
+import { CronTask } from '../../adapters/index.js';
+import { IAsyncTaskManager } from './async-task-manager';
+export declare class AsyncTaskManager implements IAsyncTaskManager {
+    private asyncTasks;
+    private handedOffTaskIds;
+    private readonly maxTasks;
+    private totalHandedOff;
+    constructor(maxTasks?: number);
+    handoffTask(task: CronTask<any>, runningPromise: Promise<void>): boolean;
+    shutdown(): Promise<void>;
+    getMetrics(): {
+        activeTaskCount: number;
+        totalHandedOff: number;
+        maxTasks: number;
+        utilizationPercent: number;
+    };
+    isHandedOff(taskId: string): boolean;
+    canAcceptTask(): boolean;
+}

package/dist/src/core/async/async-task-manager.d.ts

@@ -0,0 +1,25 @@
+import { CronTask } from '../../adapters';
+/**
+ * Interface for managing async tasks that exceed timeout thresholds
+ * Implementation should be in tq package to access executor configs
+ */
+export interface IAsyncTaskManager<T = any, ID = any> {
+    /**
+     * Hand off a running task to async management
+     * @param message The message that is still being processed
+     * @param runningPromise The promise of the still-running task
+     * @returns true if accepted, false if queue is full
+     */
+    handoffTask(message: CronTask<T, ID>, runningPromise: Promise<void>): boolean;
+    /**
+     * Gracefully shutdown the async task manager
+     */
+    shutdown(): Promise<void>;
+    isHandedOff(taskId: ID): boolean;
+    canAcceptTask(): boolean;
+    getMetrics(): {
+        activeTaskCount: number;
+        totalHandedOff: number;
+        [key: string]: unknown;
+    };
+}

package/dist/src/core/base/interfaces.d.ts

@@ -0,0 +1,35 @@
+import { CronTask } from '../../adapters/types.js';
+export type ExecutorActions<T> = {
+    addTasks(task: CronTask<any>[]): void;
+    fail(task: CronTask<T>): void;
+    success(task: CronTask<T>): void;
+};
+interface IBaseExecutor<T> {
+    multiple: boolean;
+    default_retries?: number;
+    store_on_failure: boolean;
+    asyncConfig?: {
+        handoffTimeout: number;
+        maxConcurrentAsync?: number;
+    };
+}
+export interface IMultiTaskExecutor<T> extends IBaseExecutor<T> {
+    multiple: true;
+    onTasks(tasks: CronTask<T>[], action: ExecutorActions<T>): Promise<void>;
+}
+export interface ISingleTaskExecutor<T> extends IBaseExecutor<T> {
+    parallel: boolean;
+    multiple: false;
+    onTask(task: CronTask<T>, action: ExecutorActions<T>): Promise<void>;
+}
+export interface ISingleTaskNonParallel<T> extends ISingleTaskExecutor<T> {
+    parallel: false;
+    multiple: false;
+}
+export interface ISingleTaskParallel<T> extends ISingleTaskExecutor<T> {
+    chunkSize: number;
+    parallel: true;
+    multiple: false;
+}
+export type TaskExecutor<T> = IMultiTaskExecutor<T> | ISingleTaskNonParallel<T> | ISingleTaskParallel<T>;
+export {};

package/dist/src/core/environment.d.ts

@@ -0,0 +1,6 @@
+import { QueueName } from '@supergrowthai/mq';
+/**
+ * Gets all queue names for the current environment
+ * @returns Array of full queue names including environment suffix
+ */
+export declare function getEnabledQueues(): QueueName[];

package/dist/src/core/task-processor-types.d.ts

@@ -0,0 +1,14 @@
+import { CronTask } from '../adapters/index.js';
+/**
+ * Result from processing tasks - specific to TQ (Task Queue) logic
+ */
+export interface ProcessedTaskResult<PAYLOAD = any, ID = any> {
+    failedTasks: CronTask<PAYLOAD, ID>[];
+    newTasks: CronTask<PAYLOAD, ID>[];
+    successTasks: CronTask<PAYLOAD, ID>[];
+}
+/**
+ * Task processor function type that returns task execution results
+ * This is different from MQ's MessageProcessor which just consumes messages
+ */
+export type TaskProcessor<PAYLOAD = any, ID = any> = (queueId: string, tasks: CronTask<PAYLOAD, ID>[]) => Promise<ProcessedTaskResult<PAYLOAD, ID>>;

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './types.js';
+export * from './adapters/index.js';
+export { TaskStore } from './core/TaskStore.js';
+export { TaskHandler } from './core/TaskHandler.js';
+export { TaskRunner } from './core/TaskRunner.js';
+export { TaskQueuesManager } from './core/TaskQueuesManager.js';
+export { getEnabledQueues } from './core/environment.js';
+export { Actions } from './core/Actions.js';
+export { AsyncActions } from './core/async/AsyncActions.js';
+export { AsyncTaskManager } from './core/async/AsyncTaskManager.js';
+export * from './core/base/interfaces.js';
+export * from './core/task-processor-types.js';
+export * from './task-registry.js';
+export { setKeyGenerator } from './utils/task-id-gen.js';

package/dist/src/task-registry.d.ts

@@ -0,0 +1,4 @@
+type TasksTypeExt = string;
+export type TasksType = TasksTypeExt;
+declare const _default: {};
+export default _default;

package/dist/src/test/task-queue.test.d.ts

@@ -0,0 +1,6 @@
+declare module "@supergrowthai/mq" {
+    interface QueueRegistry {
+        "test-tq-queue": "test-tq-queue";
+    }
+}
+export {};

package/dist/src/types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/task-id-gen.d.ts

@@ -0,0 +1,4 @@
+import { CronTask } from '../adapters/index.js';
+import { CacheKeyGenerator } from 'memoose-js';
+export declare function tId<T>(task: CronTask<T>): any;
+export declare function setKeyGenerator(generator: CacheKeyGenerator): void;

package/dist/types.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@supergrowthai/tq",
+  "version": "1.0.1-canary.03bf985",
+  "description": "Task queue management library with multiple executor types and async task handling",
+  "repository": "https://github.com/captadexp/next-blog",
+  "homepage": "https://github.com/captadexp/next-blog/tree/main#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters/index.d.ts",
+      "import": "./dist/adapters/index.mjs",
+      "require": "./dist/adapters/index.js"
+    },
+    "./core/base/interfaces": {
+      "types": "./dist/core/base/interfaces.d.ts",
+      "import": "./dist/core/base/interfaces.mjs",
+      "require": "./dist/core/base/interfaces.js"
+    },
+    "./core/actions": {
+      "types": "./dist/core/Actions.d.ts",
+      "import": "./dist/core/Actions.mjs",
+      "require": "./dist/core/Actions.js"
+    },
+    "./core/actions/async": {
+      "types": "./dist/core/async/AsyncActions.d.ts",
+      "import": "./dist/core/async/AsyncActions.mjs",
+      "require": "./dist/core/async/AsyncActions.js"
+    },
+    "./core/async": {
+      "types": "./dist/core/async/AsyncTaskManager.d.ts",
+      "import": "./dist/core/async/AsyncTaskManager.mjs",
+      "require": "./dist/core/async/AsyncTaskManager.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/task-id-gen.d.ts",
+      "import": "./dist/utils/task-id-gen.mjs",
+      "require": "./dist/utils/task-id-gen.js"
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "dev": "vite build --watch",
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun src/test",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "author": "Capt ADExp <tech@developer.toys>",
+  "license": "MIT",
+  "dependencies": {
+    "@supergrowthai/mq": "1.0.1-canary.03bf985",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "mongodb": "^6.16.0"
+  },
+  "devDependencies": {
+    "@supergrowthai/utils": "1.0.1",
+    "@types/bun": "^1.3.1",
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "memoose-js": "^1.1.2"
+  }
+}