@zintrust/workers 0.1.27

package/src/storage/WorkerStore.ts

@@ -0,0 +1,240 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+
+import type { IDatabase } from '@zintrust/core';
+import type { Redis } from 'ioredis';
+
+export type WorkerRecord = {
+  name: string;
+  queueName: string;
+  version: string | null;
+  status: string;
+  autoStart: boolean;
+  concurrency: number;
+  region: string | null;
+  processorPath?: string | null;
+  features?: Record<string, unknown> | null;
+  infrastructure?: Record<string, unknown> | null;
+  datacenter?: Record<string, unknown> | null;
+  createdAt: Date;
+  updatedAt: Date;
+  lastHealthCheck?: Date;
+  lastError?: string;
+  connectionState?: 'disconnected' | 'connecting' | 'connected' | 'error';
+};
+
+export type WorkerStore = {
+  init(): Promise<void>;
+  list(options?: { offset?: number; limit?: number; search?: string }): Promise<WorkerRecord[]>;
+  get(name: string): Promise<WorkerRecord | null>;
+  save(record: WorkerRecord): Promise<void>;
+  update(name: string, patch: Partial<WorkerRecord>): Promise<void>;
+  remove(name: string): Promise<void>;
+};
+
+const now = (): Date => new Date();
+
+const mergeRecord = (current: WorkerRecord, patch: Partial<WorkerRecord>): WorkerRecord => ({
+  ...current,
+  ...patch,
+  updatedAt: patch.updatedAt ?? now(),
+});
+
+const serializeDbWorker = (record: WorkerRecord): Record<string, unknown> => ({
+  name: record.name,
+  queue_name: record.queueName,
+  version: record.version,
+  status: record.status,
+  auto_start: record.autoStart,
+  concurrency: record.concurrency,
+  region: record.region,
+  processor_path: record.processorPath ?? null,
+  features: record.features ? JSON.stringify(record.features) : null,
+  infrastructure: record.infrastructure ? JSON.stringify(record.infrastructure) : null,
+  datacenter: record.datacenter ? JSON.stringify(record.datacenter) : null,
+  created_at: record.createdAt,
+  updated_at: record.updatedAt,
+  last_health_check: record.lastHealthCheck ?? null,
+  last_error: record.lastError ?? null,
+  connection_state: record.connectionState ?? null,
+});
+
+const getHealthCheck = (row: Record<string, unknown>): Date | undefined => {
+  if (!row['last_health_check']) {
+    return undefined;
+  }
+  return row['last_health_check'] instanceof Date
+    ? row['last_health_check']
+    : new Date(String(row['last_health_check']));
+};
+
+const deserializeDbWorker = (row: Record<string, unknown>): WorkerRecord => {
+  const parseJson = (value: unknown): Record<string, unknown> | null => {
+    if (typeof value !== 'string' || value.trim() === '') return null;
+    try {
+      return JSON.parse(value) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  };
+
+  return {
+    name: String(row['name'] ?? ''),
+    queueName: String(row['queue_name'] ?? ''),
+    version: row['version'] ? String(row['version']) : null,
+    status: String(row['status'] ?? 'unknown'),
+    autoStart: Boolean(row['auto_start'] ?? false),
+    concurrency: Number(row['concurrency'] ?? 0),
+    region: row['region'] ? String(row['region']) : null,
+    processorPath: row['processor_path'] ? String(row['processor_path']) : null,
+    features: parseJson(row['features']),
+    infrastructure: parseJson(row['infrastructure']),
+    datacenter: parseJson(row['datacenter']),
+    createdAt:
+      row['created_at'] instanceof Date ? row['created_at'] : new Date(String(row['created_at'])),
+    updatedAt:
+      row['updated_at'] instanceof Date ? row['updated_at'] : new Date(String(row['updated_at'])),
+    lastHealthCheck: getHealthCheck(row),
+    lastError: row['last_error'] ? String(row['last_error']) : undefined,
+    connectionState: row['connection_state']
+      ? (String(row['connection_state']) as 'disconnected' | 'connecting' | 'connected' | 'error')
+      : undefined,
+  };
+};
+
+export const InMemoryWorkerStore = Object.freeze({
+  create(): WorkerStore {
+    const store = new Map<string, WorkerRecord>();
+
+    return {
+      async init(): Promise<void> {
+        return undefined;
+      },
+      async list(options?: { offset?: number; limit?: number }): Promise<WorkerRecord[]> {
+        let values = Array.from(store.values());
+        if (options) {
+          const start = options.offset || 0;
+          const end = options.limit ? start + options.limit : undefined;
+          values = values.slice(start, end);
+        }
+        return values;
+      },
+      async get(name: string): Promise<WorkerRecord | null> {
+        return store.get(name) ?? null;
+      },
+      async save(record: WorkerRecord): Promise<void> {
+        store.set(record.name, record);
+      },
+      async update(name: string, patch: Partial<WorkerRecord>): Promise<void> {
+        const current = store.get(name);
+        if (!current) return;
+        store.set(name, mergeRecord(current, patch));
+      },
+      async remove(name: string): Promise<void> {
+        store.delete(name);
+      },
+    };
+  },
+});
+
+export const RedisWorkerStore = Object.freeze({
+  create(client: Redis, keyPrefix = 'workers:registry'): WorkerStore {
+    const key = keyPrefix;
+
+    const serialize = (record: WorkerRecord): string =>
+      JSON.stringify({
+        ...record,
+        createdAt: record.createdAt.toISOString(),
+        updatedAt: record.updatedAt.toISOString(),
+      });
+
+    const deserialize = (raw: string): WorkerRecord => {
+      const parsed = JSON.parse(raw) as Omit<WorkerRecord, 'createdAt' | 'updatedAt'> & {
+        createdAt: string;
+        updatedAt: string;
+      };
+      return {
+        ...parsed,
+        createdAt: new Date(parsed.createdAt),
+        updatedAt: new Date(parsed.updatedAt),
+      };
+    };
+
+    return {
+      async init(): Promise<void> {
+        return undefined;
+      },
+      async list(options?: { offset?: number; limit?: number }): Promise<WorkerRecord[]> {
+        const all = await client.hgetall(key);
+        let values = Object.values(all).map(deserialize);
+        values.sort((a, b) => a.name.localeCompare(b.name));
+        if (options) {
+          const start = options.offset || 0;
+          const end = options.limit ? start + options.limit : undefined;
+          values = values.slice(start, end);
+        }
+        return values;
+      },
+      async get(name: string): Promise<WorkerRecord | null> {
+        const raw = await client.hget(key, name);
+        return raw ? deserialize(raw) : null;
+      },
+      async save(record: WorkerRecord): Promise<void> {
+        await client.hset(key, record.name, serialize(record));
+      },
+      async update(name: string, patch: Partial<WorkerRecord>): Promise<void> {
+        const current = await this.get(name);
+        if (!current) return;
+        await client.hset(key, name, serialize(mergeRecord(current, patch)));
+      },
+      async remove(name: string): Promise<void> {
+        await client.hdel(key, name);
+      },
+    };
+  },
+});
+
+export const DbWorkerStore = Object.freeze({
+  create(db: IDatabase, table = 'zintrust_workers'): WorkerStore {
+    return {
+      async init(): Promise<void> {
+        return undefined;
+      },
+      async list(options?: { offset?: number; limit?: number }): Promise<WorkerRecord[]> {
+        const query = db.table(table);
+        if (options?.limit) query.limit(options.limit);
+        if (options?.offset) query.offset(options.offset);
+        const rows = await query.get<Record<string, unknown>>();
+        return rows.map(deserializeDbWorker);
+      },
+      async get(name: string): Promise<WorkerRecord | null> {
+        const row = await db.table(table).where('name', '=', name).first<Record<string, unknown>>();
+        return row ? deserializeDbWorker(row) : null;
+      },
+      async save(record: WorkerRecord): Promise<void> {
+        const existing = await db
+          .table(table)
+          .where('name', '=', record.name)
+          .first<Record<string, unknown>>();
+
+        if (existing) {
+          await db.table(table).where('name', '=', record.name).update(serializeDbWorker(record));
+          return;
+        }
+
+        await db.table(table).insert(serializeDbWorker(record));
+      },
+      async update(name: string, patch: Partial<WorkerRecord>): Promise<void> {
+        const current = await this.get(name);
+        if (!current) return;
+        const updated = mergeRecord(current, patch);
+        await db.table(table).where('name', '=', name).update(serializeDbWorker(updated));
+      },
+      async remove(name: string): Promise<void> {
+        await db.table(table).where('name', '=', name).delete();
+      },
+    };
+  },
+});

package/src/type.ts

@@ -0,0 +1,89 @@
+export interface WorkerType {
+  name: string;
+  queueName: string;
+  processor: string;
+  version: string;
+  options: Options;
+  infrastructure: Infrastructure;
+  features: Features;
+  datacenter: Datacenter;
+}
+
+export interface Options {
+  concurrency: number;
+  limiter: Limiter;
+}
+
+export interface Limiter {
+  max: number;
+  duration: number;
+}
+
+export interface Infrastructure {
+  persistence: Persistence;
+  redis: Redis;
+  deadLetterQueue: DeadLetterQueue;
+  compliance: Compliance;
+  observability: Observability;
+  autoScaler: AutoScaler;
+}
+
+export interface Persistence {
+  driver: string;
+}
+
+export interface Redis {
+  env: boolean;
+  host: string;
+  port: string;
+  db: string;
+  password: string;
+}
+
+export interface DeadLetterQueue {
+  policy: string;
+}
+
+export interface Compliance {
+  config: Config;
+}
+
+export interface Config {
+  retentionDays: number;
+}
+
+export interface Observability {
+  enabled: boolean;
+}
+
+export interface AutoScaler {
+  enabled: boolean;
+  minWorkers: number;
+  maxWorkers: number;
+}
+
+export interface Features {
+  clustering: boolean;
+  metrics: boolean;
+  autoScaling: boolean;
+  circuitBreaker: boolean;
+  deadLetterQueue: boolean;
+  resourceMonitoring: boolean;
+  compliance: boolean;
+  observability: boolean;
+  plugins: boolean;
+  versioning: boolean;
+  datacenterOrchestration: boolean;
+}
+
+export interface Datacenter {
+  primaryRegion: string;
+  secondaryRegions: string[];
+  affinityRules: AffinityRules;
+}
+
+export interface AffinityRules {
+  preferLocal: boolean;
+  maxLatency: number;
+  avoidRegions: string[];
+}

package/src/types/queue-monitor.d.ts

@@ -0,0 +1,38 @@
+declare module '@zintrust/queue-monitor' {
+  export type QueueCounts = {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    paused: number;
+  };
+
+  export type QueueMonitorSnapshot = {
+    status: 'ok';
+    startedAt: string;
+    queues: Array<{
+      name: string;
+      counts: QueueCounts;
+    }>;
+  };
+
+  export type QueueMonitorConfig = {
+    enabled?: boolean;
+    basePath?: string;
+    middleware?: ReadonlyArray<string>;
+    autoRefresh?: boolean;
+    refreshIntervalMs?: number;
+    redis: Record<string, unknown>;
+  };
+
+  export type QueueMonitorApi = {
+    getSnapshot: () => Promise<QueueMonitorSnapshot>;
+  };
+
+  export const QueueMonitor: Readonly<{
+    create: (config: QueueMonitorConfig) => QueueMonitorApi;
+  }>;
+
+  export default QueueMonitor;
+}

package/src/types/queue-redis.d.ts

@@ -0,0 +1,38 @@
+declare module '@zintrust/queue-redis' {
+  export type QueueMessage<T = unknown> = {
+    id: string;
+    payload: T;
+    attempts: number;
+  };
+
+  export type RedisPublishClient = {
+    connect?: () => Promise<void>;
+    publish(channel: string, message: string): Promise<number>;
+  };
+
+  export const RedisQueue: {
+    enqueue: <T = unknown>(queue: string, payload: T) => Promise<string>;
+    dequeue: <T = unknown>(queue: string) => Promise<QueueMessage<T> | undefined>;
+    ack: (queue: string, id: string) => Promise<void>;
+    length: (queue: string) => Promise<number>;
+    drain: (queue: string) => Promise<void>;
+  };
+
+  export const BullMQRedisQueue: {
+    getQueue: (queueName: string) => unknown;
+    enqueue: <T = unknown>(queue: string, payload: T) => Promise<string>;
+    dequeue: <T = unknown>(queue: string) => Promise<QueueMessage<T> | undefined>;
+    ack: (queue: string, id: string) => Promise<void>;
+    length: (queue: string) => Promise<number>;
+    drain: (queue: string) => Promise<void>;
+    shutdown: () => Promise<void>;
+    closeQueue: (queueName: string) => Promise<void>;
+    getQueueNames: () => string[];
+  };
+
+  export const createRedisPublishClient: () => Promise<RedisPublishClient>;
+  export const resetPublishClient: () => void;
+
+  export const _ZINTRUST_QUEUE_REDIS_VERSION: string;
+  export const _ZINTRUST_QUEUE_REDIS_BUILD_DATE: string;
+}

package/src/ui/README.md

@@ -0,0 +1,13 @@
+# @zintrust/ui
+
+Vanilla-JS, framework-free UI components and static dashboard pages for ZinTrust.
+
+Drop-in usage
+
+- Serve files from `packages/ui/public/<page>/` or copy `packages/ui/src` to your static host.
+- Include `styles.css` and `main.js` from the desired page and mount in any server-rendered HTML.
+
+Contributing
+
+- Implement shared components in `src/components/` and pages in `src/<page>/`.
+- Keep components framework-agnostic and use ESM exports.