@classytic/arc 1.1.0 → 2.1.2

package/dist/errors-8WIxGS_6.d.ts

@@ -1,122 +0,0 @@
-/**
- * Error Classes
- *
- * Standard error types for the Arc framework.
- */
-interface ErrorDetails {
-    code?: string;
-    statusCode?: number;
-    details?: Record<string, unknown>;
-    cause?: Error;
-    requestId?: string;
-}
-/**
- * Base Arc Error
- *
- * All Arc errors extend this class and produce a consistent error envelope:
- * {
- *   success: false,
- *   error: "Human-readable message",
- *   code: "MACHINE_CODE",
- *   requestId: "uuid",     // For tracing
- *   timestamp: "ISO date", // When error occurred
- *   details: { ... }       // Additional context
- * }
- */
-declare class ArcError extends Error {
-    name: string;
-    readonly code: string;
-    readonly statusCode: number;
-    readonly details?: Record<string, unknown>;
-    readonly cause?: Error;
-    readonly timestamp: string;
-    requestId?: string;
-    constructor(message: string, options?: ErrorDetails);
-    /**
-     * Set request ID (typically from request context)
-     */
-    withRequestId(requestId: string): this;
-    /**
-     * Convert to JSON response
-     */
-    toJSON(): Record<string, unknown>;
-}
-/**
- * Not Found Error - 404
- */
-declare class NotFoundError extends ArcError {
-    constructor(resource: string, identifier?: string);
-}
-/**
- * Validation Error - 400
- */
-declare class ValidationError extends ArcError {
-    readonly errors: Array<{
-        field: string;
-        message: string;
-    }>;
-    constructor(message: string, errors?: Array<{
-        field: string;
-        message: string;
-    }>);
-}
-/**
- * Unauthorized Error - 401
- */
-declare class UnauthorizedError extends ArcError {
-    constructor(message?: string);
-}
-/**
- * Forbidden Error - 403
- */
-declare class ForbiddenError extends ArcError {
-    constructor(message?: string);
-}
-/**
- * Conflict Error - 409
- */
-declare class ConflictError extends ArcError {
-    constructor(message: string, field?: string);
-}
-/**
- * Organization Required Error - 403
- */
-declare class OrgRequiredError extends ArcError {
-    readonly organizations?: Array<{
-        id: string;
-        roles?: string[];
-    }>;
-    constructor(message: string, organizations?: Array<{
-        id: string;
-        roles?: string[];
-    }>);
-}
-/**
- * Organization Access Denied Error - 403
- */
-declare class OrgAccessDeniedError extends ArcError {
-    constructor(orgId?: string);
-}
-/**
- * Rate Limit Error - 429
- */
-declare class RateLimitError extends ArcError {
-    readonly retryAfter?: number;
-    constructor(message?: string, retryAfter?: number);
-}
-/**
- * Service Unavailable Error - 503
- */
-declare class ServiceUnavailableError extends ArcError {
-    constructor(message?: string);
-}
-/**
- * Create error from status code
- */
-declare function createError(statusCode: number, message: string, details?: Record<string, unknown>): ArcError;
-/**
- * Check if error is an Arc error
- */
-declare function isArcError(error: unknown): error is ArcError;
-
-export { ArcError as A, ConflictError as C, type ErrorDetails as E, ForbiddenError as F, NotFoundError as N, OrgRequiredError as O, RateLimitError as R, ServiceUnavailableError as S, UnauthorizedError as U, ValidationError as V, OrgAccessDeniedError as a, createError as c, isArcError as i };

package/dist/events/index.d.ts

@@ -1,117 +0,0 @@
-import { FastifyPluginAsync } from 'fastify';
-
-/**
- * Event Transport Interface
- *
- * Defines contract for event delivery backends.
- * Implement for durable transports (Redis, RabbitMQ, Kafka, etc.)
- *
- * @example
- * // Redis Pub/Sub implementation
- * class RedisEventTransport implements EventTransport {
- *   async publish(event) {
- *     await redis.publish(event.type, JSON.stringify(event));
- *   }
- *   async subscribe(pattern, handler) {
- *     redis.psubscribe(pattern);
- *     redis.on('pmessage', (p, channel, msg) => handler(JSON.parse(msg)));
- *   }
- * }
- */
-interface DomainEvent<T = unknown> {
-    /** Event type (e.g., 'product.created', 'order.shipped') */
-    type: string;
-    /** Event payload */
-    payload: T;
-    /** Event metadata */
-    meta: {
-        /** Unique event ID */
-        id: string;
-        /** Event timestamp */
-        timestamp: Date;
-        /** Source resource */
-        resource?: string;
-        /** Resource ID */
-        resourceId?: string;
-        /** User who triggered the event */
-        userId?: string;
-        /** Organization context */
-        organizationId?: string;
-        /** Correlation ID for tracing */
-        correlationId?: string;
-    };
-}
-type EventHandler<T = unknown> = (event: DomainEvent<T>) => void | Promise<void>;
-interface EventTransport {
-    /** Transport name for logging */
-    readonly name: string;
-    /**
-     * Publish an event to the transport
-     */
-    publish(event: DomainEvent): Promise<void>;
-    /**
-     * Subscribe to events matching a pattern
-     * @param pattern - Event type pattern (e.g., 'product.*', '*')
-     * @param handler - Handler function
-     * @returns Unsubscribe function
-     */
-    subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
-    /**
-     * Close transport connections
-     */
-    close?(): Promise<void>;
-}
-/**
- * In-memory event transport (default)
- * Events are delivered synchronously within the process.
- * Not suitable for multi-instance deployments.
- */
-declare class MemoryEventTransport implements EventTransport {
-    readonly name = "memory";
-    private handlers;
-    publish(event: DomainEvent): Promise<void>;
-    subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
-    close(): Promise<void>;
-}
-/**
- * Create a domain event with auto-generated metadata
- */
-declare function createEvent<T>(type: string, payload: T, meta?: Partial<DomainEvent['meta']>): DomainEvent<T>;
-
-/**
- * Event Plugin
- *
- * Integrates event transport with Fastify.
- * Defaults to in-memory transport; configure durable transport for production.
- *
- * @example
- * // Development (in-memory)
- * await fastify.register(eventPlugin);
- *
- * // Production (Redis)
- * await fastify.register(eventPlugin, {
- *   transport: new RedisEventTransport({ url: process.env.REDIS_URL }),
- * });
- */
-
-interface EventPluginOptions {
-    /** Event transport (default: MemoryEventTransport) */
-    transport?: EventTransport;
-    /** Enable event logging (default: false) */
-    logEvents?: boolean;
-}
-declare module 'fastify' {
-    interface FastifyInstance {
-        events: {
-            /** Publish an event */
-            publish: <T>(type: string, payload: T, meta?: Partial<DomainEvent['meta']>) => Promise<void>;
-            /** Subscribe to events */
-            subscribe: (pattern: string, handler: EventHandler) => Promise<() => void>;
-            /** Get transport name */
-            transportName: string;
-        };
-    }
-}
-declare const eventPlugin: FastifyPluginAsync<EventPluginOptions>;
-
-export { type DomainEvent, type EventHandler, type EventPluginOptions, type EventTransport, MemoryEventTransport, createEvent, eventPlugin };

package/dist/events/index.js

@@ -1,89 +0,0 @@
-import fp from 'fastify-plugin';
-
-// src/events/EventTransport.ts
-var MemoryEventTransport = class {
-  name = "memory";
-  handlers = /* @__PURE__ */ new Map();
-  async publish(event) {
-    const exactHandlers = this.handlers.get(event.type) ?? /* @__PURE__ */ new Set();
-    const wildcardHandlers = this.handlers.get("*") ?? /* @__PURE__ */ new Set();
-    const patternHandlers = /* @__PURE__ */ new Set();
-    for (const [pattern, handlers] of this.handlers.entries()) {
-      if (pattern.endsWith(".*")) {
-        const prefix = pattern.slice(0, -2);
-        if (event.type.startsWith(prefix + ".")) {
-          handlers.forEach((h) => patternHandlers.add(h));
-        }
-      }
-    }
-    const allHandlers = /* @__PURE__ */ new Set([...exactHandlers, ...wildcardHandlers, ...patternHandlers]);
-    for (const handler of allHandlers) {
-      try {
-        await handler(event);
-      } catch (err) {
-        console.error(`[EventTransport] Handler error for ${event.type}:`, err);
-      }
-    }
-  }
-  async subscribe(pattern, handler) {
-    if (!this.handlers.has(pattern)) {
-      this.handlers.set(pattern, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(pattern).add(handler);
-    return () => {
-      this.handlers.get(pattern)?.delete(handler);
-    };
-  }
-  async close() {
-    this.handlers.clear();
-  }
-};
-function createEvent(type, payload, meta) {
-  return {
-    type,
-    payload,
-    meta: {
-      id: crypto.randomUUID(),
-      timestamp: /* @__PURE__ */ new Date(),
-      ...meta
-    }
-  };
-}
-var eventPlugin = async (fastify, opts = {}) => {
-  const {
-    transport = new MemoryEventTransport(),
-    logEvents = false
-  } = opts;
-  fastify.decorate("events", {
-    publish: async (type, payload, meta) => {
-      const event = createEvent(type, payload, meta);
-      if (logEvents) {
-        fastify.log?.info?.({ eventType: type, eventId: event.meta.id }, "Publishing event");
-      }
-      await transport.publish(event);
-    },
-    subscribe: async (pattern, handler) => {
-      if (logEvents) {
-        fastify.log?.info?.({ pattern }, "Subscribing to events");
-      }
-      return transport.subscribe(pattern, handler);
-    },
-    transportName: transport.name
-  });
-  fastify.addHook("onClose", async () => {
-    await transport.close?.();
-  });
-  if (transport.name === "memory") {
-    fastify.log?.warn?.(
-      "[Arc Events] Using in-memory transport. Events will not persist or scale across instances. For production, configure a durable transport (Redis, RabbitMQ, etc.)"
-    );
-  } else {
-    fastify.log?.info?.(`[Arc Events] Using ${transport.name} transport`);
-  }
-};
-fp(eventPlugin, {
-  name: "arc-events",
-  fastify: "5.x"
-});
-
-export { MemoryEventTransport, createEvent, eventPlugin };

package/dist/factory/index.d.ts

@@ -1,38 +0,0 @@
-export { A as ArcFactory, c as createApp } from '../createApp-Ce9wl8W9.js';
-import { C as CreateAppOptions } from '../types-BvckRbs2.js';
-export { M as MultipartOptions, R as RawBodyOptions, U as UnderPressureOptions } from '../types-BvckRbs2.js';
-import 'fastify';
-import '@fastify/cors';
-import '@fastify/helmet';
-import '@fastify/rate-limit';
-import '../index-B4t03KQ0.js';
-import 'mongoose';
-import '../types-B99TBmFV.js';
-
-/**
- * Environment Presets for createApp
- *
- * Provides sensible defaults for different environments:
- * - production: Strict security, performance optimized
- * - development: Relaxed CORS, verbose logging
- * - testing: In-memory DB, no rate limiting
- */
-
-/**
- * Production preset - strict security, performance optimized
- */
-declare const productionPreset: Partial<CreateAppOptions>;
-/**
- * Development preset - relaxed security, verbose logging
- */
-declare const developmentPreset: Partial<CreateAppOptions>;
-/**
- * Testing preset - minimal setup, fast startup
- */
-declare const testingPreset: Partial<CreateAppOptions>;
-/**
- * Get preset by name
- */
-declare function getPreset(name: 'production' | 'development' | 'testing'): Partial<CreateAppOptions>;
-
-export { CreateAppOptions, developmentPreset, getPreset, productionPreset, testingPreset };