@goplusvn/core 0.1.0

package/dist/infrastructure/index.js

@@ -0,0 +1,633 @@
+'use strict';
+
+// src/infrastructure/logger/logger.ts
+var LOG_LEVELS = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+function getLogLevel() {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+  if (envLevel && LOG_LEVELS[envLevel] !== void 0) {
+    return envLevel;
+  }
+  return process.env.NODE_ENV === "production" ? "info" : "debug";
+}
+function formatMessage(level, name, message, context) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contextStr = context ? ` ${JSON.stringify(context)}` : "";
+  return `${timestamp} [${level.toUpperCase()}] [${name}] ${message}${contextStr}`;
+}
+function shouldLog(level, minLevel) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+var ConsoleLogger = class {
+  constructor(options = {}) {
+    this.name = options.name || "App";
+    this.level = options.level || getLogLevel();
+  }
+  trace(message, context) {
+    if (shouldLog("trace", this.level)) {
+      console.log(formatMessage("trace", this.name, message, context));
+    }
+  }
+  debug(message, context) {
+    if (shouldLog("debug", this.level)) {
+      console.log(formatMessage("debug", this.name, message, context));
+    }
+  }
+  info(message, context) {
+    if (shouldLog("info", this.level)) {
+      console.info(formatMessage("info", this.name, message, context));
+    }
+  }
+  warn(message, context) {
+    if (shouldLog("warn", this.level)) {
+      console.warn(formatMessage("warn", this.name, message, context));
+    }
+  }
+  error(message, context) {
+    if (shouldLog("error", this.level)) {
+      console.error(formatMessage("error", this.name, message, context));
+    }
+  }
+};
+function createLogger(nameOrOptions = {}) {
+  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+  return new ConsoleLogger(options);
+}
+var logger = createLogger("App");
+
+// src/infrastructure/cache/cache.ts
+var MemoryCache = class {
+  constructor(options) {
+    this.store = /* @__PURE__ */ new Map();
+    this.name = options.name;
+    this.defaultTtl = options.ttl || 3600;
+    this.maxSize = options.max || 1e3;
+    this.prefix = options.prefix || "";
+  }
+  getFullKey(key) {
+    return this.prefix ? `${this.prefix}:${this.name}:${key}` : `${this.name}:${key}`;
+  }
+  isExpired(entry) {
+    if (entry.expireAt === null) return false;
+    return Date.now() > entry.expireAt;
+  }
+  cleanup() {
+    for (const [key, entry] of this.store.entries()) {
+      if (this.isExpired(entry)) {
+        this.store.delete(key);
+      }
+    }
+  }
+  async get(key) {
+    const fullKey = this.getFullKey(key);
+    const entry = this.store.get(fullKey);
+    if (!entry) return void 0;
+    if (this.isExpired(entry)) {
+      this.store.delete(fullKey);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    const fullKey = this.getFullKey(key);
+    const ttlSeconds = ttl ?? this.defaultTtl;
+    if (this.store.size >= this.maxSize) {
+      this.cleanup();
+      if (this.store.size >= this.maxSize) {
+        const firstKey = this.store.keys().next().value;
+        if (firstKey) this.store.delete(firstKey);
+      }
+    }
+    this.store.set(fullKey, {
+      value,
+      expireAt: ttlSeconds > 0 ? Date.now() + ttlSeconds * 1e3 : null
+    });
+  }
+  async del(key) {
+    const fullKey = this.getFullKey(key);
+    this.store.delete(fullKey);
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== void 0;
+  }
+  async reset() {
+    const prefix = this.getFullKey("");
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.store.delete(key);
+      }
+    }
+  }
+  async keys() {
+    this.cleanup();
+    const prefix = this.getFullKey("");
+    const result = [];
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        result.push(key.slice(prefix.length));
+      }
+    }
+    return result;
+  }
+  /** Get cache info for admin dashboard */
+  getInfo() {
+    return {
+      name: this.name,
+      ttl: this.defaultTtl,
+      maxSize: this.maxSize
+    };
+  }
+};
+
+// src/infrastructure/cache/cache-manager.ts
+var CacheManagerImpl = class {
+  constructor(options = {}) {
+    this.caches = /* @__PURE__ */ new Map();
+    this.options = {
+      defaultTtl: options.defaultTtl || 3600,
+      prefix: options.prefix || ""
+    };
+  }
+  create(options) {
+    const existing = this.caches.get(options.name);
+    if (existing) {
+      return existing;
+    }
+    const cache = new MemoryCache({
+      ...options,
+      ttl: options.ttl || this.options.defaultTtl,
+      prefix: this.options.prefix
+    });
+    this.caches.set(options.name, cache);
+    return cache;
+  }
+  get(name) {
+    return this.caches.get(name);
+  }
+  async flushAll() {
+    const promises = [];
+    for (const cache of this.caches.values()) {
+      promises.push(cache.reset());
+    }
+    await Promise.all(promises);
+  }
+  /** Get all cache names */
+  getAllCaches() {
+    return Array.from(this.caches.keys());
+  }
+  /** Get stats for all caches (for admin dashboard) */
+  async getStats() {
+    const stats = [];
+    for (const [name, cache] of this.caches.entries()) {
+      const keys = await cache.keys();
+      stats.push({
+        name,
+        itemCount: keys.length,
+        ttl: cache.getInfo().ttl
+      });
+    }
+    return stats;
+  }
+  /** Clear a specific cache by name */
+  async clearCache(name) {
+    const cache = this.caches.get(name);
+    if (cache) {
+      await cache.reset();
+      return true;
+    }
+    return false;
+  }
+};
+var globalForCache = globalThis;
+var cacheManager = globalForCache.coreCacheManager ?? new CacheManagerImpl();
+if (process.env.NODE_ENV !== "production") {
+  globalForCache.coreCacheManager = cacheManager;
+}
+
+// src/infrastructure/event-bus/event-bus.ts
+var logger2 = createLogger("EventBus");
+var EventBusImpl = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.onceHandlers = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    logger2.debug(`Subscribed to event: ${event}`);
+    return {
+      unsubscribe: () => {
+        this.handlers.get(event)?.delete(handler);
+      }
+    };
+  }
+  once(event, handler) {
+    if (!this.onceHandlers.has(event)) {
+      this.onceHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.onceHandlers.get(event).add(handler);
+    return {
+      unsubscribe: () => {
+        this.onceHandlers.get(event)?.delete(handler);
+      }
+    };
+  }
+  emit(event, data) {
+    logger2.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) {
+          logger2.error(`Error in event handler for ${event}`, {
+            error: String(error)
+          });
+        }
+      }
+    }
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          logger2.error(`Error in once handler for ${event}`, {
+            error: String(error)
+          });
+        }
+      }
+      this.onceHandlers.delete(event);
+    }
+  }
+  async emitAsync(event, data) {
+    logger2.debug(`Emitting async event: ${event}`);
+    const handlers = this.handlers.get(event);
+    const onceHandlers = this.onceHandlers.get(event);
+    const promises = [];
+    if (handlers) {
+      for (const handler of handlers) {
+        promises.push(
+          Promise.resolve(handler(data)).catch((error) => {
+            logger2.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) => {
+            logger2.error(`Error in async once handler for ${event}`, {
+              error: String(error)
+            });
+          })
+        );
+      }
+      this.onceHandlers.delete(event);
+    }
+    await Promise.all(promises);
+  }
+  off(event) {
+    this.handlers.delete(event);
+    this.onceHandlers.delete(event);
+    logger2.debug(`Removed all handlers for event: ${event}`);
+  }
+  removeAllListeners() {
+    this.handlers.clear();
+    this.onceHandlers.clear();
+    logger2.debug("Removed all event listeners");
+  }
+};
+var eventBus = new EventBusImpl();
+
+// src/infrastructure/cron/cron-manager.ts
+var logger3 = createLogger("CronJobManager");
+var SimpleCronJob = class {
+  constructor(options) {
+    this.intervalId = null;
+    this.running = false;
+    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'
+   */
+  parseInterval(cronTime) {
+    const simpleMatch = cronTime.match(/^(\d+)([smhd])$/);
+    if (simpleMatch) {
+      const value = parseInt(simpleMatch[1], 10);
+      const unit = simpleMatch[2];
+      switch (unit) {
+        case "s":
+          return value * 1e3;
+        case "m":
+          return value * 60 * 1e3;
+        case "h":
+          return value * 60 * 60 * 1e3;
+        case "d":
+          return value * 24 * 60 * 60 * 1e3;
+      }
+    }
+    const parts = cronTime.split(" ");
+    if (parts.length >= 5) {
+      const [minute, hour, dayOfMonth, ,] = parts;
+      if (minute === "*" && hour === "*") {
+        return 60 * 1e3;
+      }
+      if (minute !== "*" && hour === "*") {
+        return 60 * 60 * 1e3;
+      }
+      if (minute !== "*" && hour !== "*" && dayOfMonth === "*") {
+        return 24 * 60 * 60 * 1e3;
+      }
+    }
+    logger3.warn(
+      `Could not parse cron expression "${cronTime}", defaulting to every minute`
+    );
+    return 60 * 1e3;
+  }
+  start() {
+    if (this.running) return;
+    logger3.info(`Starting cron job: ${this.name}`, {
+      interval: `${this.intervalMs}ms`
+    });
+    this.running = true;
+    this.intervalId = setInterval(async () => {
+      try {
+        await this.onTick();
+      } catch (error) {
+        logger3.error(`Cron job "${this.name}" failed`, {
+          error: String(error)
+        });
+      }
+    }, this.intervalMs);
+  }
+  stop() {
+    if (!this.running || !this.intervalId) return;
+    logger3.info(`Stopping cron job: ${this.name}`);
+    clearInterval(this.intervalId);
+    this.intervalId = null;
+    this.running = false;
+  }
+  isRunning() {
+    return this.running;
+  }
+  nextDate() {
+    if (!this.running) return null;
+    return new Date(Date.now() + this.intervalMs);
+  }
+};
+var CronJobManagerImpl = class {
+  constructor() {
+    this.jobs = /* @__PURE__ */ new Map();
+  }
+  addJob(options) {
+    if (this.jobs.has(options.name)) {
+      logger3.warn(`Job "${options.name}" already exists, removing old one`);
+      this.removeJob(options.name);
+    }
+    const job = new SimpleCronJob(options);
+    this.jobs.set(options.name, job);
+    logger3.info(`Added cron job: ${options.name}`, {
+      cronTime: options.cronTime
+    });
+    return job;
+  }
+  removeJob(name) {
+    const job = this.jobs.get(name);
+    if (job) {
+      job.stop();
+      this.jobs.delete(name);
+      logger3.info(`Removed cron job: ${name}`);
+    }
+  }
+  getJob(name) {
+    return this.jobs.get(name);
+  }
+  getAllJobs() {
+    return Array.from(this.jobs.values());
+  }
+  startAll() {
+    for (const job of this.jobs.values()) {
+      job.start();
+    }
+    logger3.info(`Started ${this.jobs.size} cron jobs`);
+  }
+  stopAll() {
+    for (const job of this.jobs.values()) {
+      job.stop();
+    }
+    logger3.info(`Stopped ${this.jobs.size} cron jobs`);
+  }
+  /** Get info for all jobs (for admin dashboard) */
+  getJobsInfo() {
+    const info = [];
+    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) {
+    const job = this.jobs.get(name);
+    if (!job) return false;
+    if (job.isRunning()) {
+      job.stop();
+    } else {
+      job.start();
+    }
+    return true;
+  }
+};
+var cronJobManager = new CronJobManagerImpl();
+
+// src/infrastructure/api-service.ts
+var APIService = class {
+  constructor(baseURL, options = {}) {
+    this.baseURL = baseURL;
+    this.options = options;
+  }
+  // --------------------------------------------------------
+  // Core HTTP Methods
+  // --------------------------------------------------------
+  /**
+   * Makes a GET request to the specified endpoint
+   */
+  async get(endpoint = "", config = {}) {
+    const url = this.buildURL(endpoint, config.params);
+    return this.request("GET", url, void 0, config);
+  }
+  /**
+   * Makes a POST request with JSON body
+   */
+  async post(endpoint = "", data, config = {}) {
+    const url = this.buildURL(endpoint);
+    return this.request("POST", url, data, config);
+  }
+  /**
+   * Makes a PUT request with JSON body
+   */
+  async put(endpoint = "", data, config = {}) {
+    const url = this.buildURL(endpoint);
+    return this.request("PUT", url, data, config);
+  }
+  /**
+   * Makes a PATCH request with JSON body
+   */
+  async patch(endpoint = "", data, config = {}) {
+    const url = this.buildURL(endpoint);
+    return this.request("PATCH", url, data, config);
+  }
+  /**
+   * Makes a DELETE request
+   */
+  async delete(endpoint = "", data, config = {}) {
+    const url = this.buildURL(endpoint);
+    return this.request("DELETE", url, data, config);
+  }
+  // --------------------------------------------------------
+  // Internal Helpers
+  // --------------------------------------------------------
+  /**
+   * Build full URL with query params
+   */
+  buildURL(endpoint, params) {
+    const url = `${this.baseURL}${endpoint}`;
+    if (!params || Object.keys(params).length === 0) return url;
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null && value !== "") {
+        searchParams.append(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  /**
+   * Core request method — all HTTP methods funnel through here.
+   * Handles: headers, body, timeout, error handling, 401 redirect.
+   */
+  async request(method, url, data, config = {}) {
+    this.options.onRequest?.(method, url);
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.options.defaultHeaders,
+      ...config.headers
+    };
+    const fetchOptions = {
+      method,
+      headers,
+      credentials: "include",
+      // Send cookies (same as axios withCredentials)
+      signal: config.signal
+    };
+    if (data !== void 0 && method !== "GET") {
+      fetchOptions.body = JSON.stringify(data);
+    }
+    try {
+      const response = await fetch(url, fetchOptions);
+      this.options.onResponse?.(method, url, response.status);
+      if (response.status === 401) {
+        const error = {
+          message: "Unauthorized",
+          status: 401,
+          code: "UNAUTHORIZED"
+        };
+        this.options.onUnauthorized?.();
+        this.options.onError?.(error);
+        throw error;
+      }
+      if (!response.ok) {
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {
+          errorBody = await response.text();
+        }
+        const error = {
+          message: typeof errorBody === "object" && errorBody !== null && "message" in errorBody ? String(errorBody.message) : `HTTP Error ${response.status}`,
+          status: response.status,
+          code: typeof errorBody === "object" && errorBody !== null && "code" in errorBody ? String(errorBody.code) : void 0,
+          details: errorBody
+        };
+        this.options.onError?.(error);
+        throw error;
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      const responseData = await response.json();
+      return responseData;
+    } catch (error) {
+      if (this.isAPIError(error)) {
+        throw error;
+      }
+      const apiError = {
+        message: error instanceof Error ? error.message : "Network error",
+        status: 0,
+        code: "NETWORK_ERROR"
+      };
+      this.options.onError?.(apiError);
+      throw apiError;
+    }
+  }
+  /**
+   * Type guard for APIError
+   */
+  isAPIError(error) {
+    return typeof error === "object" && error !== null && "message" in error && "status" in error;
+  }
+};
+var defaultClientOptions = {
+  onUnauthorized: () => {
+    if (typeof window !== "undefined") {
+      const currentPath = window.location.pathname;
+      window.location.replace(`/login?next_path=${encodeURIComponent(currentPath)}`);
+    }
+  }
+};
+function isAPIError(error) {
+  return typeof error === "object" && error !== null && "message" in error && "status" in error && typeof error.status === "number";
+}
+
+exports.APIService = APIService;
+exports.CacheManagerImpl = CacheManagerImpl;
+exports.CronJobManagerImpl = CronJobManagerImpl;
+exports.EventBusImpl = EventBusImpl;
+exports.MemoryCache = MemoryCache;
+exports.SimpleCronJob = SimpleCronJob;
+exports.cacheManager = cacheManager;
+exports.createLogger = createLogger;
+exports.cronJobManager = cronJobManager;
+exports.defaultClientOptions = defaultClientOptions;
+exports.eventBus = eventBus;
+exports.isAPIError = isAPIError;
+exports.logger = logger;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map