@rvoh/psychic-workers 0.2.1

package/dist/types/src/background/BaseBackgroundedModel.d.ts

@@ -0,0 +1,15 @@
+import { Dream } from '@rvoh/dream';
+import { BackgroundJobConfig } from './index.js';
+import { BackgroundableMethodArgs } from './BaseBackgroundedService.js';
+import { FunctionPropertyNames } from './types.js';
+export default class BaseBackgroundedModel extends Dream {
+    static get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedModel>;
+    get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedModel>;
+    static background<T, MethodName extends PsychicBackgroundedModelStaticMethods<T & typeof BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    static backgroundWithDelay<T, MethodName extends PsychicBackgroundedModelStaticMethods<T & typeof BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    get psychicTypes(): any;
+    background<T, MethodName extends PsychicBackgroundedServiceInstanceMethods<T & BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    backgroundWithDelay<T, MethodName extends PsychicBackgroundedServiceInstanceMethods<T & BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+}
+export type PsychicBackgroundedModelStaticMethods<T extends typeof BaseBackgroundedModel> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseBackgroundedModel>>;
+export type PsychicBackgroundedServiceInstanceMethods<T extends BaseBackgroundedModel> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<BaseBackgroundedModel>>;

package/dist/types/src/background/BaseBackgroundedService.d.ts

@@ -0,0 +1,17 @@
+import { Job } from 'bullmq';
+import { BackgroundJobConfig } from './index.js';
+import { FunctionPropertyNames } from './types.js';
+export default class BaseBackgroundedService {
+    static get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedService>;
+    static get globalName(): string;
+    static setGlobalName(globalName: string): void;
+    private static _globalName;
+    static background<T, MethodName extends PsychicBackgroundedServiceStaticMethods<T & typeof BaseBackgroundedService>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    static backgroundWithDelay<T, MethodName extends PsychicBackgroundedServiceStaticMethods<T & typeof BaseBackgroundedService>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    get psychicTypes(): any;
+}
+export type PsychicBackgroundedServiceStaticMethods<T extends typeof BaseBackgroundedService> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseBackgroundedService>>;
+export type PsychicBackgroundedServiceInstanceMethods<T extends BaseBackgroundedService> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<BaseBackgroundedService>>;
+type OmitJobFromEndOfArguments<Original extends unknown[]> = Original extends [Job] ? Original extends [string] ? Original : [] : Original extends [...infer Rest, Job] ? Original extends [...unknown[], string] ? Original : Rest : Original;
+export type BackgroundableMethodArgs<MethodFunc> = MethodFunc extends (...args: any) => any ? OmitJobFromEndOfArguments<Parameters<MethodFunc>> : never;
+export {};

package/dist/types/src/background/BaseScheduledService.d.ts

@@ -0,0 +1,11 @@
+import { BackgroundJobConfig } from './index.js';
+import { FunctionPropertyNames } from './types.js';
+export default class BaseScheduledService {
+    static get backgroundJobConfig(): BackgroundJobConfig<BaseScheduledService>;
+    static get globalName(): string;
+    static setGlobalName(globalName: string): void;
+    private static _globalName;
+    static schedule<T, MethodName extends FunctionPropertyNames<Required<T>>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends MethodFunc extends (...args: any) => any ? Parameters<MethodFunc> : never>(this: T, pattern: string, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    get psychicTypes(): any;
+}
+export type PsychicScheduledServiceStaticMethods<T extends typeof BaseScheduledService> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseScheduledService>>;

package/dist/types/src/background/index.d.ts

@@ -0,0 +1,101 @@
+import { Dream, IdType } from '@rvoh/dream';
+import { Job, Queue, Worker } from 'bullmq';
+import { PsychicBackgroundNativeBullMQOptions, PsychicBackgroundSimpleOptions } from '../psychic-application-workers/index.js';
+import BaseBackgroundedService from './BaseBackgroundedService.js';
+import BaseScheduledService from './BaseScheduledService.js';
+import { Either } from './types.js';
+type JobTypes = 'BackgroundJobQueueFunctionJob' | 'BackgroundJobQueueStaticJob' | 'BackgroundJobQueueModelInstanceJob';
+export interface BackgroundJobData {
+    id?: IdType;
+    method?: string;
+    args: any;
+    filepath?: string;
+    importKey?: string;
+    globalName?: string;
+}
+export declare class Background {
+    static get defaultQueueName(): string;
+    static get Worker(): typeof Worker;
+    static get Queue(): typeof Queue;
+    /**
+     * Used when adding jobs to the default queue
+     */
+    private defaultQueue;
+    /**
+     * Used when adding jobs to the default transitional queue
+     */
+    private defaultTransitionalQueue;
+    /**
+     * Used when adding jobs to a named queue
+     */
+    private namedQueues;
+    private groupNames;
+    private workstreamNames;
+    /**
+     * Used when adding jobs to a named transitioanl queue
+     */
+    private namedTransitionalQueues;
+    private _workers;
+    private redisConnections;
+    connect({ activateWorkers, }?: {
+        activateWorkers?: boolean;
+    }): void;
+    get queues(): Queue[];
+    get workers(): Worker<any, any, string>[];
+    private shutdownAndExit;
+    shutdown(): Promise<void>;
+    closeAllRedisConnections(): Promise<void>;
+    private simpleConnect;
+    private nativeBullMQConnect;
+    work(): void;
+    staticMethod(ObjectClass: Record<'name', string>, method: string, { delaySeconds, globalName, args, jobConfig, }: {
+        globalName: string;
+        filepath?: string;
+        delaySeconds?: number;
+        importKey?: string;
+        args?: any[];
+        jobConfig?: BackgroundJobConfig<any>;
+    }): Promise<void>;
+    scheduledMethod(ObjectClass: Record<'name', string>, pattern: string, method: string, { globalName, args, jobConfig, }: {
+        globalName: string;
+        filepath?: string;
+        importKey?: string;
+        args?: any[];
+        jobConfig?: BackgroundJobConfig<any>;
+    }): Promise<void>;
+    private queueInstance;
+    modelInstanceMethod(modelInstance: Dream, method: string, { delaySeconds, args, jobConfig, }: {
+        delaySeconds?: number;
+        importKey?: string;
+        args?: any[];
+        jobConfig?: BackgroundJobConfig<any>;
+    }): Promise<void>;
+    _addToQueue(jobType: JobTypes, jobData: BackgroundJobData, { delaySeconds, jobConfig, priority, groupId, }: {
+        delaySeconds?: number;
+        jobConfig: BackgroundJobConfig<any>;
+        priority: BackgroundQueuePriority;
+        groupId?: string;
+    }): Promise<void>;
+    private jobConfigToPriority;
+    private jobConfigToGroupId;
+    private jobConfigToGroup;
+    private groupIdToGroupConfig;
+    private mapPriorityWordToPriorityNumber;
+    doWork(job: Job): Promise<void>;
+}
+declare const background: Background;
+export default background;
+export declare function stopBackgroundWorkers(): Promise<void>;
+export type BackgroundQueuePriority = 'default' | 'urgent' | 'not_urgent' | 'last';
+interface BaseBackgroundJobConfig {
+    priority?: BackgroundQueuePriority;
+}
+export interface WorkstreamBackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService> extends BaseBackgroundJobConfig {
+    workstream?: T['psychicTypes']['workstreamNames'][number];
+}
+export interface QueueBackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService, PsyTypes extends T['psychicTypes'] = T['psychicTypes'], QueueGroupMap = PsyTypes['queueGroupMap'], Queue extends keyof QueueGroupMap = keyof QueueGroupMap, Groups extends QueueGroupMap[Queue] = QueueGroupMap[Queue], GroupId = Groups[number & keyof Groups]> extends BaseBackgroundJobConfig {
+    groupId?: GroupId;
+    queue?: Queue;
+}
+export type BackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService> = Either<WorkstreamBackgroundJobConfig<T>, QueueBackgroundJobConfig<T>>;
+export type PsychicBackgroundOptions = (PsychicBackgroundSimpleOptions & Partial<Record<Exclude<keyof PsychicBackgroundNativeBullMQOptions, keyof PsychicBackgroundSimpleOptions>, never>>) | (PsychicBackgroundNativeBullMQOptions & Partial<Record<Exclude<keyof PsychicBackgroundSimpleOptions, keyof PsychicBackgroundNativeBullMQOptions>, never>>);

package/dist/types/src/background/types.d.ts

@@ -0,0 +1,7 @@
+export type FunctionProperties<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
+};
+export type FunctionPropertyNames<T> = keyof FunctionProperties<T> & string;
+type Only<T, U> = T & Partial<Record<Exclude<keyof U, keyof T>, never>>;
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+export {};

package/dist/types/src/error/background/NoQueueForSpecifiedQueueName.d.ts

@@ -0,0 +1,5 @@
+export default class NoQueueForSpecifiedQueueName extends Error {
+    private queue;
+    constructor(queue: string);
+    get message(): string;
+}

package/dist/types/src/error/background/NoQueueForSpecifiedWorkstream.d.ts

@@ -0,0 +1,5 @@
+export default class NoQueueForSpecifiedWorkstream extends Error {
+    private workstream;
+    constructor(workstream: string);
+    get message(): string;
+}

package/dist/types/src/helpers/EnvInternal.d.ts

@@ -0,0 +1,6 @@
+import { Env } from '@rvoh/dream';
+declare const EnvInternal: Env<{
+    string: "NODE_ENV" | "PSYCHIC_CORE_DEVELOPMENT";
+    boolean: "DEBUG" | "PSYCHIC_CORE_DEVELOPMENT" | "REALLY_TEST_BACKGROUND_QUEUE";
+}, "NODE_ENV" | "PSYCHIC_CORE_DEVELOPMENT", never, "PSYCHIC_CORE_DEVELOPMENT" | "DEBUG" | "REALLY_TEST_BACKGROUND_QUEUE">;
+export default EnvInternal;

package/dist/types/src/index.d.ts

@@ -0,0 +1,7 @@
+export { default as background, Background, type BackgroundJobConfig, type BackgroundQueuePriority, stopBackgroundWorkers, } from './background/index.js';
+export { default as BaseBackgroundedModel } from './background/BaseBackgroundedModel.js';
+export { default as BaseBackgroundedService } from './background/BaseBackgroundedService.js';
+export { default as BaseScheduledService } from './background/BaseScheduledService.js';
+export { type BullMQNativeWorkerOptions, default as PsychicApplicationWorkers, type PsychicBackgroundNativeBullMQOptions, type PsychicBackgroundSimpleOptions, type PsychicBackgroundWorkstreamOptions, type QueueOptionsWithConnectionInstance, type RedisOrRedisClusterConnection, type TransitionalPsychicBackgroundSimpleOptions, } from './psychic-application-workers/index.js';
+export { default as NoQueueForSpecifiedQueueName } from './error/background/NoQueueForSpecifiedQueueName.js';
+export { default as NoQueueForSpecifiedWorkstream } from './error/background/NoQueueForSpecifiedWorkstream.js';

package/dist/types/src/psychic-application-workers/cache.d.ts

@@ -0,0 +1,4 @@
+import PsychicApplicationWorkers from './index.js';
+export declare function cachePsychicWorkersApplication(psychicWorkersApp: PsychicApplicationWorkers): void;
+export declare function getCachedPsychicWorkersApplication(): PsychicApplicationWorkers | undefined;
+export declare function getCachedPsychicWorkersApplicationOrFail(): PsychicApplicationWorkers;

package/dist/types/src/psychic-application-workers/index.d.ts

@@ -0,0 +1,200 @@
+import { PsychicApplication } from '@rvoh/psychic';
+import { QueueOptions, WorkerOptions } from 'bullmq';
+import { Cluster, Redis } from 'ioredis';
+import { PsychicBackgroundOptions } from '../background/index.js';
+export default class PsychicApplicationWorkers {
+    static init(psychicApp: PsychicApplication, cb: (app: PsychicApplicationWorkers) => void | Promise<void>): Promise<PsychicApplicationWorkers>;
+    /**
+     * Returns the cached psychic application if it has been set.
+     * If it has not been set, an exception is raised.
+     *
+     * The psychic application can be set by calling PsychicApplication#init
+     */
+    static getOrFail(): PsychicApplicationWorkers;
+    psychicApp: PsychicApplication;
+    constructor(psychicApp: PsychicApplication);
+    /**
+     * Returns the background options provided by the user
+     */
+    get backgroundOptions(): PsychicBackgroundOptions;
+    private _backgroundOptions;
+    private _hooks;
+    get hooks(): PsychicWorkersApplicationHooks;
+    on<T extends PsychicWorkersHookEventType>(hookEventType: T, cb: T extends 'workers:shutdown' ? () => void | Promise<void> : never): void;
+    set<Opt extends PsychicWorkersApplicationOption>(option: Opt, value: unknown): void;
+}
+export interface PsychicWorkersTypeSync {
+    workstreamNames: string[];
+    queueGroupMap: Record<string, string[]>;
+}
+export type PsychicWorkersApplicationOption = 'background';
+export type PsychicWorkersHookEventType = 'workers:shutdown';
+export interface PsychicWorkersApplicationHooks {
+    workerShutdown: (() => void | Promise<void>)[];
+}
+export interface BullMQNativeWorkerOptions extends WorkerOptions {
+    group?: {
+        id?: string;
+        maxSize?: number;
+        limit?: {
+            max?: number;
+            duration?: number;
+        };
+        concurrency?: number;
+        priority?: number;
+    };
+    concurrency?: number;
+    workerCount?: number;
+}
+export interface PsychicBackgroundNativeBullMQOptions extends PsychicBackgroundSharedOptions {
+    /**
+     * See https://docs.bullmq.io/guide/going-to-production for the different settings to use between
+     * queue and worker connections.
+     */
+    defaultQueueConnection?: RedisOrRedisClusterConnection;
+    defaultWorkerConnection?: RedisOrRedisClusterConnection;
+    nativeBullMQ: {
+        defaultQueueOptions?: QueueOptionsWithConnectionInstance;
+        /**
+         * named queues are useful for dispersing queues among nodes in a Redis cluster
+         * and for running queues on different Redis instances
+         */
+        namedQueueOptions?: Record<string, QueueOptionsWithConnectionInstance>;
+        /**
+         * Native BullMQ options to provide to configure the default workers
+         * for psychic. By default, Psychic leverages a single-queue system, with
+         * many workers running off the queue. Each worker receives the
+         * same worker configuration, so this configuration is really
+         * only used to supply the number of default workers that you want.
+         */
+        defaultWorkerOptions?: BullMQNativeWorkerOptions;
+        /**
+         * The number of default workers to run against the default Psychic
+         * background queues.
+         *
+         * By default, Psychic leverages a single-queue system, with
+         * many workers running off a single queue. This number determines
+         * the number of those default workers to provide.
+         */
+        defaultWorkerCount?: number;
+        /**
+         * namedQueueWorkers are necessary to work off namedQueues
+         * With BullMQ Pro, namedQueueWorkers can be rate limited (useful
+         * for interacting with external APIs)
+         */
+        namedQueueWorkers?: Record<string, BullMQNativeWorkerOptions>;
+    };
+}
+interface PsychicBackgroundSharedOptions {
+    /**
+     * If using BullMQ, these can be omitted. However, if you are using
+     * BullMQ Pro, you will need to provide the Queue and Worker
+     * classes custom from them.
+     */
+    providers?: {
+        Queue: any;
+        Worker: any;
+    };
+    defaultBullMQQueueOptions?: Omit<QueueOptions, 'connection'>;
+}
+export type QueueOptionsWithConnectionInstance = Omit<QueueOptions, 'connection'> & {
+    /**
+     * See https://docs.bullmq.io/guide/going-to-production for the different settings to use between
+     * queue and worker connections.
+     */
+    queueConnection?: RedisOrRedisClusterConnection;
+    workerConnection?: RedisOrRedisClusterConnection;
+};
+export interface PsychicBackgroundSimpleOptions extends PsychicBackgroundSharedOptions {
+    /**
+     * See https://docs.bullmq.io/guide/going-to-production for the different settings to use between
+     * queue and worker connections.
+     */
+    defaultQueueConnection: RedisOrRedisClusterConnection;
+    /**
+     * defaultWorkerConnection is only optional when workers will not be activated (e.g. on the webserver)
+     */
+    defaultWorkerConnection?: RedisOrRedisClusterConnection;
+    /**
+     * Every Psychic application that leverages simple background jobs will have a default
+     * workstream. Set workerCount to set the number of workers that will work through the
+     * default queue
+     */
+    defaultWorkstream?: {
+        workerCount?: number;
+        concurrency?: number;
+    };
+    /**
+     * When running background jobs on BullMQ, each named workstream corresponds
+     * to a specific queue and workers created for a named workstream are given
+     * a groupId corresponding to the workstream name
+     *
+     * named workstreams are useful for dispersing queues among nodes in a Redis cluster
+     * and for running queues on different Redis instances
+     *
+     * With BullMQ Pro, named workstreams can be rate limited (useful
+     * for interacting with external APIs)
+     */
+    namedWorkstreams?: PsychicBackgroundWorkstreamOptions[];
+    /**
+     * When transitioning from one instance of Redis to another, we can set up transitionalWorkstreams
+     * so that jobs already added to the legacy Redis instance continue to be worked. Once all jobs
+     * from the legacy Redis have been run, this configuration may be removed.
+     */
+    transitionalWorkstreams?: TransitionalPsychicBackgroundSimpleOptions;
+}
+export interface PsychicBackgroundWorkstreamOptions {
+    /**
+     * This will be the name of the queue (and the group if using BullMQ Pro)
+     */
+    name: string;
+    /**
+     * The number of workers you want to run on this configuration
+     */
+    workerCount?: number;
+    concurrency?: number;
+    /**
+     * See https://docs.bullmq.io/bullmq-pro/groups/rate-limiting for documentation
+     * on rate limiting in BullMQ Pro (requires paid BullMQ Pro license)
+     */
+    rateLimit?: {
+        max?: number;
+        duration?: number;
+    };
+    /**
+     * Optional redis connection. If not provided, the default background redis connection will be used.
+     * See https://docs.bullmq.io/guide/going-to-production for the different settings to use between
+     * queue and worker connections.
+     */
+    queueConnection?: RedisOrRedisClusterConnection;
+    workerConnection?: RedisOrRedisClusterConnection;
+}
+export interface PsychicBackgroundWorkstreamOptions {
+    /**
+     * This will be the name of the queue (and the group if using BullMQ Pro)
+     */
+    name: string;
+    /**
+     * The number of workers you want to run on this configuration
+     */
+    workerCount?: number;
+    concurrency?: number;
+    /**
+     * See https://docs.bullmq.io/bullmq-pro/groups/rate-limiting for documentation
+     * on rate limiting in BullMQ Pro (requires paid BullMQ Pro license)
+     */
+    rateLimit?: {
+        max?: number;
+        duration?: number;
+    };
+    /**
+     * Optional redis connection. If not provided, the default background redis connection will be used.
+     * See https://docs.bullmq.io/guide/going-to-production for the different settings to use between
+     * queue and worker connections.
+     */
+    queueConnection?: RedisOrRedisClusterConnection;
+    workerConnection?: RedisOrRedisClusterConnection;
+}
+export type TransitionalPsychicBackgroundSimpleOptions = Omit<PsychicBackgroundSimpleOptions, 'providers' | 'defaultBullMQQueueOptions' | 'transitionalWorkstreams'>;
+export type RedisOrRedisClusterConnection = Redis | Cluster;
+export {};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "type": "module",
+  "name": "@rvoh/psychic-workers",
+  "description": "Background job system for Psychic applications",
+  "version": "0.2.1",
+  "author": "RVOHealth",
+  "repository": "https://github.com/rvohealth/psychic-workers.git",
+  "license": "MIT",
+  "main": "./dist/cjs/src/index.js",
+  "module": "./dist/esm/src/index.js",
+  "types": "./dist/types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/cjs/src/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "publish": "yarn npm publish",
+    "psy": "yarn psyts",
+    "psyjs": "node ./dist/test-app/src/cli/index.js",
+    "psyts": "node --experimental-specifier-resolution=node --import ./bin/esm.js ./test-app/src/cli/index.ts",
+    "build": "echo \"building cjs...\" && rm -rf dist && npx tsc -p ./tsconfig.cjs.build.json && echo \"building esm...\" && npx tsc -p ./tsconfig.esm.build.json",
+    "uspec": "vitest --config ./spec/unit/vite.config.ts",
+    "format": "yarn run prettier . --write",
+    "lint": "yarn run eslint --no-warn-ignored \"src/**/*.ts\" && yarn run prettier . --check",
+    "prepack": "yarn build",
+    "dev-worker": "NODE_ENV=development WORKER_COUNT=1 ts-node --transpile-only ./test-app/worker.ts"
+  },
+  "peerDependencies": {
+    "@rvoh/dream": "*",
+    "@rvoh/psychic": "*",
+    "bullmq": "*",
+    "ioredis": "*"
+  },
+  "devDependencies": {
+    "@eslint/js": "=9.0.0",
+    "@rvoh/dream": "^0.29.1",
+    "@rvoh/dream-spec-helpers": "^0.2.0",
+    "@rvoh/psychic": "^0.24.1",
+    "@rvoh/psychic-spec-helpers": "^0.3.0",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "@socket.io/redis-emitter": "^5.1.0",
+    "@types/express": "^4",
+    "@types/luxon": "^3.4.2",
+    "@types/node": "^22.5.1",
+    "@types/pg": "^8",
+    "@types/supertest": "^6.0.2",
+    "bullmq": "^5.12.12",
+    "eslint": "^9.9.1",
+    "express": "^4.21.2",
+    "ioredis": "^5.4.1",
+    "kysely": "^0.27.5",
+    "kysely-codegen": "^0.17.0",
+    "luxon": "^3.5.0",
+    "luxon-jest-matchers": "^0.1.14",
+    "pg": "^8.13.1",
+    "prettier": "^3.3.3",
+    "socket.io": "^4.8.1",
+    "socket.io-adapter": "^2.5.5",
+    "supertest": "^7.0.0",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.7.0",
+    "typedoc": "^0.26.6",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "=7.18.0",
+    "vitest": "^3.0.8"
+  },
+  "packageManager": "yarn@4.4.1"
+}