@tracelens/shared 0.1.0

package/dist/schemas/error.schema.js

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

package/dist/schemas/index.d.ts

@@ -0,0 +1,5 @@
+export * from './performance.schema';
+export * from './trace.schema';
+export * from './dependency.schema';
+export * from './error.schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}

package/dist/schemas/index.js

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

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

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

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

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