@tracelens/shared 0.1.0

package/src/schemas/performance.schema.ts

@@ -0,0 +1,200 @@
+// Performance timing event schema for TraceLens
+export const PerformanceEventSchema = {
+  type: 'object',
+  required: ['id', 'timestamp', 'type', 'data', 'url', 'userAgent'],
+  properties: {
+    id: {
+      type: 'string',
+      pattern: '^[a-zA-Z0-9_-]+$',
+      minLength: 1,
+      maxLength: 100
+    },
+    timestamp: {
+      type: 'number',
+      minimum: 1577836800000, // 2020-01-01
+      maximum: 2524608000000  // 2050-01-01
+    },
+    type: {
+      type: 'string',
+      enum: ['web-vitals', 'resource-timing', 'navigation-timing', 'long-task']
+    },
+    data: {
+      oneOf: [
+        { $ref: '#/definitions/WebVitalsData' },
+        { $ref: '#/definitions/ResourceTimingData' },
+        { $ref: '#/definitions/NavigationTimingData' },
+        { $ref: '#/definitions/LongTaskData' }
+      ]
+    },
+    url: {
+      type: 'string',
+      format: 'uri',
+      maxLength: 2048
+    },
+    userAgent: {
+      type: 'string',
+      maxLength: 512
+    }
+  },
+  definitions: {
+    WebVitalsData: {
+      type: 'object',
+      properties: {
+        cls: { $ref: '#/definitions/CLSMetric' },
+        fid: { $ref: '#/definitions/FIDMetric' },
+        lcp: { $ref: '#/definitions/LCPMetric' },
+        fcp: { $ref: '#/definitions/FCPMetric' },
+        ttfb: { $ref: '#/definitions/TTFBMetric' },
+        inp: { $ref: '#/definitions/INPMetric' }
+      }
+    },
+    BaseMetric: {
+      type: 'object',
+      required: ['name', 'value', 'rating', 'delta', 'id', 'navigationType'],
+      properties: {
+        name: { type: 'string' },
+        value: { type: 'number', minimum: 0 },
+        rating: { 
+          type: 'string',
+          enum: ['good', 'needs-improvement', 'poor']
+        },
+        delta: { type: 'number' },
+        id: { type: 'string' },
+        navigationType: {
+          type: 'string',
+          enum: ['navigate', 'reload', 'back-forward', 'prerender']
+        }
+      }
+    },
+    CLSMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'CLS' },
+            value: { maximum: 1 }
+          }
+        }
+      ]
+    },
+    FIDMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'FID' },
+            value: { maximum: 10000 }
+          }
+        }
+      ]
+    },
+    LCPMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'LCP' },
+            value: { maximum: 30000 }
+          }
+        }
+      ]
+    },
+    FCPMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'FCP' },
+            value: { maximum: 10000 }
+          }
+        }
+      ]
+    },
+    TTFBMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'TTFB' },
+            value: { maximum: 5000 }
+          }
+        }
+      ]
+    },
+    INPMetric: {
+      allOf: [
+        { $ref: '#/definitions/BaseMetric' },
+        {
+          properties: {
+            name: { const: 'INP' },
+            value: { maximum: 1000 }
+          }
+        }
+      ]
+    },
+    ResourceTimingData: {
+      type: 'object',
+      required: ['name', 'entryType', 'startTime', 'duration'],
+      properties: {
+        name: { type: 'string', maxLength: 2048 },
+        entryType: { const: 'resource' },
+        startTime: { type: 'number', minimum: 0 },
+        duration: { type: 'number', minimum: 0 },
+        initiatorType: { type: 'string' },
+        nextHopProtocol: { type: 'string' },
+        renderBlockingStatus: { type: 'string' },
+        responseStatus: { type: 'number', minimum: 100, maximum: 599 },
+        transferSize: { type: 'number', minimum: 0 },
+        encodedBodySize: { type: 'number', minimum: 0 },
+        decodedBodySize: { type: 'number', minimum: 0 },
+        responseStart: { type: 'number', minimum: 0 },
+        responseEnd: { type: 'number', minimum: 0 }
+      }
+    },
+    NavigationTimingData: {
+      type: 'object',
+      required: ['type'],
+      properties: {
+        domComplete: { type: 'number', minimum: 0 },
+        domContentLoadedEventEnd: { type: 'number', minimum: 0 },
+        domContentLoadedEventStart: { type: 'number', minimum: 0 },
+        domInteractive: { type: 'number', minimum: 0 },
+        loadEventEnd: { type: 'number', minimum: 0 },
+        loadEventStart: { type: 'number', minimum: 0 },
+        redirectCount: { type: 'number', minimum: 0 },
+        type: {
+          type: 'string',
+          enum: ['navigate', 'reload', 'back-forward', 'prerender']
+        },
+        unloadEventEnd: { type: 'number', minimum: 0 },
+        unloadEventStart: { type: 'number', minimum: 0 }
+      }
+    },
+    LongTaskData: {
+      type: 'object',
+      required: ['name', 'entryType', 'startTime', 'duration'],
+      properties: {
+        name: { const: 'longtask' },
+        entryType: { const: 'longtask' },
+        startTime: { type: 'number', minimum: 0 },
+        duration: { type: 'number', minimum: 50 }, // Long tasks are >= 50ms
+        attribution: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              entryType: { const: 'taskattribution' },
+              startTime: { type: 'number', minimum: 0 },
+              duration: { type: 'number', minimum: 0 },
+              containerType: { type: 'string' },
+              containerSrc: { type: 'string' },
+              containerId: { type: 'string' },
+              containerName: { type: 'string' }
+            }
+          }
+        }
+      }
+    }
+  }
+} as const;

package/src/schemas/trace.schema.ts

@@ -0,0 +1,146 @@
+// Trace span event schema for TraceLens
+export const TraceSpanSchema = {
+  type: 'object',
+  required: ['traceId', 'spanId', 'operationName', 'startTime', 'tags', 'status'],
+  properties: {
+    traceId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{32}$',
+      description: 'Hexadecimal trace ID (32 characters)'
+    },
+    spanId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{16}$',
+      description: 'Hexadecimal span ID (16 characters)'
+    },
+    parentSpanId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{16}$',
+      description: 'Hexadecimal parent span ID (16 characters)'
+    },
+    operationName: {
+      type: 'string',
+      minLength: 1,
+      maxLength: 256,
+      description: 'Name of the operation being traced'
+    },
+    startTime: {
+      type: 'number',
+      minimum: 0,
+      description: 'Start time in microseconds since epoch'
+    },
+    endTime: {
+      type: 'number',
+      minimum: 0,
+      description: 'End time in microseconds since epoch'
+    },
+    duration: {
+      type: 'number',
+      minimum: 0,
+      description: 'Duration in microseconds'
+    },
+    tags: {
+      type: 'object',
+      patternProperties: {
+        '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+          oneOf: [
+            { type: 'string', maxLength: 1024 },
+            { type: 'number' },
+            { type: 'boolean' }
+          ]
+        }
+      },
+      additionalProperties: false,
+      description: 'Key-value pairs providing additional context'
+    },
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: ['timestamp', 'fields'],
+        properties: {
+          timestamp: {
+            type: 'number',
+            minimum: 0,
+            description: 'Log timestamp in microseconds since epoch'
+          },
+          fields: {
+            type: 'object',
+            patternProperties: {
+              '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                oneOf: [
+                  { type: 'string', maxLength: 1024 },
+                  { type: 'number' },
+                  { type: 'boolean' }
+                ]
+              }
+            },
+            additionalProperties: false
+          }
+        }
+      },
+      maxItems: 100,
+      description: 'Structured log events within the span'
+    },
+    status: {
+      type: 'string',
+      enum: [
+        'OK',
+        'CANCELLED',
+        'UNKNOWN',
+        'INVALID_ARGUMENT',
+        'DEADLINE_EXCEEDED',
+        'NOT_FOUND',
+        'ALREADY_EXISTS',
+        'PERMISSION_DENIED',
+        'RESOURCE_EXHAUSTED',
+        'FAILED_PRECONDITION',
+        'ABORTED',
+        'OUT_OF_RANGE',
+        'UNIMPLEMENTED',
+        'INTERNAL',
+        'UNAVAILABLE',
+        'DATA_LOSS',
+        'UNAUTHENTICATED'
+      ],
+      description: 'Span status indicating success or failure'
+    }
+  },
+  additionalProperties: false
+} as const;
+
+export const TraceSchema = {
+  type: 'object',
+  required: ['traceId', 'spans', 'startTime'],
+  properties: {
+    traceId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{32}$',
+      description: 'Hexadecimal trace ID (32 characters)'
+    },
+    spans: {
+      type: 'array',
+      items: TraceSpanSchema,
+      minItems: 1,
+      maxItems: 1000,
+      description: 'Array of spans that make up this trace'
+    },
+    startTime: {
+      type: 'number',
+      minimum: 0,
+      description: 'Trace start time in microseconds since epoch'
+    },
+    endTime: {
+      type: 'number',
+      minimum: 0,
+      description: 'Trace end time in microseconds since epoch'
+    },
+    duration: {
+      type: 'number',
+      minimum: 0,
+      description: 'Total trace duration in microseconds'
+    },
+    rootSpan: TraceSpanSchema
+  },
+  additionalProperties: false
+} as const;

package/src/types/dependency.types.ts

@@ -0,0 +1,120 @@
+// Package dependency structures for TraceLens
+export interface PackageDependency {
+  name: string;
+  version: string;
+  type: DependencyType;
+  resolved?: string;
+  integrity?: string;
+  dev?: boolean;
+  optional?: boolean;
+  bundled?: boolean;
+}
+
+export enum DependencyType {
+  PRODUCTION = 'production',
+  DEVELOPMENT = 'development',
+  PEER = 'peer',
+  OPTIONAL = 'optional',
+  BUNDLED = 'bundled'
+}
+
+export interface DependencyGraph {
+  projectId: string;
+  timestamp: number;
+  rootPackage: PackageInfo;
+  dependencies: Map<string, PackageDependency>;
+  dependencyTree: DependencyNode;
+  lockfileHash?: string;
+}
+
+export interface PackageInfo {
+  name: string;
+  version: string;
+  description?: string;
+  main?: string;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  bundledDependencies?: string[];
+}
+
+export interface DependencyNode {
+  name: string;
+  version: string;
+  path: string;
+  children: DependencyNode[];
+  parent?: DependencyNode;
+  depth: number;
+  circular?: boolean;
+}
+
+export interface RuntimeDependency {
+  name: string;
+  version: string;
+  loadTime: number;
+  executionTime: number;
+  memoryUsage: number;
+  importPath: string;
+  isEsm: boolean;
+  exports: string[];
+}
+
+export interface DependencySnapshot {
+  id: string;
+  projectId: string;
+  timestamp: number;
+  environment: 'development' | 'production' | 'test';
+  nodeVersion: string;
+  npmVersion?: string;
+  yarnVersion?: string;
+  packageManager: 'npm' | 'yarn' | 'pnpm';
+  dependencies: PackageDependency[];
+  runtimeDependencies: RuntimeDependency[];
+  totalSize: number;
+  bundleSize?: number;
+}
+
+export interface DependencyChange {
+  type: 'added' | 'removed' | 'updated';
+  package: string;
+  oldVersion?: string;
+  newVersion?: string;
+  timestamp: number;
+  reason?: string;
+}
+
+export interface DependencyAnalysis {
+  snapshotId: string;
+  criticalPath: string[];
+  bottlenecks: DependencyBottleneck[];
+  unusedDependencies: string[];
+  duplicateDependencies: DuplicateDependency[];
+  securityIssues: string[];
+  performanceImpact: PerformanceImpact;
+}
+
+export interface DependencyBottleneck {
+  package: string;
+  version: string;
+  impact: 'high' | 'medium' | 'low';
+  reason: 'load-time' | 'execution-time' | 'memory-usage' | 'bundle-size';
+  value: number;
+  threshold: number;
+}
+
+export interface DuplicateDependency {
+  package: string;
+  versions: string[];
+  paths: string[];
+  wastedSize: number;
+}
+
+export interface PerformanceImpact {
+  totalLoadTime: number;
+  totalExecutionTime: number;
+  totalMemoryUsage: number;
+  criticalPathTime: number;
+  parallelizableTime: number;
+}

package/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+// Shared type definitions
+export * from './trace.types';
+export * from './performance.types';
+export * from './dependency.types';
+export * from './security.types';
+
+export interface BaseEvent {
+  id: string;
+  timestamp: number;
+  projectId: string;
+}

package/src/types/performance.types.ts

@@ -0,0 +1,108 @@
+// Web Vitals and performance timing types for TraceLens
+export interface WebVitalsMetrics {
+  cls?: CLSMetric;
+  fid?: FIDMetric;
+  lcp?: LCPMetric;
+  fcp?: FCPMetric;
+  ttfb?: TTFBMetric;
+  inp?: INPMetric;
+}
+
+export interface BaseMetric {
+  name: string;
+  value: number;
+  rating: 'good' | 'needs-improvement' | 'poor';
+  delta: number;
+  entries: unknown[]; // Generic entries array
+  id: string;
+  navigationType: NavigationType;
+}
+
+export interface CLSMetric extends BaseMetric {
+  name: 'CLS';
+  entries: unknown[]; // Layout shift entries
+}
+
+export interface FIDMetric extends BaseMetric {
+  name: 'FID';
+  entries: unknown[]; // Performance event timing entries
+}
+
+export interface LCPMetric extends BaseMetric {
+  name: 'LCP';
+  entries: unknown[]; // Largest contentful paint entries
+}
+
+export interface FCPMetric extends BaseMetric {
+  name: 'FCP';
+  entries: unknown[]; // Performance paint timing entries
+}
+
+export interface TTFBMetric extends BaseMetric {
+  name: 'TTFB';
+  entries: unknown[]; // Performance navigation timing entries
+}
+
+export interface INPMetric extends BaseMetric {
+  name: 'INP';
+  entries: unknown[]; // Performance event timing entries
+}
+
+export type NavigationType = 'navigate' | 'reload' | 'back-forward' | 'prerender';
+
+export interface ResourceTiming {
+  name: string;
+  entryType: string;
+  startTime: number;
+  duration: number;
+  initiatorType: string;
+  nextHopProtocol: string;
+  renderBlockingStatus: string;
+  responseStatus: number;
+  transferSize: number;
+  encodedBodySize: number;
+  decodedBodySize: number;
+  responseStart: number;
+  responseEnd: number;
+}
+
+export interface NavigationTiming {
+  domComplete: number;
+  domContentLoadedEventEnd: number;
+  domContentLoadedEventStart: number;
+  domInteractive: number;
+  loadEventEnd: number;
+  loadEventStart: number;
+  redirectCount: number;
+  type: NavigationType;
+  unloadEventEnd: number;
+  unloadEventStart: number;
+}
+
+export interface LongTask {
+  name: string;
+  entryType: 'longtask';
+  startTime: number;
+  duration: number;
+  attribution: TaskAttributionTiming[];
+}
+
+export interface TaskAttributionTiming {
+  name: string;
+  entryType: 'taskattribution';
+  startTime: number;
+  duration: number;
+  containerType: string;
+  containerSrc: string;
+  containerId: string;
+  containerName: string;
+}
+
+export interface PerformanceEvent {
+  id: string;
+  timestamp: number;
+  type: 'web-vitals' | 'resource-timing' | 'navigation-timing' | 'long-task';
+  data: WebVitalsMetrics | ResourceTiming | NavigationTiming | LongTask;
+  url: string;
+  userAgent: string;
+}