@autofleet/sheilta 2.2.8 → 2.4.0

package/lib/index.d.cts

@@ -1,9 +1,15 @@
-import { Op, literal } from "sequelize";
-import { Handler } from "express";
+import { Model, ModelStatic, Op, Sequelize, WhereOptions, literal } from "sequelize";
+import { Handler, Router } from "express";
 import { LoggerInstanceManager } from "@autofleet/logger";
+import { RedisClientType, createClient } from "redis";
+import rabbit from "@autofleet/rabbit";
+import { z, z as z$1 } from "zod/v3";
+import { EventEmitter } from "node:events";
 
-//#region src/operators/index.d.ts
+//#region rolldown:runtime
 
+//#endregion
+//#region src/operators/index.d.ts
 declare const formatOperators: (sequelize?: {
   Op: typeof Op;
 }) => Record<string, symbol>;
@@ -180,7 +186,7 @@ interface QueryHandlerOptions {
     count: number;
   }, queryValues: QueryValues) => any;
 }
-type Asyncify<T extends (...a: any[]) => any> = (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+type Asyncify$1<T extends (...a: any[]) => any> = (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
 declare const queryHandler: ({
   model,
   logger,
@@ -190,7 +196,417 @@ declare const queryHandler: ({
   additionalScopes,
   modifyQueryValues,
   onRowsRetrieved
-}: QueryHandlerOptions) => Asyncify<Handler>;
+}: QueryHandlerOptions) => Asyncify$1<Handler>;
+//#endregion
+//#region src/bulker/src/types.d.ts
+type Id = string | number;
+interface JobMetadata {
+  status: string;
+  total: number;
+  action: string;
+}
+interface ConsumeOptions {
+  enableRabbitTrace?: boolean;
+  [key: string]: any;
+}
+interface JobStatus {
+  jobId: string;
+  status: string;
+  action: string;
+  total: number;
+  queued: number;
+  processed: number;
+  succeeded: number;
+  failed: number;
+  errors: any[];
+  createdAt?: string;
+  updatedAt?: string;
+  duration: {
+    startTime: string | null;
+    endTime: string | null;
+    durationMs: number | null;
+  };
+}
+type MessageAck = () => Promise<void>;
+type MessageNack = (err?: Error, requeue?: boolean) => Promise<void>;
+type BulkPerIdHandler<T = any> = (args: {
+  jobId?: string;
+  id: Id;
+  payload: T;
+}, ack: MessageAck, nack: MessageNack) => Promise<void>;
+interface AdditionalIdsHookData<T = any> {
+  rawPayload: {
+    query: Record<string, any>;
+    include?: any[];
+    searchTerm: string;
+  };
+  payload: T;
+}
+interface BulkRouteOptions<T = any> {
+  /** e.g. "change-state" - the action identifier sent in request body */
+  action: string;
+  /** Sequelize model from which to scan IDs */
+  model: Model<any, any> | ModelStatic<any> | any;
+  modelScopes: string[];
+  /** Per-ID handler that performs the operation */
+  consumer: BulkPerIdHandler<T>;
+  consumerOptions?: ConsumeOptions;
+  rabbitQueueName?: string;
+  payloadSchema?: z.ZodType<T>;
+  /** Identity Scopes to be provided and are used and validated from the query.query object */
+  identityScopes?: string[];
+  queryFunction?: (reqBody: any) => Promise<Record<string, any>[]>;
+  idField?: string;
+  pageSize?: number;
+  workerConcurrency?: number;
+  jobAttempts?: number;
+  jobBackoffMs?: number;
+  removeOnComplete?: boolean | number;
+  removeOnFail?: boolean | number;
+  /** Inject tenant/RBAC filters (AND-ed with user query) */
+  contextWhere?: (payload: T) => WhereOptions;
+  /**
+  * Hook to provide additional IDs that will be OR-ed with the main query.
+  * This is useful when you need to manually fetch additional IDs based on the raw request body.
+  * The returned IDs will be included in the where clause using an OR statement.
+  *
+  * @example
+  * additionalIdsHook: async (data) => {
+  *   const { rawPayload, payload } = reqBody;
+  *   if (!rawPayload.searchTerm) return [];
+  *   const filters = rawPayload?.query?.fleetId ? { fleetId: query.query.fleetId } : {};
+  *   const labelIds = await searchDriversByLabelsValue(rawPayload.searchTerm, filters);
+  *   const vendorIds = await searchDriversByVendorName(rawPayload.searchTerm, filters);
+  *   return [...labelIds, ...vendorIds];
+  * }
+  */
+  additionalIdsHook?: (data: AdditionalIdsHookData) => Promise<Id[]>;
+}
+interface BulkRouterEvents$1 {
+  "job:created": (data: {
+    jobId: string;
+    action: string;
+    total: number;
+  }) => void;
+  "job:started": (data: {
+    jobId: string;
+    action: string;
+  }) => void;
+  "job:queued": (data: {
+    jobId: string;
+    action: string;
+    queued: number;
+    total: number;
+  }) => void;
+  "job:completed": (data: {
+    jobId: string;
+    action: string;
+    processed: number;
+    failed: number;
+    duration: number;
+  }) => void;
+  "job:canceled": (data: {
+    jobId: string;
+    action: string;
+  }) => void;
+  "job:failed": (data: {
+    jobId: string;
+    action: string;
+    error: string;
+  }) => void;
+  "item:processing": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "item:processed": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "item:failed": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+    error: string;
+  }) => void;
+  "item:retrying": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "worker:started": (data: {
+    action: string;
+    queueName: string;
+  }) => void;
+  "worker:error": (data: {
+    action: string;
+    error: string;
+  }) => void;
+  "scan:page": (data: {
+    jobId: string;
+    action: string;
+    pageNumber: number;
+    itemsInPage: number;
+  }) => void;
+}
+/**
+* Interface for event emitters with the emitEvent helper method
+*/
+interface IBulkEventEmitter {
+  emitEvent<K extends keyof BulkRouterEvents$1>(event: K, ...args: Parameters<BulkRouterEvents$1[K]>): void;
+}
+//#endregion
+//#region src/bulker/src/BulkRoute.d.ts
+type Asyncify<T extends (...a: any[]) => any> = (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+declare class BulkRoute<T = any> {
+  private readonly bulker;
+  private readonly opts;
+  readonly action: string;
+  private readonly model;
+  private readonly consumer;
+  private readonly idField;
+  private readonly pageSize;
+  private readonly rabbitQueueName;
+  private readonly rabbit;
+  private readonly consumerOptions;
+  private readonly queryFunction?;
+  private readonly payloadSchema?;
+  private readonly identityScopeSchema;
+  private readonly modelScopes;
+  constructor(bulker: Bulker, opts: BulkRouteOptions<T>);
+  bulkHandler: Asyncify<Handler>;
+  /** Get user jobs - public method for BulkRouter to use */
+  getUserJobs(userId: string, limit?: number): Promise<(JobStatus | null)[]>;
+  private rabbitScanAndEnqueue;
+  startRabbitWorker(): Promise<void>;
+}
+//#endregion
+//#region src/bulker/src/BulkRouter.d.ts
+declare class BulkRouter {
+  private readonly bulker;
+  private readonly router;
+  private routes;
+  private actionsToRouteMap;
+  private staticRoute;
+  constructor(bulker: Bulker, router?: Router, staticRoute?: string);
+  private registerStaticRoutes;
+  addAction<T = any>(actionName: string, opts: Omit<BulkRouteOptions<T>, "action">): BulkRoute<T>;
+  private bulkHandler;
+  private getJobHandler;
+  private cancelJobHandler;
+  private getMyJobsHandler;
+  /** Get the configured router instance */
+  getRouter(): Router;
+}
+//#endregion
+//#region src/bulker/src/events.d.ts
+interface BulkRouterEvents {
+  "job:created": (data: {
+    jobId: string;
+    action: string;
+    total: number;
+  }) => void;
+  "job:started": (data: {
+    jobId: string;
+    action: string;
+  }) => void;
+  "job:queued": (data: {
+    jobId: string;
+    action: string;
+    queued: number;
+    total: number;
+  }) => void;
+  "job:completed": (data: {
+    jobId: string;
+    action: string;
+    processed: number;
+    failed: number;
+    duration: number;
+  }) => void;
+  "job:canceled": (data: {
+    jobId: string;
+    action: string;
+  }) => void;
+  "job:failed": (data: {
+    jobId: string;
+    action: string;
+    error: string;
+  }) => void;
+  "item:processing": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "item:processed": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "item:failed": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+    error: string;
+  }) => void;
+  "item:retrying": (data: {
+    jobId: string;
+    action: string;
+    id: string | number;
+  }) => void;
+  "worker:started": (data: {
+    action: string;
+    queueName: string;
+  }) => void;
+  "worker:error": (data: {
+    action: string;
+    error: string;
+  }) => void;
+  "scan:page": (data: {
+    jobId: string;
+    action: string;
+    pageNumber: number;
+    itemsInPage: number;
+  }) => void;
+}
+interface BulkEventEmitter extends EventEmitter {
+  on<K extends keyof BulkRouterEvents>(event: K, listener: BulkRouterEvents[K]): this;
+  once<K extends keyof BulkRouterEvents>(event: K, listener: BulkRouterEvents[K]): this;
+  off<K extends keyof BulkRouterEvents>(event: K, listener: BulkRouterEvents[K]): this;
+  removeListener<K extends keyof BulkRouterEvents>(event: K, listener: BulkRouterEvents[K]): this;
+  emit<K extends keyof BulkRouterEvents>(event: K, ...args: Parameters<BulkRouterEvents[K]>): boolean;
+}
+interface EmitsBulkEvents {
+  emitEvent<K extends keyof BulkRouterEvents>(event: K, ...args: Parameters<BulkRouterEvents[K]>): void;
+}
+//#endregion
+//#region src/bulker/src/JobManager.d.ts
+/**
+* Manages all job-related operations in Redis
+* Centralizes job creation, status updates, cancellation, and user job tracking
+*/
+declare class JobManager {
+  private eventEmitter?;
+  private readonly redis;
+  private readonly defaults;
+  constructor(redis: RedisClientType, defaults?: {
+    maxJobsPerUser?: number;
+    jobTtlSeconds?: number;
+    errorLogLimit?: number;
+  });
+  /** Set event emitter for emitting job events */
+  setEventEmitter(emitter: EmitsBulkEvents): void;
+  /** Generate Redis key for job */
+  static jobKey(jobId: string): string;
+  /** Generate Redis key for user jobs list */
+  static userJobsKey(userId: string): string;
+  /**
+  * Initialize a new job in Redis
+  */
+  initJob(jobId: string, meta: JobMetadata): Promise<void>;
+  /**
+  * Get job status from Redis
+  */
+  getJob(jobId: string): Promise<JobStatus | null>;
+  /**
+  * Set a single field on a job
+  */
+  setJobField(jobId: string, field: string, value: string): Promise<boolean>;
+  /**
+  * Set multiple fields on a job
+  */
+  setJobFields(jobId: string, fields: Record<string, string>): Promise<boolean>;
+  /**
+  * Increment a counter field on a job
+  */
+  incrJobField(jobId: string, field: "queued" | "processed" | "succeeded" | "failed", by?: number): Promise<number>;
+  /**
+  * Get a single field from a job
+  */
+  getJobField(jobId: string, field: string): Promise<string | undefined>;
+  /**
+  * Cancel a job
+  */
+  cancelJob(jobId: string): Promise<boolean>;
+  /**
+  * Mark job as completed (for jobs with no items to process)
+  */
+  completeEmptyJob(jobId: string): Promise<void>;
+  /**
+  * Handle successful message processing (ack)
+  * Uses Redis Lua script for atomic operation
+  */
+  ack(jobId: string): Promise<void>;
+  /**
+  * Handle failed message processing (nack)
+  * Uses Redis Lua script for atomic operation
+  */
+  nack(jobId: string, errorMsg: string, data: any): Promise<void>;
+  /**
+  * Add a job to user's job list
+  */
+  addUserJob(userId: string, jobId: string): Promise<void>;
+  /**
+  * Remove a job from user's job list
+  */
+  removeUserJob(userId: string, jobId: string): Promise<void>;
+  /**
+  * Get all jobs for a user
+  */
+  getUserJobs(userId: string, limit?: number): Promise<(JobStatus | null)[]>;
+}
+//#endregion
+//#region src/bulker/src/Errors.d.ts
+declare class BulkerError extends Error {
+  readonly retryable: boolean;
+  constructor(message: string, retryable?: boolean);
+  static isBulkerError(err: unknown): err is BulkerError;
+  static wrap(err: unknown, message?: string, retryable?: boolean): BulkerError;
+  static retryable(message: string): BulkerError;
+  static nonRetryable(message: string): BulkerError;
+}
+declare namespace index_d_exports {
+  export { BulkEventEmitter, BulkRoute, BulkRouteOptions, BulkRouterEvents$1 as BulkRouterEvents, Bulker, BulkerError, BulkerInit, IBulkEventEmitter, JobManager, JobMetadata, JobStatus, z$1 as z };
+}
+interface BulkerInit {
+  sequelize: Sequelize;
+  logger: LoggerInstanceManager;
+  rabbit: rabbit;
+  redis: RedisClientType | ReturnType<typeof createClient> | {
+    host: string;
+    port?: number;
+    password?: string;
+    db?: number;
+  };
+  getUserId?: () => string | null;
+  emitEvents?: boolean;
+  defaults?: {
+    pageSize?: number;
+    maxJobsPerUser?: number;
+    idField?: string;
+    workerConcurrency?: number;
+    jobTtlSeconds?: number;
+    errorLogLimit?: number;
+  };
+}
+declare class Bulker extends EventEmitter implements BulkEventEmitter {
+  readonly sequelize: Sequelize;
+  readonly logger: BulkerInit["logger"];
+  readonly redis: RedisClientType;
+  readonly rabbit: rabbit;
+  readonly defaults: Required<NonNullable<BulkerInit["defaults"]>>;
+  readonly jobManager: JobManager;
+  private readonly bulkRouters;
+  getUserId: BulkerInit["getUserId"];
+  readonly eventsEnabled: boolean;
+  constructor(init: BulkerInit);
+  createBulkRouter(router?: Router, staticRoute?: string): BulkRouter;
+  /**
+  * Emit event only if events are enabled.
+  * Centralizes the eventsEnabled check to avoid repetition.
+  */
+  emitEvent<K extends keyof BulkRouterEvents>(event: K, ...args: Parameters<BulkRouterEvents[K]>): void;
+}
 //#endregion
-export { type LiteralAttribute, type MiddlewareValidationOption, formatOperators, generateFilterReplacements, queryFormatMiddleware, queryHandler, queryValidationMiddleware, validatePayload };
+export { index_d_exports as Bulker, type LiteralAttribute, type MiddlewareValidationOption, formatOperators, generateFilterReplacements, queryFormatMiddleware, queryHandler, queryValidationMiddleware, validatePayload };
 //# sourceMappingURL=index.d.cts.map