@goplusvn/core 0.1.0 → 0.1.2

package/dist/infrastructure/index.mjs

@@ -1,619 +0,0 @@
-// 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";
-}
-
-export { APIService, CacheManagerImpl, CronJobManagerImpl, EventBusImpl, MemoryCache, SimpleCronJob, cacheManager, createLogger, cronJobManager, defaultClientOptions, eventBus, isAPIError, logger };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map