@engjts/nexus 0.1.0

package/src/advanced/observability/types.ts

@@ -0,0 +1,174 @@
+export interface MetricDefinition {
+    name: string;
+    type: 'counter' | 'histogram' | 'gauge';
+    help: string;
+    buckets?: number[];
+    labels?: string[];
+}
+
+export interface TracingOptions {
+    enabled: boolean;
+    exporter?: 'otlp' | 'jaeger' | 'zipkin' | 'console';
+    endpoint?: string;
+    serviceName?: string;
+    sampleRate?: number;
+    alwaysTrace?: string[];
+    propagation?: 'w3c' | 'b3' | 'jaeger';
+}
+
+export interface LoggingOptions {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    format?: 'json' | 'pretty';
+    requests?: {
+        enabled?: boolean;
+        includeBody?: boolean;
+        excludePaths?: string[];
+    };
+    mask?: {
+        fields?: string[];
+        patterns?: RegExp[];
+        replacement?: string;
+    };
+    correlationId?: {
+        enabled?: boolean;
+        header?: string;
+        generator?: () => string;
+    };
+}
+
+export interface APMOptions {
+    /**
+     * Enable APM features
+     * Note: For full APM, use Sentry integration which includes
+     * enhanced APM with memory leak detection and slow query tracking
+     * @default true when observability is enabled
+     */
+    enabled?: boolean;
+
+    /**
+     * Slow query threshold in milliseconds
+     * @default 1000
+     */
+    slowQueryThreshold?: number;
+
+    /**
+     * Memory leak detection options
+     */
+    memoryLeakDetection?: {
+        enabled?: boolean;
+        /** 
+         * Memory growth threshold percentage (e.g., "50%" or 0.5)
+         * @default "50%"
+         */
+        threshold?: string | number;
+        /**
+         * Check interval in milliseconds
+         * @default 60000
+         */
+        interval?: number;
+    };
+
+    /**
+     * Deadlock detection (experimental)
+     * @default false
+     */
+    deadlockDetection?: boolean;
+
+    /**
+     * Profiling options
+     */
+    profiling?: {
+        enabled?: boolean;
+        sampleRate?: number;
+        includeStackTrace?: boolean;
+    };
+}
+
+export interface AlertDefinition {
+    name: string;
+    condition: string;
+    window: string;
+    channels: string[];
+    threshold?: number;
+}
+
+export interface AlertingOptions {
+    enabled?: boolean;
+    alerts?: AlertDefinition[];
+    channels?: {
+        slack?: { webhookUrl: string };
+        email?: { recipients: string[] };
+        pagerduty?: { routingKey: string };
+        webhook?: { url: string };
+        telegram?: { botToken: string; chatId: string };
+        discord?: { webhookUrl: string };
+        console?: {};
+    };
+}
+
+export interface HealthCheckDefinition {
+    name: string;
+    check: () => Promise<{ status: 'up' | 'down'; details?: Record<string, any> }>;
+    timeout?: number;
+    critical?: boolean;
+}
+
+export interface ObservabilityOptions {
+    metrics?: {
+        enabled?: boolean;
+        custom?: MetricDefinition[];
+        format?: 'prometheus' | 'json';
+        endpoint?: string;
+        defaultLabels?: Record<string, string>;
+    };
+    tracing?: TracingOptions;
+    logging?: LoggingOptions;
+    apm?: APMOptions;
+    alerting?: AlertingOptions;
+    health?: {
+        endpoint?: string;
+        checks?: HealthCheckDefinition[];
+    };
+}
+
+export type HistogramRecord = {
+    count: number;
+    sum: number;
+    buckets: number[];
+    bucketBoundaries: number[];
+};
+
+export type LabeledMetric<T> = Map<string, T>;
+
+export interface GaugeRecord {
+    value: number;
+    timestamp: number;
+}
+
+/**
+ * Span for distributed tracing
+ */
+export interface Span {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    status: 'ok' | 'error' | 'unset';
+    attributes: Record<string, any>;
+    events: Array<{ name: string; timestamp: number; attributes?: Record<string, any> }>;
+}
+
+/**
+ * Structured log entry
+ */
+export interface LogEntry {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+    correlationId?: string;
+    context?: Record<string, any>;
+    error?: { message: string; stack?: string };
+}

package/src/advanced/playground/extractPathParams.ts

@@ -0,0 +1,6 @@
+
+
+export function extractPathParams(path: string): Array<{ name: string; }> {
+    const matches = path.match(/:(\w+)/g) || [];
+    return matches.map(m => ({ name: m.slice(1) }));
+}

package/src/advanced/playground/generateFieldExample.ts

@@ -0,0 +1,31 @@
+import { zodToExample } from './zodToExample';
+
+
+
+export function generateFieldExample(field: any, fieldName: string): any {
+    if (!field?._def) return '';
+    const def = field._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case 'ZodString': {
+            for (const check of def.checks || []) {
+                if (check.kind === 'email') return 'user@example.com';
+                if (check.kind === 'url') return 'https://example.com';
+                if (check.kind === 'uuid') return '550e8400-e29b-41d4-a716-446655440000';
+            }
+            if (fieldName.toLowerCase().includes('email')) return 'user@example.com';
+            if (fieldName.toLowerCase().includes('password')) return 'password123';
+            if (fieldName.toLowerCase().includes('name')) return 'John Doe';
+            if (fieldName.toLowerCase().includes('username')) return 'johndoe';
+            return 'string';
+        }
+        case 'ZodNumber': return 0;
+        case 'ZodBoolean': return true;
+        case 'ZodArray': return [];
+        case 'ZodObject': return zodToExample(field);
+        case 'ZodEnum': return def.values?.[0] || 'enum';
+        case 'ZodOptional':
+        case 'ZodNullable': return generateFieldExample(def.innerType, fieldName);
+        default: return '';
+    }
+}