@goplusvn/core 0.1.0 → 0.1.1

package/src/infrastructure/cron/cron-manager.ts

@@ -0,0 +1,239 @@
+import type {
+  CronJob,
+  CronJobManager as ICronJobManager,
+  CronJobOptions,
+} from "./types";
+import { createLogger } from "../logger";
+
+const logger = createLogger("CronJobManager");
+
+/**
+ * Simple interval-based cron job (no external dependencies)
+ * Supports basic cron expressions: minute, hour, day, month, weekday
+ */
+class SimpleCronJob implements CronJob {
+  name: string;
+  cronTime: string;
+  private onTick: () => void | Promise<void>;
+  private intervalId: NodeJS.Timeout | null = null;
+  private running = false;
+  private intervalMs: number;
+
+  constructor(options: CronJobOptions) {
+    this.name = options.name;
+    this.cronTime = options.cronTime;
+    this.onTick = options.onTick;
+    this.intervalMs = this.parseInterval(options.cronTime);
+
+    if (options.start) {
+      this.start();
+    }
+  }
+
+  /**
+   * Parse simple cron expressions to interval
+   * Supports:
+   * - '* * * * *' - every minute
+   * - '0 * * * *' - every hour
+   * - '0 0 * * *' - every day at midnight
+   * - Also supports simple intervals: '5m', '1h', '1d'
+   */
+  private parseInterval(cronTime: string): number {
+    // Simple interval format: 5m, 1h, 1d
+    const simpleMatch = cronTime.match(/^(\d+)([smhd])$/);
+    if (simpleMatch) {
+      const value = parseInt(simpleMatch[1], 10);
+      const unit = simpleMatch[2];
+      switch (unit) {
+        case "s":
+          return value * 1000;
+        case "m":
+          return value * 60 * 1000;
+        case "h":
+          return value * 60 * 60 * 1000;
+        case "d":
+          return value * 24 * 60 * 60 * 1000;
+      }
+    }
+
+    // Parse cron expression
+    const parts = cronTime.split(" ");
+    if (parts.length >= 5) {
+      const [minute, hour, dayOfMonth, ,] = parts;
+
+      // Every minute
+      if (minute === "*" && hour === "*") {
+        return 60 * 1000; // 1 minute
+      }
+
+      // Every hour (minute = 0)
+      if (minute !== "*" && hour === "*") {
+        return 60 * 60 * 1000; // 1 hour
+      }
+
+      // Every day (minute and hour specified)
+      if (minute !== "*" && hour !== "*" && dayOfMonth === "*") {
+        return 24 * 60 * 60 * 1000; // 1 day
+      }
+    }
+
+    // Default: every minute
+    logger.warn(
+      `Could not parse cron expression "${cronTime}", defaulting to every minute`,
+    );
+    return 60 * 1000;
+  }
+
+  start(): void {
+    if (this.running) return;
+
+    logger.info(`Starting cron job: ${this.name}`, {
+      interval: `${this.intervalMs}ms`,
+    });
+
+    this.running = true;
+    this.intervalId = setInterval(async () => {
+      try {
+        await this.onTick();
+      } catch (error) {
+        logger.error(`Cron job "${this.name}" failed`, {
+          error: String(error),
+        });
+      }
+    }, this.intervalMs);
+  }
+
+  stop(): void {
+    if (!this.running || !this.intervalId) return;
+
+    logger.info(`Stopping cron job: ${this.name}`);
+    clearInterval(this.intervalId);
+    this.intervalId = null;
+    this.running = false;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  nextDate(): Date | null {
+    if (!this.running) return null;
+    return new Date(Date.now() + this.intervalMs);
+  }
+}
+
+/**
+ * CronJobManager - manages scheduled tasks
+ *
+ * @example
+ * ```typescript
+ * import { cronJobManager } from '@goerp/core/infrastructure';
+ *
+ * // Add a job that runs every hour
+ * cronJobManager.addJob({
+ *   name: 'cleanup-expired-tokens',
+ *   cronTime: '1h', // or '0 * * * *'
+ *   onTick: async () => {
+ *     await db.token.deleteMany({ where: { expiredAt: { lt: new Date() } } });
+ *   },
+ *   start: true
+ * });
+ *
+ * // Stop all jobs on shutdown
+ * cronJobManager.stopAll();
+ * ```
+ */
+class CronJobManagerImpl implements ICronJobManager {
+  private jobs = new Map<string, CronJob>();
+
+  addJob(options: CronJobOptions): CronJob {
+    if (this.jobs.has(options.name)) {
+      logger.warn(`Job "${options.name}" already exists, removing old one`);
+      this.removeJob(options.name);
+    }
+
+    const job = new SimpleCronJob(options);
+    this.jobs.set(options.name, job);
+
+    logger.info(`Added cron job: ${options.name}`, {
+      cronTime: options.cronTime,
+    });
+    return job;
+  }
+
+  removeJob(name: string): void {
+    const job = this.jobs.get(name);
+    if (job) {
+      job.stop();
+      this.jobs.delete(name);
+      logger.info(`Removed cron job: ${name}`);
+    }
+  }
+
+  getJob(name: string): CronJob | undefined {
+    return this.jobs.get(name);
+  }
+
+  getAllJobs(): CronJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  startAll(): void {
+    for (const job of this.jobs.values()) {
+      job.start();
+    }
+    logger.info(`Started ${this.jobs.size} cron jobs`);
+  }
+
+  stopAll(): void {
+    for (const job of this.jobs.values()) {
+      job.stop();
+    }
+    logger.info(`Stopped ${this.jobs.size} cron jobs`);
+  }
+
+  /** Get info for all jobs (for admin dashboard) */
+  getJobsInfo(): Array<{
+    name: string;
+    cronTime: string;
+    isRunning: boolean;
+    nextDate: Date | null;
+  }> {
+    const info: Array<{
+      name: string;
+      cronTime: string;
+      isRunning: boolean;
+      nextDate: Date | null;
+    }> = [];
+
+    for (const job of this.jobs.values()) {
+      info.push({
+        name: job.name,
+        cronTime: job.cronTime,
+        isRunning: job.isRunning(),
+        nextDate: job.nextDate(),
+      });
+    }
+
+    return info;
+  }
+
+  /** Toggle a job on/off */
+  toggleJob(name: string): boolean {
+    const job = this.jobs.get(name);
+    if (!job) return false;
+
+    if (job.isRunning()) {
+      job.stop();
+    } else {
+      job.start();
+    }
+    return true;
+  }
+}
+
+// Singleton instance
+export const cronJobManager = new CronJobManagerImpl();
+
+// Export classes for testing
+export { CronJobManagerImpl, SimpleCronJob };

package/src/infrastructure/cron/index.ts

@@ -0,0 +1,6 @@
+export {
+  cronJobManager,
+  CronJobManagerImpl,
+  SimpleCronJob,
+} from "./cron-manager";
+export type { CronJob, CronJobOptions, CronJobManager } from "./types";

package/src/infrastructure/cron/types.ts

@@ -0,0 +1,41 @@
+// CronJob Types
+export interface CronJobOptions {
+  /** Job name for identification */
+  name: string;
+  /** Cron expression (e.g., '0 * * * *' for every hour) */
+  cronTime: string;
+  /** Function to execute */
+  onTick: () => void | Promise<void>;
+  /** Start immediately on creation (default: false) */
+  start?: boolean;
+  /** Timezone (default: system timezone) */
+  timezone?: string;
+}
+
+export interface CronJob {
+  name: string;
+  cronTime: string;
+  /** Start the job */
+  start(): void;
+  /** Stop the job */
+  stop(): void;
+  /** Check if job is running */
+  isRunning(): boolean;
+  /** Get next execution date */
+  nextDate(): Date | null;
+}
+
+export interface CronJobManager {
+  /** Add a new cron job */
+  addJob(options: CronJobOptions): CronJob;
+  /** Remove a job by name */
+  removeJob(name: string): void;
+  /** Get a job by name */
+  getJob(name: string): CronJob | undefined;
+  /** Get all jobs */
+  getAllJobs(): CronJob[];
+  /** Start all jobs */
+  startAll(): void;
+  /** Stop all jobs */
+  stopAll(): void;
+}

package/src/infrastructure/event-bus/event-bus.ts

@@ -0,0 +1,145 @@
+import type {
+  EventBus as IEventBus,
+  EventHandler,
+  EventSubscription,
+} from "./types";
+import { createLogger } from "../logger";
+
+const logger = createLogger("EventBus");
+
+/**
+ * Simple in-memory event bus for pub/sub pattern
+ *
+ * @example
+ * ```typescript
+ * import { eventBus } from '@goerp/core/infrastructure';
+ *
+ * // Subscribe
+ * eventBus.on('order.created', async ({ orderId }) => {
+ *   await notificationService.notify(orderId);
+ * });
+ *
+ * // Publish
+ * eventBus.emit('order.created', { orderId: '123' });
+ *
+ * // Async emit (wait for handlers)
+ * await eventBus.emitAsync('order.approved', { orderId: '123' });
+ * ```
+ */
+class EventBusImpl implements IEventBus {
+  private handlers = new Map<string, Set<EventHandler<unknown>>>();
+  private onceHandlers = new Map<string, Set<EventHandler<unknown>>>();
+
+  on<T>(event: string, handler: EventHandler<T>): EventSubscription {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, new Set());
+    }
+    this.handlers.get(event)!.add(handler as EventHandler<unknown>);
+
+    logger.debug(`Subscribed to event: ${event}`);
+
+    return {
+      unsubscribe: () => {
+        this.handlers.get(event)?.delete(handler as EventHandler<unknown>);
+      },
+    };
+  }
+
+  once<T>(event: string, handler: EventHandler<T>): EventSubscription {
+    if (!this.onceHandlers.has(event)) {
+      this.onceHandlers.set(event, new Set());
+    }
+    this.onceHandlers.get(event)!.add(handler as EventHandler<unknown>);
+
+    return {
+      unsubscribe: () => {
+        this.onceHandlers.get(event)?.delete(handler as EventHandler<unknown>);
+      },
+    };
+  }
+
+  emit<T>(event: string, data: T): void {
+    logger.debug(`Emitting event: ${event}`);
+
+    const handlers = this.handlers.get(event);
+    const onceHandlers = this.onceHandlers.get(event);
+
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          logger.error(`Error in event handler for ${event}`, {
+            error: String(error),
+          });
+        }
+      }
+    }
+
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          logger.error(`Error in once handler for ${event}`, {
+            error: String(error),
+          });
+        }
+      }
+      this.onceHandlers.delete(event);
+    }
+  }
+
+  async emitAsync<T>(event: string, data: T): Promise<void> {
+    logger.debug(`Emitting async event: ${event}`);
+
+    const handlers = this.handlers.get(event);
+    const onceHandlers = this.onceHandlers.get(event);
+    const promises: Promise<void>[] = [];
+
+    if (handlers) {
+      for (const handler of handlers) {
+        promises.push(
+          Promise.resolve(handler(data)).catch((error) => {
+            logger.error(`Error in async handler for ${event}`, {
+              error: String(error),
+            });
+          }),
+        );
+      }
+    }
+
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        promises.push(
+          Promise.resolve(handler(data)).catch((error) => {
+            logger.error(`Error in async once handler for ${event}`, {
+              error: String(error),
+            });
+          }),
+        );
+      }
+      this.onceHandlers.delete(event);
+    }
+
+    await Promise.all(promises);
+  }
+
+  off(event: string): void {
+    this.handlers.delete(event);
+    this.onceHandlers.delete(event);
+    logger.debug(`Removed all handlers for event: ${event}`);
+  }
+
+  removeAllListeners(): void {
+    this.handlers.clear();
+    this.onceHandlers.clear();
+    logger.debug("Removed all event listeners");
+  }
+}
+
+// Singleton instance
+export const eventBus = new EventBusImpl();
+
+// Export class for testing
+export { EventBusImpl };

package/src/infrastructure/event-bus/index.ts

@@ -0,0 +1,2 @@
+export { eventBus, EventBusImpl } from "./event-bus";
+export type { EventBus, EventHandler, EventSubscription } from "./types";

package/src/infrastructure/event-bus/types.ts

@@ -0,0 +1,22 @@
+// EventBus Types
+export type EventHandler<T = unknown> = (data: T) => void | Promise<void>;
+
+export interface EventSubscription {
+  /** Unsubscribe from the event */
+  unsubscribe(): void;
+}
+
+export interface EventBus {
+  /** Subscribe to an event */
+  on<T>(event: string, handler: EventHandler<T>): EventSubscription;
+  /** Subscribe to an event (fires only once) */
+  once<T>(event: string, handler: EventHandler<T>): EventSubscription;
+  /** Emit an event with data */
+  emit<T>(event: string, data: T): void;
+  /** Emit an event and wait for all handlers to complete */
+  emitAsync<T>(event: string, data: T): Promise<void>;
+  /** Remove all handlers for an event */
+  off(event: string): void;
+  /** Remove all handlers */
+  removeAllListeners(): void;
+}

package/src/infrastructure/index.ts

@@ -0,0 +1,32 @@
+// @goerp/core/infrastructure
+// Infrastructure utilities for GoERP applications
+
+// Logger
+export { createLogger, logger } from "./logger";
+export type { Logger, LoggerOptions, LogContext, LogLevel } from "./logger";
+
+// Cache
+export { cacheManager, CacheManagerImpl, MemoryCache } from "./cache";
+export type {
+  Cache,
+  CacheOptions,
+  CacheManager,
+  CacheManagerOptions,
+} from "./cache";
+
+// EventBus
+export { eventBus, EventBusImpl } from "./event-bus";
+export type { EventBus, EventHandler, EventSubscription } from "./event-bus";
+
+// CronJob
+export { cronJobManager, CronJobManagerImpl, SimpleCronJob } from "./cron";
+export type { CronJob, CronJobOptions, CronJobManager } from "./cron";
+
+// API Service Layer (Inspired by Plane's Abstract APIService pattern)
+export { APIService, defaultClientOptions, isAPIError } from "./api-service";
+export type {
+  APIRequestConfig,
+  APIResponse,
+  APIError,
+  APIServiceOptions,
+} from "./api-service";

package/src/infrastructure/lock/decorators.ts

@@ -0,0 +1,67 @@
+import type { LockOptions } from "./lock-manager";
+import { LockManager } from "./lock-manager";
+
+/**
+ * Decorator to acquire a lock before executing a method.
+ * Requires the class to have a `lockManager` property.
+ */
+export function WithLock(keyPath: string, options?: LockOptions) {
+  return function (
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const self = this as any;
+
+      if (!self.lockManager) {
+        throw new Error(
+          `Class '${target.constructor.name}' must have a 'lockManager' property to use @WithLock`,
+        );
+      }
+
+      const resolvedKey = resolveKey(keyPath, args);
+      // Prefix lock key to avoid collisions
+      const lockKey = `lock:${resolvedKey}`;
+
+      const acquired = await self.lockManager.acquire(lockKey, options);
+
+      if (!acquired) {
+        throw new Error(`Could not acquire lock for key: ${lockKey}`);
+      }
+
+      try {
+        return await originalMethod.apply(this, args);
+      } finally {
+        await self.lockManager.release(lockKey);
+      }
+    };
+
+    return descriptor;
+  };
+}
+
+function resolveKey(path: string, args: any[]): string {
+  // If path format is "{0}" or "{0}.id"
+  const match = path.match(/\{(\d+)\}(.*)/);
+  if (match) {
+    const argIndex = parseInt(match[1]);
+    let value = args[argIndex];
+    const subPath = match[2]; // e.g., ".id"
+
+    if (!subPath) return String(value);
+
+    const props = subPath.replace(/^\./, "").split(".");
+    for (const prop of props) {
+      if (value === undefined || value === null) break;
+      value = value[prop];
+    }
+    return String(value);
+  }
+
+  // Legacy/Simple support: direct string
+  return path;
+}

package/src/infrastructure/lock/index.ts

@@ -0,0 +1,2 @@
+export * from "./lock-manager";
+export * from "./decorators";

package/src/infrastructure/lock/lock-manager.ts

@@ -0,0 +1,33 @@
+import type { Cache } from "../cache/types";
+
+export interface LockOptions {
+  ttl?: number;
+  retryTimes?: number;
+  retryDelay?: number;
+}
+
+export class LockManager {
+  constructor(private cache: Cache) {}
+
+  async acquire(key: string, options?: LockOptions): Promise<boolean> {
+    const ttl = options?.ttl || 10;
+    const retryTimes = options?.retryTimes || 1;
+    const retryDelay = options?.retryDelay || 100;
+
+    for (let i = 0; i < retryTimes; i++) {
+      const existing = await this.cache.get(key);
+      if (!existing) {
+        await this.cache.set(key, "LOCKED", ttl);
+        return true;
+      }
+      if (i < retryTimes - 1) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+    return false;
+  }
+
+  async release(key: string): Promise<void> {
+    await this.cache.del(key);
+  }
+}

package/src/infrastructure/logger/index.ts

@@ -0,0 +1,2 @@
+export { createLogger, logger } from "./logger";
+export type { Logger, LoggerOptions, LogContext, LogLevel } from "./types";

package/src/infrastructure/logger/logger.ts

@@ -0,0 +1,96 @@
+import type { Logger, LoggerOptions, LogContext, LogLevel } from "./types";
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+};
+
+function getLogLevel(): LogLevel {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase() as LogLevel;
+  if (envLevel && LOG_LEVELS[envLevel] !== undefined) {
+    return envLevel;
+  }
+  return process.env.NODE_ENV === "production" ? "info" : "debug";
+}
+
+function formatMessage(
+  level: LogLevel,
+  name: string,
+  message: string,
+  context?: LogContext,
+): string {
+  const timestamp = new Date().toISOString();
+  const contextStr = context ? ` ${JSON.stringify(context)}` : "";
+  return `${timestamp} [${level.toUpperCase()}] [${name}] ${message}${contextStr}`;
+}
+
+function shouldLog(level: LogLevel, minLevel: LogLevel): boolean {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+
+class ConsoleLogger implements Logger {
+  private name: string;
+  private level: LogLevel;
+
+  constructor(options: LoggerOptions = {}) {
+    this.name = options.name || "App";
+    this.level = options.level || getLogLevel();
+  }
+
+  trace(message: string, context?: LogContext): void {
+    if (shouldLog("trace", this.level)) {
+      console.log(formatMessage("trace", this.name, message, context));
+    }
+  }
+
+  debug(message: string, context?: LogContext): void {
+    if (shouldLog("debug", this.level)) {
+      console.log(formatMessage("debug", this.name, message, context));
+    }
+  }
+
+  info(message: string, context?: LogContext): void {
+    if (shouldLog("info", this.level)) {
+      console.info(formatMessage("info", this.name, message, context));
+    }
+  }
+
+  warn(message: string, context?: LogContext): void {
+    if (shouldLog("warn", this.level)) {
+      console.warn(formatMessage("warn", this.name, message, context));
+    }
+  }
+
+  error(message: string, context?: LogContext): void {
+    if (shouldLog("error", this.level)) {
+      console.error(formatMessage("error", this.name, message, context));
+    }
+  }
+}
+
+/**
+ * Create a logger instance with the given name/options
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@goerp/core/infrastructure';
+ *
+ * const logger = createLogger('OrderService');
+ * logger.info('Order created', { orderId: '123' });
+ * logger.error('Payment failed', { error: err.message });
+ * ```
+ */
+export function createLogger(
+  nameOrOptions: string | LoggerOptions = {},
+): Logger {
+  const options =
+    typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+
+  return new ConsoleLogger(options);
+}
+
+// Default app logger
+export const logger = createLogger("App");