@tracelens/shared 0.1.0

package/dist/utils/validation.js

@@ -0,0 +1,157 @@
+export class ValidationError extends Error {
+    field;
+    value;
+    constructor(message, field, value) {
+        super(message);
+        this.field = field;
+        this.value = value;
+        this.name = 'ValidationError';
+    }
+}
+export function validateTraceSpan(span) {
+    if (!span || typeof span !== 'object') {
+        throw new ValidationError('Span must be an object', 'span', span);
+    }
+    const s = span;
+    if (!s.traceId || typeof s.traceId !== 'string') {
+        throw new ValidationError('traceId must be a string', 'traceId', s.traceId);
+    }
+    if (!s.spanId || typeof s.spanId !== 'string') {
+        throw new ValidationError('spanId must be a string', 'spanId', s.spanId);
+    }
+    if (!s.operationName || typeof s.operationName !== 'string') {
+        throw new ValidationError('operationName must be a string', 'operationName', s.operationName);
+    }
+    if (!s.startTime || typeof s.startTime !== 'number') {
+        throw new ValidationError('startTime must be a number', 'startTime', s.startTime);
+    }
+    if (s.endTime !== undefined && typeof s.endTime !== 'number') {
+        throw new ValidationError('endTime must be a number', 'endTime', s.endTime);
+    }
+    if (!s.tags || typeof s.tags !== 'object') {
+        throw new ValidationError('tags must be an object', 'tags', s.tags);
+    }
+    return s;
+}
+export function validateTrace(trace) {
+    if (!trace || typeof trace !== 'object') {
+        throw new ValidationError('Trace must be an object', 'trace', trace);
+    }
+    const t = trace;
+    if (!t.traceId || typeof t.traceId !== 'string') {
+        throw new ValidationError('traceId must be a string', 'traceId', t.traceId);
+    }
+    if (!Array.isArray(t.spans)) {
+        throw new ValidationError('spans must be an array', 'spans', t.spans);
+    }
+    // Validate each span
+    t.spans.forEach((span, index) => {
+        try {
+            validateTraceSpan(span);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new ValidationError(`Invalid span at index ${index}: ${errorMessage}`, `spans[${index}]`, span);
+        }
+    });
+    return t;
+}
+export function validatePerformanceEvent(event) {
+    if (!event || typeof event !== 'object') {
+        throw new ValidationError('Event must be an object', 'event', event);
+    }
+    const e = event;
+    if (!e.id || typeof e.id !== 'string') {
+        throw new ValidationError('id must be a string', 'id', e.id);
+    }
+    if (!e.timestamp || typeof e.timestamp !== 'number') {
+        throw new ValidationError('timestamp must be a number', 'timestamp', e.timestamp);
+    }
+    const validTypes = ['web-vitals', 'resource-timing', 'navigation-timing', 'long-task'];
+    if (!e.type || !validTypes.includes(e.type)) {
+        throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`, 'type', e.type);
+    }
+    if (!e.url || typeof e.url !== 'string') {
+        throw new ValidationError('url must be a string', 'url', e.url);
+    }
+    return e;
+}
+export function validateDependencySnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object') {
+        throw new ValidationError('Snapshot must be an object', 'snapshot', snapshot);
+    }
+    const s = snapshot;
+    if (!s.id || typeof s.id !== 'string') {
+        throw new ValidationError('id must be a string', 'id', s.id);
+    }
+    if (!s.projectId || typeof s.projectId !== 'string') {
+        throw new ValidationError('projectId must be a string', 'projectId', s.projectId);
+    }
+    if (!s.timestamp || typeof s.timestamp !== 'number') {
+        throw new ValidationError('timestamp must be a number', 'timestamp', s.timestamp);
+    }
+    if (!Array.isArray(s.dependencies)) {
+        throw new ValidationError('dependencies must be an array', 'dependencies', s.dependencies);
+    }
+    return s;
+}
+export function validateCVERecord(cve) {
+    if (!cve || typeof cve !== 'object') {
+        throw new ValidationError('CVE must be an object', 'cve', cve);
+    }
+    const c = cve;
+    if (!c.id || typeof c.id !== 'string') {
+        throw new ValidationError('id must be a string', 'id', c.id);
+    }
+    // Validate CVE ID format
+    const cveIdPattern = /^CVE-\d{4}-\d{4,}$/;
+    if (!cveIdPattern.test(c.id)) {
+        throw new ValidationError('id must be in CVE-YYYY-NNNN format', 'id', c.id);
+    }
+    if (!c.published || typeof c.published !== 'string') {
+        throw new ValidationError('published must be a string', 'published', c.published);
+    }
+    return c;
+}
+export function sanitizeInput(input) {
+    // Remove potentially dangerous characters
+    return input
+        .replace(/[<>]/g, '') // Remove angle brackets
+        .replace(/javascript:/gi, '') // Remove javascript: protocol
+        .replace(/on\w+=/gi, '') // Remove event handlers
+        .trim();
+}
+export function validateProjectId(projectId) {
+    // Project ID should be alphanumeric with hyphens and underscores
+    const projectIdPattern = /^[a-zA-Z0-9_-]+$/;
+    return projectIdPattern.test(projectId) && projectId.length >= 3 && projectId.length <= 50;
+}
+export function validateTimestamp(timestamp) {
+    // Timestamp should be a reasonable Unix timestamp (after 2020, before 2050)
+    const minTimestamp = 1577836800000; // 2020-01-01
+    const maxTimestamp = 2524608000000; // 2050-01-01
+    return timestamp >= minTimestamp && timestamp <= maxTimestamp;
+}
+export function validateUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function validateVersion(version) {
+    // Validate semantic version format
+    const semverPattern = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*)?(?:\+[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*)?$/;
+    return semverPattern.test(version);
+}
+export function isValidJSON(str) {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/jest.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/__tests__/**',
+  ],
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@tracelens/shared",
+  "version": "0.1.0",
+  "description": "Shared types and utilities for TraceLens",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src/**/*.ts",
+    "test": "jest",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@tracelens/eslint-config": "file:../../tools/eslint-config",
+    "@tracelens/tsconfig": "file:../../tools/tsconfig",
+    "@types/jest": "^29.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.0.0"
+  }
+}

package/src/__tests__/validation.test.ts

@@ -0,0 +1,19 @@
+// Basic validation test
+import { validateProjectId, validateTimestamp, validateVersion } from '../utils/validation';
+
+describe('Basic Validation', () => {
+  test('validateProjectId works', () => {
+    expect(validateProjectId('my-project')).toBe(true);
+    expect(validateProjectId('ab')).toBe(false);
+  });
+
+  test('validateTimestamp works', () => {
+    expect(validateTimestamp(Date.now())).toBe(true);
+    expect(validateTimestamp(0)).toBe(false);
+  });
+
+  test('validateVersion works', () => {
+    expect(validateVersion('1.0.0')).toBe(true);
+    expect(validateVersion('invalid')).toBe(false);
+  });
+});

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/src/index.ts

@@ -0,0 +1,4 @@
+// TraceLens Shared Types and Utilities
+export * from './types';
+export * from './utils';
+export * from './schemas';

package/src/schemas/dependency.schema.ts

@@ -0,0 +1,187 @@
+// Dependency snapshot schema for TraceLens
+export const DependencySnapshotSchema = {
+  type: 'object',
+  required: [
+    'id',
+    'projectId', 
+    'timestamp',
+    'environment',
+    'nodeVersion',
+    'packageManager',
+    'dependencies',
+    'runtimeDependencies',
+    'totalSize'
+  ],
+  properties: {
+    id: {
+      type: 'string',
+      pattern: '^[a-zA-Z0-9_-]+$',
+      minLength: 1,
+      maxLength: 100,
+      description: 'Unique identifier for this dependency snapshot'
+    },
+    projectId: {
+      type: 'string',
+      pattern: '^[a-zA-Z0-9_-]+$',
+      minLength: 3,
+      maxLength: 50,
+      description: 'Project identifier'
+    },
+    timestamp: {
+      type: 'number',
+      minimum: 1577836800000, // 2020-01-01
+      maximum: 2524608000000, // 2050-01-01
+      description: 'Snapshot timestamp in milliseconds since epoch'
+    },
+    environment: {
+      type: 'string',
+      enum: ['development', 'production', 'test'],
+      description: 'Environment where snapshot was taken'
+    },
+    nodeVersion: {
+      type: 'string',
+      pattern: '^v?\\d+\\.\\d+\\.\\d+',
+      description: 'Node.js version (e.g., v18.17.0)'
+    },
+    npmVersion: {
+      type: 'string',
+      pattern: '^\\d+\\.\\d+\\.\\d+',
+      description: 'npm version if applicable'
+    },
+    yarnVersion: {
+      type: 'string',
+      pattern: '^\\d+\\.\\d+\\.\\d+',
+      description: 'Yarn version if applicable'
+    },
+    packageManager: {
+      type: 'string',
+      enum: ['npm', 'yarn', 'pnpm'],
+      description: 'Package manager used'
+    },
+    dependencies: {
+      type: 'array',
+      items: {
+        $ref: '#/definitions/PackageDependency'
+      },
+      maxItems: 10000,
+      description: 'List of package dependencies'
+    },
+    runtimeDependencies: {
+      type: 'array',
+      items: {
+        $ref: '#/definitions/RuntimeDependency'
+      },
+      maxItems: 10000,
+      description: 'List of runtime dependencies with execution data'
+    },
+    totalSize: {
+      type: 'number',
+      minimum: 0,
+      description: 'Total size of all dependencies in bytes'
+    },
+    bundleSize: {
+      type: 'number',
+      minimum: 0,
+      description: 'Bundle size in bytes if applicable'
+    }
+  },
+  definitions: {
+    PackageDependency: {
+      type: 'object',
+      required: ['name', 'version', 'type'],
+      properties: {
+        name: {
+          type: 'string',
+          pattern: '^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$',
+          maxLength: 214,
+          description: 'Package name (npm naming rules)'
+        },
+        version: {
+          type: 'string',
+          pattern: '^\\d+\\.\\d+\\.\\d+(?:-[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)?(?:\\+[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)?$',
+          description: 'Semantic version'
+        },
+        type: {
+          type: 'string',
+          enum: ['production', 'development', 'peer', 'optional', 'bundled'],
+          description: 'Dependency type'
+        },
+        resolved: {
+          type: 'string',
+          format: 'uri',
+          description: 'Resolved URL for the package'
+        },
+        integrity: {
+          type: 'string',
+          pattern: '^(sha1|sha256|sha384|sha512)-[A-Za-z0-9+/]+=*$',
+          description: 'Package integrity hash'
+        },
+        dev: {
+          type: 'boolean',
+          description: 'Whether this is a development dependency'
+        },
+        optional: {
+          type: 'boolean',
+          description: 'Whether this is an optional dependency'
+        },
+        bundled: {
+          type: 'boolean',
+          description: 'Whether this dependency is bundled'
+        }
+      },
+      additionalProperties: false
+    },
+    RuntimeDependency: {
+      type: 'object',
+      required: ['name', 'version', 'loadTime', 'executionTime', 'memoryUsage', 'importPath', 'isEsm'],
+      properties: {
+        name: {
+          type: 'string',
+          pattern: '^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$',
+          maxLength: 214,
+          description: 'Package name'
+        },
+        version: {
+          type: 'string',
+          pattern: '^\\d+\\.\\d+\\.\\d+(?:-[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)?(?:\\+[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)?$',
+          description: 'Package version'
+        },
+        loadTime: {
+          type: 'number',
+          minimum: 0,
+          description: 'Time to load the module in milliseconds'
+        },
+        executionTime: {
+          type: 'number',
+          minimum: 0,
+          description: 'Time to execute module initialization in milliseconds'
+        },
+        memoryUsage: {
+          type: 'number',
+          minimum: 0,
+          description: 'Memory usage in bytes'
+        },
+        importPath: {
+          type: 'string',
+          maxLength: 1024,
+          description: 'Import path used to load the module'
+        },
+        isEsm: {
+          type: 'boolean',
+          description: 'Whether the module is an ES module'
+        },
+        exports: {
+          type: 'array',
+          items: {
+            type: 'string',
+            maxLength: 256
+          },
+          maxItems: 1000,
+          description: 'List of exported symbols'
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
+} as const;

package/src/schemas/error.schema.ts

@@ -0,0 +1,176 @@
+// Error event schema for TraceLens
+export const ErrorEventSchema = {
+  type: 'object',
+  required: ['id', 'timestamp', 'type', 'message', 'source', 'projectId'],
+  properties: {
+    id: {
+      type: 'string',
+      pattern: '^[a-zA-Z0-9_-]+$',
+      minLength: 1,
+      maxLength: 100,
+      description: 'Unique identifier for this error event'
+    },
+    timestamp: {
+      type: 'number',
+      minimum: 1577836800000, // 2020-01-01
+      maximum: 2524608000000, // 2050-01-01
+      description: 'Error timestamp in milliseconds since epoch'
+    },
+    type: {
+      type: 'string',
+      enum: [
+        'javascript-error',
+        'unhandled-promise-rejection',
+        'resource-error',
+        'network-error',
+        'csp-violation',
+        'server-error',
+        'database-error',
+        'validation-error'
+      ],
+      description: 'Type of error that occurred'
+    },
+    message: {
+      type: 'string',
+      maxLength: 2048,
+      description: 'Error message'
+    },
+    source: {
+      type: 'string',
+      enum: ['browser', 'server', 'network'],
+      description: 'Source of the error'
+    },
+    projectId: {
+      type: 'string',
+      pattern: '^[a-zA-Z0-9_-]+$',
+      minLength: 3,
+      maxLength: 50,
+      description: 'Project identifier'
+    },
+    stack: {
+      type: 'string',
+      maxLength: 8192,
+      description: 'Error stack trace'
+    },
+    filename: {
+      type: 'string',
+      maxLength: 1024,
+      description: 'File where error occurred'
+    },
+    lineno: {
+      type: 'number',
+      minimum: 0,
+      description: 'Line number where error occurred'
+    },
+    colno: {
+      type: 'number',
+      minimum: 0,
+      description: 'Column number where error occurred'
+    },
+    url: {
+      type: 'string',
+      format: 'uri',
+      maxLength: 2048,
+      description: 'URL where error occurred'
+    },
+    userAgent: {
+      type: 'string',
+      maxLength: 512,
+      description: 'User agent string'
+    },
+    userId: {
+      type: 'string',
+      maxLength: 100,
+      description: 'User identifier (if available)'
+    },
+    sessionId: {
+      type: 'string',
+      maxLength: 100,
+      description: 'Session identifier'
+    },
+    traceId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{32}$',
+      description: 'Associated trace ID if available'
+    },
+    spanId: {
+      type: 'string',
+      pattern: '^[a-f0-9]{16}$',
+      description: 'Associated span ID if available'
+    },
+    severity: {
+      type: 'string',
+      enum: ['low', 'medium', 'high', 'critical'],
+      description: 'Error severity level'
+    },
+    tags: {
+      type: 'object',
+      patternProperties: {
+        '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+          oneOf: [
+            { type: 'string', maxLength: 256 },
+            { type: 'number' },
+            { type: 'boolean' }
+          ]
+        }
+      },
+      additionalProperties: false,
+      maxProperties: 50,
+      description: 'Additional tags for categorization'
+    },
+    context: {
+      type: 'object',
+      properties: {
+        component: {
+          type: 'string',
+          maxLength: 256,
+          description: 'Component where error occurred'
+        },
+        action: {
+          type: 'string',
+          maxLength: 256,
+          description: 'Action being performed when error occurred'
+        },
+        environment: {
+          type: 'string',
+          enum: ['development', 'staging', 'production'],
+          description: 'Environment where error occurred'
+        },
+        version: {
+          type: 'string',
+          maxLength: 50,
+          description: 'Application version'
+        },
+        buildId: {
+          type: 'string',
+          maxLength: 100,
+          description: 'Build identifier'
+        }
+      },
+      additionalProperties: false,
+      description: 'Additional context about the error'
+    },
+    fingerprint: {
+      type: 'string',
+      pattern: '^[a-f0-9]{32}$',
+      description: 'Error fingerprint for grouping similar errors'
+    },
+    count: {
+      type: 'number',
+      minimum: 1,
+      default: 1,
+      description: 'Number of times this error occurred'
+    },
+    firstSeen: {
+      type: 'number',
+      minimum: 1577836800000,
+      description: 'Timestamp when this error was first seen'
+    },
+    lastSeen: {
+      type: 'number',
+      minimum: 1577836800000,
+      description: 'Timestamp when this error was last seen'
+    }
+  },
+  additionalProperties: false
+} as const;

package/src/schemas/index.ts

@@ -0,0 +1,5 @@
+// Schema exports
+export * from './performance.schema';
+export * from './trace.schema';
+export * from './dependency.schema';
+export * from './error.schema';