@tracelens/shared 0.1.0

package/dist/__tests__/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.test.d.ts.map

package/dist/__tests__/validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/validation.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/validation.test.js

@@ -0,0 +1,16 @@
+// 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/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './utils';
+export * from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

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

package/dist/schemas/dependency.schema.d.ts

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

package/dist/schemas/dependency.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/dependency.schema.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyL3B,CAAC"}

package/dist/schemas/dependency.schema.js

@@ -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
+};

package/dist/schemas/error.schema.d.ts

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

package/dist/schemas/error.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/error.schema.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8KnB,CAAC"}