@goplusvn/core 0.1.1 → 0.1.3

package/dist/infrastructure/index.d.mts

@@ -1,423 +0,0 @@
-type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
-interface LoggerOptions {
-    /** Logger name/context for identification */
-    name?: string;
-    /** Minimum log level */
-    level?: LogLevel;
-    /** Enable file output */
-    enableFile?: boolean;
-    /** Directory for log files */
-    dirname?: string;
-}
-interface LogContext {
-    [key: string]: unknown;
-}
-interface Logger {
-    trace(message: string, context?: LogContext): void;
-    debug(message: string, context?: LogContext): void;
-    info(message: string, context?: LogContext): void;
-    warn(message: string, context?: LogContext): void;
-    error(message: string, context?: LogContext): void;
-}
-
-/**
- * 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 });
- * ```
- */
-declare function createLogger(nameOrOptions?: string | LoggerOptions): Logger;
-declare const logger: Logger;
-
-declare enum CacheNamespace {
-    Auth = "auth",
-    Lock = "lock",
-    Metadata = "metadata",
-    TenantConfig = "tenant-config",
-    RateLimit = "rate-limit"
-}
-interface CacheOptions {
-    /**
-     * Name of the cache store (e.g. 'redis', 'memory')
-     */
-    name: string;
-    /**
-     * Default TTL in seconds
-     */
-    ttl?: number;
-    /**
-     * Max number of items (for memory cache)
-     */
-    max?: number;
-    /**
-     * Namespace prefix for all keys in this cache instance
-     */
-    prefix?: CacheNamespace | string;
-}
-interface Cache {
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    del(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-    reset(): Promise<void>;
-    keys(): Promise<string[]>;
-}
-interface CacheManagerOptions {
-    defaultTtl?: number;
-    prefix?: string;
-}
-interface CacheManager {
-    create(options: CacheOptions): Cache;
-    get(name: string): Cache | undefined;
-    flushAll(): Promise<void>;
-    getAllCaches(): string[];
-    getStats(): Promise<Array<{
-        name: string;
-        itemCount: number;
-        ttl: number;
-    }>>;
-    clearCache(name: string): Promise<boolean>;
-}
-
-/**
- * CacheManager - manages multiple cache instances
- *
- * @example
- * ```typescript
- * import { cacheManager } from '@goerp/core/infrastructure';
- *
- * const userCache = cacheManager.create({ name: 'users', ttl: 3600 });
- * await userCache.set('user:123', userData);
- * const user = await userCache.get('user:123');
- * ```
- */
-declare class CacheManagerImpl implements CacheManager {
-    private caches;
-    private options;
-    constructor(options?: CacheManagerOptions);
-    create(options: CacheOptions): Cache;
-    get(name: string): Cache | undefined;
-    flushAll(): Promise<void>;
-    /** Get all cache names */
-    getAllCaches(): string[];
-    /** Get stats for all caches (for admin dashboard) */
-    getStats(): Promise<Array<{
-        name: string;
-        itemCount: number;
-        ttl: number;
-    }>>;
-    /** Clear a specific cache by name */
-    clearCache(name: string): Promise<boolean>;
-}
-declare const cacheManager: CacheManagerImpl;
-
-/**
- * Simple in-memory cache implementation
- */
-declare class MemoryCache implements Cache {
-    private store;
-    private name;
-    private defaultTtl;
-    private maxSize;
-    private prefix;
-    constructor(options: CacheOptions & {
-        prefix?: string;
-    });
-    private getFullKey;
-    private isExpired;
-    private cleanup;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    del(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-    reset(): Promise<void>;
-    keys(): Promise<string[]>;
-    /** Get cache info for admin dashboard */
-    getInfo(): {
-        name: string;
-        ttl: number;
-        maxSize: number;
-    };
-}
-
-type EventHandler<T = unknown> = (data: T) => void | Promise<void>;
-interface EventSubscription {
-    /** Unsubscribe from the event */
-    unsubscribe(): void;
-}
-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;
-}
-
-/**
- * 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' });
- * ```
- */
-declare class EventBusImpl implements EventBus {
-    private handlers;
-    private onceHandlers;
-    on<T>(event: string, handler: EventHandler<T>): EventSubscription;
-    once<T>(event: string, handler: EventHandler<T>): EventSubscription;
-    emit<T>(event: string, data: T): void;
-    emitAsync<T>(event: string, data: T): Promise<void>;
-    off(event: string): void;
-    removeAllListeners(): void;
-}
-declare const eventBus: EventBusImpl;
-
-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;
-}
-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;
-}
-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;
-}
-
-/**
- * Simple interval-based cron job (no external dependencies)
- * Supports basic cron expressions: minute, hour, day, month, weekday
- */
-declare class SimpleCronJob implements CronJob {
-    name: string;
-    cronTime: string;
-    private onTick;
-    private intervalId;
-    private running;
-    private intervalMs;
-    constructor(options: CronJobOptions);
-    /**
-     * 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;
-    start(): void;
-    stop(): void;
-    isRunning(): boolean;
-    nextDate(): Date | null;
-}
-/**
- * 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();
- * ```
- */
-declare class CronJobManagerImpl implements CronJobManager {
-    private jobs;
-    addJob(options: CronJobOptions): CronJob;
-    removeJob(name: string): void;
-    getJob(name: string): CronJob | undefined;
-    getAllJobs(): CronJob[];
-    startAll(): void;
-    stopAll(): void;
-    /** Get info for all jobs (for admin dashboard) */
-    getJobsInfo(): Array<{
-        name: string;
-        cronTime: string;
-        isRunning: boolean;
-        nextDate: Date | null;
-    }>;
-    /** Toggle a job on/off */
-    toggleJob(name: string): boolean;
-}
-declare const cronJobManager: CronJobManagerImpl;
-
-/**
- * @goerp/core - Abstract API Service Layer
- * Inspired by Plane's APIService pattern (packages/services/src/api.service.ts)
- *
- * Provides a centralized HTTP client base class for all domain services.
- * Features:
- * - Centralized error handling & 401 redirect
- * - Request/Response interceptors
- * - Type-safe CRUD methods
- * - Automatic retry logic (configurable)
- *
- * @example
- * ```typescript
- * class CustomerService extends APIService {
- *   constructor() { super('/api/sales/customers') }
- *
- *   async list(filters?: CustomerFilters) {
- *     return this.get<PaginatedResponse<Customer>>('/', { params: filters })
- *   }
- *
- *   async getById(id: string) {
- *     return this.get<Customer>(`/${id}`)
- *   }
- *
- *   async create(data: CreateCustomerDTO) {
- *     return this.post<Customer>('/', data)
- *   }
- * }
- * ```
- */
-interface APIRequestConfig {
-    params?: Record<string, unknown>;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-    /** Override default timeout (ms) */
-    timeout?: number;
-}
-interface APIResponse<T = unknown> {
-    data: T;
-    status: number;
-    ok: boolean;
-}
-interface APIError {
-    message: string;
-    status: number;
-    code?: string;
-    details?: unknown;
-}
-interface APIServiceOptions {
-    /** Called when a 401 response is received */
-    onUnauthorized?: () => void;
-    /** Called before each request (e.g., for logging) */
-    onRequest?: (method: string, url: string) => void;
-    /** Called after each response (e.g., for logging) */
-    onResponse?: (method: string, url: string, status: number) => void;
-    /** Called on any error */
-    onError?: (error: APIError) => void;
-    /** Default timeout in ms (default: 30000) */
-    timeout?: number;
-    /** Default headers to include in every request */
-    defaultHeaders?: Record<string, string>;
-}
-/**
- * Abstract base class for making HTTP requests using fetch API.
- * All domain services (CustomerService, OrderService, etc.) should extend this class.
- *
- * Unlike Plane's axios-based approach, we use native fetch() for Next.js compatibility
- * (better SSR support, no extra dependency, works with Server Components).
- */
-declare abstract class APIService {
-    protected readonly baseURL: string;
-    private readonly options;
-    constructor(baseURL: string, options?: APIServiceOptions);
-    /**
-     * Makes a GET request to the specified endpoint
-     */
-    protected get<T = unknown>(endpoint?: string, config?: APIRequestConfig): Promise<T>;
-    /**
-     * Makes a POST request with JSON body
-     */
-    protected post<T = unknown>(endpoint?: string, data?: unknown, config?: APIRequestConfig): Promise<T>;
-    /**
-     * Makes a PUT request with JSON body
-     */
-    protected put<T = unknown>(endpoint?: string, data?: unknown, config?: APIRequestConfig): Promise<T>;
-    /**
-     * Makes a PATCH request with JSON body
-     */
-    protected patch<T = unknown>(endpoint?: string, data?: unknown, config?: APIRequestConfig): Promise<T>;
-    /**
-     * Makes a DELETE request
-     */
-    protected delete<T = unknown>(endpoint?: string, data?: unknown, config?: APIRequestConfig): Promise<T>;
-    /**
-     * Build full URL with query params
-     */
-    private buildURL;
-    /**
-     * Core request method — all HTTP methods funnel through here.
-     * Handles: headers, body, timeout, error handling, 401 redirect.
-     */
-    private request;
-    /**
-     * Type guard for APIError
-     */
-    private isAPIError;
-}
-/**
- * Default options for client-side services.
- * Handles 401 redirect to login page automatically.
- */
-declare const defaultClientOptions: APIServiceOptions;
-/**
- * Helper to check if an error is an APIError
- */
-declare function isAPIError(error: unknown): error is APIError;
-
-export { type APIError, type APIRequestConfig, type APIResponse, APIService, type APIServiceOptions, type Cache, type CacheManager, CacheManagerImpl, type CacheManagerOptions, type CacheOptions, type CronJob, type CronJobManager, CronJobManagerImpl, type CronJobOptions, type EventBus, EventBusImpl, type EventHandler, type EventSubscription, type LogContext, type LogLevel, type Logger, type LoggerOptions, MemoryCache, SimpleCronJob, cacheManager, createLogger, cronJobManager, defaultClientOptions, eventBus, isAPIError, logger };