@od-oneapp/analytics 2026.2.1501-canary.1 → 2026.2.1701

package/service-Duqnlppl.mjs

@@ -0,0 +1,1049 @@
+import { t as ConsoleProvider } from "./console-8bND3mMU.mjs";
+import { b as validateEventName, v as createAnalyticsManager, y as sanitizeProperties } from "./posthog-bootstrap-CYfIy_WS.mjs";
+import { t as PROVIDER_REQUIREMENTS } from "./config-P6P5adJg.mjs";
+import { HttpServerProvider } from "./providers-http-server.mjs";
+import { logError, logInfo, logWarn } from "@od-oneapp/shared/logger";
+import { logDebug as logDebug$1, logError as logError$1, logInfo as logInfo$1, logWarn as logWarn$1 } from "@od-oneapp/shared/logs";
+import { z } from "zod";
+
+//#region ../../integrations/segment/src/analytics-provider/server.ts
+var SegmentServerProvider = class {
+	name = "segment";
+	analytics = null;
+	config;
+	isInitialized = false;
+	constructor(config) {
+		if (!config.writeKey) throw new Error("Segment writeKey is required");
+		this.config = {
+			options: config.options,
+			writeKey: config.writeKey
+		};
+	}
+	async initialize() {
+		if (this.isInitialized) return;
+		const { Analytics } = await import(
+			/* webpackChunkName: "segment-analytics" */
+			"@segment/analytics-next"
+);
+		this.analytics = new Analytics({
+			writeKey: this.config.writeKey,
+			...this.config.options
+		});
+		this.isInitialized = true;
+	}
+	async track(event, properties = {}, _context) {
+		if (!this.analytics) return;
+		await this.analytics.track({
+			event,
+			properties
+		});
+	}
+	async identify(userId, traits = {}, _context) {
+		if (!this.analytics) return;
+		await this.analytics.identify({
+			userId,
+			traits
+		});
+	}
+	async page(name, properties = {}, _context) {
+		if (!this.analytics) return;
+		await this.analytics.page({
+			...name && { name },
+			properties
+		});
+	}
+	async group(groupId, traits = {}, _context) {
+		if (!this.analytics) return;
+		await this.analytics.group({
+			groupId,
+			traits
+		});
+	}
+	async alias(userId, previousId, _context) {
+		if (!this.analytics) return;
+		await this.analytics.alias({
+			userId,
+			previousId
+		});
+	}
+};
+
+//#endregion
+//#region ../../integrations/vercel/src/analytics-provider/server.ts
+var VercelServerProvider = class {
+	name = "vercel";
+	isInitialized = false;
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	async initialize() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+	}
+	async track(event, properties = {}) {
+		if (!this.isInitialized) return;
+		this.config;
+	}
+	async identify(userId, traits = {}) {
+		await this.track("User Identified", {
+			userId,
+			...traits
+		});
+	}
+	async page(name, properties = {}) {
+		await this.track("Page View (Server)", {
+			page: name,
+			...properties
+		});
+	}
+	async group(groupId, traits = {}) {
+		await this.track("Group Identified", {
+			groupId,
+			...traits
+		});
+	}
+	async alias(userId, previousId) {
+		await this.track("User Aliased", {
+			previousId,
+			userId
+		});
+	}
+};
+
+//#endregion
+//#region src/server/manager.ts
+/**
+* @fileoverview Server analytics manager with static provider registry
+* Server analytics manager with static provider registry
+*/
+const SERVER_PROVIDERS = {
+	console: (config) => new ConsoleProvider(config),
+	http: (config) => new HttpServerProvider(config),
+	segment: (config) => new SegmentServerProvider(config),
+	vercel: (config) => new VercelServerProvider(config)
+};
+/**
+* Create and initialize a server analytics instance
+* This is the primary way to create analytics for server-side applications
+*
+* @example
+* ```typescript
+* const analytics = await createServerAnalytics({
+*   providers: {
+*     segment: { writeKey: process.env.SEGMENT_KEY! },
+*   },
+* });
+* await analytics.page('/admin', { title: 'Admin Dashboard' });
+* ```
+* @param config - Analytics configuration including providers and settings
+* @returns Promise resolving to initialized analytics manager
+*/
+async function createServerAnalytics(config) {
+	const manager = createAnalyticsManager(config, SERVER_PROVIDERS);
+	await manager.initialize();
+	return manager;
+}
+/**
+* Create a server analytics instance without initializing
+* Useful when you need to control initialization timing
+*
+* @example
+* ```typescript
+* const analytics = createServerAnalyticsUninitialized(config);
+* if (shouldEmit) {
+*   await analytics.initialize();
+*   await analytics.track('CRON Completed');
+* }
+* ```
+* @param config - Analytics configuration including providers and settings
+* @returns Uninitialized analytics manager instance
+*/
+function createServerAnalyticsUninitialized(config) {
+	return createAnalyticsManager(config, SERVER_PROVIDERS);
+}
+
+//#endregion
+//#region src/shared/utils/validation.ts
+/**
+* @fileoverview Validation utilities for analytics configuration
+*
+* This module provides comprehensive validation for analytics configurations,
+* including provider validation, environment-specific checks, and helpful
+* warnings for common misconfigurations.
+*
+* **Features**:
+* - Configuration structure validation
+* - Provider-specific field validation
+* - Environment variable validation
+* - Environment-specific warnings
+* - Detailed error reporting
+*
+* @module @od-oneapp/analytics/shared/utils/validation
+*/
+/**
+* Comprehensive configuration validation.
+*
+* Validates the entire analytics configuration structure, including:
+* - Configuration object structure
+* - Providers object existence
+* - Individual provider configurations
+* - Environment-specific warnings
+*
+* Accepts `unknown` input for defensive validation of potentially malformed configs.
+*
+* @param {unknown} config - Analytics configuration to validate
+* @returns {ValidationResult} Validation result with errors, warnings, and validity status
+*
+* @example
+* ```typescript
+* const result = validateAnalyticsConfig(config);
+* if (!result.isValid) {
+*   console.error('Validation errors:', result.errors);
+* }
+* if (result.warnings.length > 0) {
+*   console.warn('Warnings:', result.warnings);
+* }
+* ```
+*/
+function validateAnalyticsConfig(config) {
+	const errors = [];
+	const warnings = [];
+	if (!config || typeof config !== "object") {
+		errors.push({
+			provider: "global",
+			field: "config",
+			message: "Analytics configuration is required and must be an object"
+		});
+		return {
+			isValid: false,
+			errors,
+			warnings
+		};
+	}
+	const typedConfig = config;
+	if (!typedConfig.providers || typeof typedConfig.providers !== "object") {
+		errors.push({
+			provider: "global",
+			field: "providers",
+			message: "Providers configuration is required and must be an object"
+		});
+		return {
+			isValid: false,
+			errors,
+			warnings
+		};
+	}
+	if (Object.keys(typedConfig.providers).length === 0) warnings.push("No providers configured. Analytics will not track any events.");
+	for (const [providerName, providerConfig] of Object.entries(typedConfig.providers)) {
+		const providerErrors = validateProvider(providerName, providerConfig);
+		errors.push(...providerErrors);
+	}
+	const isBrowser = typeof window !== "undefined";
+	if (isBrowser && typedConfig.providers.mixpanel) warnings.push("Mixpanel provider configured on client-side. Consider using server-side for better performance.");
+	if (!isBrowser && typedConfig.providers.vercel) warnings.push("Vercel Analytics has limited server-side support. Consider using client-side for better features.");
+	return {
+		isValid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+/**
+* Validate a single provider configuration.
+*
+* Checks that the provider is known and that all required fields are present.
+*
+* @param {string} providerName - Name of the provider to validate
+* @param {ProviderConfig} config - Provider configuration to validate
+* @returns {ValidationError[]} Array of validation errors (empty if valid)
+*
+* @example
+* ```typescript
+* const errors = validateProvider('posthog', { apiKey: 'phc_xxx' });
+* if (errors.length > 0) {
+*   console.error('Provider errors:', errors);
+* }
+* ```
+*/
+function validateProvider(providerName, config) {
+	const errors = [];
+	const knownProviders = [
+		"segment",
+		"posthog",
+		"vercel",
+		"console",
+		"mixpanel"
+	];
+	if (!knownProviders.includes(providerName)) {
+		errors.push({
+			provider: providerName,
+			field: "name",
+			message: `Unknown provider '${providerName}'. Known providers: ${knownProviders.join(", ")}`
+		});
+		return errors;
+	}
+	const requiredFields = PROVIDER_REQUIREMENTS[providerName] ?? [];
+	for (const field of requiredFields) {
+		const value = config[field];
+		if (!value) errors.push({
+			provider: providerName,
+			field,
+			message: `Required field '${field}' is missing for provider '${providerName}'`
+		});
+		else if (typeof value === "string" && value.trim() === "") errors.push({
+			provider: providerName,
+			field,
+			message: `Required field '${field}' cannot be empty for provider '${providerName}'`
+		});
+	}
+	switch (providerName) {
+		case "segment":
+			if (config.writeKey && !isValidSegmentWriteKey(config.writeKey)) errors.push({
+				provider: providerName,
+				field: "writeKey",
+				message: "Segment writeKey appears to be invalid format"
+			});
+			break;
+		case "posthog":
+			if (config.apiKey && !isValidPostHogApiKey(config.apiKey)) errors.push({
+				provider: providerName,
+				field: "apiKey",
+				message: "PostHog apiKey appears to be invalid format"
+			});
+			break;
+	}
+	return errors;
+}
+/**
+* Validates Segment write key format.
+*
+* Checks that the write key matches Segment's expected format:
+* - Exactly 32 alphanumeric characters
+* - Not a placeholder value
+*
+* @param {string} writeKey - Write key to validate
+* @returns {boolean} `true` if valid, `false` otherwise
+*
+* @internal
+*/
+function isValidSegmentWriteKey(writeKey) {
+	if (!/^[\dA-Za-z]{32}$/.test(writeKey)) return false;
+	if ([
+		"your-write-key",
+		"paste-key-here",
+		"xxxxxxxx",
+		"example"
+	].some((p) => writeKey.toLowerCase().includes(p.toLowerCase()))) return false;
+	return true;
+}
+/**
+* Validates PostHog API key format.
+*
+* Checks that the API key matches PostHog's expected format:
+* - Starts with `phc_` prefix
+* - Followed by 43 alphanumeric/dash/underscore characters
+* - Not a placeholder value
+*
+* @param {string} apiKey - API key to validate
+* @returns {boolean} `true` if valid, `false` otherwise
+*
+* @internal
+*/
+function isValidPostHogApiKey(apiKey) {
+	if (!/^phc_[\w-]{43}$/.test(apiKey)) return false;
+	if ([
+		"your-api-key",
+		"paste-key-here",
+		"xxxxxxxx",
+		"example"
+	].some((p) => apiKey.toLowerCase().includes(p.toLowerCase()))) return false;
+	return true;
+}
+/**
+* Utility to throw validation errors (for strict validation).
+*
+* Validates the configuration and throws an error if validation fails.
+* Useful for ensuring configuration is valid before using analytics.
+*
+* @param {AnalyticsConfig} config - Analytics configuration to validate
+* @throws {Error} If configuration validation fails
+*
+* @example
+* ```typescript
+* try {
+*   validateConfigOrThrow(config);
+*   // Configuration is valid, proceed
+* } catch (error) {
+*   console.error('Invalid config:', error.message);
+* }
+* ```
+*/
+function validateConfigOrThrow(config) {
+	const result = validateAnalyticsConfig(config);
+	if (!result.isValid) {
+		const errorMessages = result.errors.map((error) => `${error.provider}.${error.field}: ${error.message}`).join("\n");
+		throw new Error(`Analytics configuration validation failed:\n${errorMessages}`);
+	}
+	if (result.warnings.length > 0 && config.onError) config.onError(/* @__PURE__ */ new Error("Analytics configuration warnings"), {
+		provider: "analytics",
+		method: "validateConfig",
+		warnings: result.warnings
+	});
+}
+/**
+* Development helper to check configuration.
+*
+* Logs configuration details and validation results for debugging.
+* Only useful in development environments.
+*
+* @param {AnalyticsConfig} config - Analytics configuration to debug
+* @returns {Promise<void>} Promise that resolves when debugging is complete
+*
+* @example
+* ```typescript
+* if (process.env.NODE_ENV === 'development') {
+*   await debugConfig(config);
+* }
+* ```
+*/
+async function debugConfig(config) {
+	const result = validateAnalyticsConfig(config);
+	logInfo("Analytics Configuration Debug", {
+		config,
+		validationResult: result
+	});
+	if (result.errors.length > 0) logError("Analytics configuration errors: Validation failed", { errors: result.errors });
+	if (result.warnings.length > 0) logWarn("Analytics configuration warnings", { warnings: result.warnings });
+}
+
+//#endregion
+//#region src/shared/ingestion/schemas.ts
+/**
+* @fileoverview Event Ingestion Schemas and Validation
+*
+* Defines Zod schemas for validating event ingestion payloads. These schemas
+* ensure type-safe, secure event ingestion with proper validation.
+*
+* **Key Features**:
+* - CloudEvents-style fields for future interoperability
+* - Support for single events and batched arrays
+* - Strict validation of required fields
+* - Typed extensions per event category
+*
+* @module @od-oneapp/analytics/shared/ingestion/schemas
+*/
+/**
+* Property value schema - safe, serializable values only.
+*/
+const PropertyValueSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.date()
+]);
+/**
+* Property object schema with nested structure support.
+*/
+const PropertyObjectSchema = z.record(z.string(), z.lazy(() => z.union([
+	PropertyValueSchema,
+	z.array(PropertyValueSchema),
+	z.record(z.string(), z.unknown())
+])));
+/**
+* Emitter context schema - contextual information about the environment.
+*/
+const EmitterContextSchema = z.object({
+	app: z.object({
+		name: z.string().optional(),
+		version: z.string().optional(),
+		build: z.string().optional(),
+		namespace: z.string().optional()
+	}).optional(),
+	campaign: z.object({
+		name: z.string().optional(),
+		source: z.string().optional(),
+		medium: z.string().optional(),
+		term: z.string().optional(),
+		content: z.string().optional()
+	}).passthrough().optional(),
+	device: z.object({
+		id: z.string().optional(),
+		manufacturer: z.string().optional(),
+		model: z.string().optional(),
+		name: z.string().optional(),
+		type: z.string().optional(),
+		version: z.string().optional()
+	}).optional(),
+	ip: z.string().optional(),
+	library: z.object({
+		name: z.string(),
+		version: z.string()
+	}).optional(),
+	locale: z.string().optional(),
+	network: z.object({
+		bluetooth: z.boolean().optional(),
+		carrier: z.string().optional(),
+		cellular: z.boolean().optional(),
+		wifi: z.boolean().optional()
+	}).optional(),
+	os: z.object({
+		name: z.string().optional(),
+		version: z.string().optional()
+	}).optional(),
+	page: z.object({
+		path: z.string().optional(),
+		referrer: z.string().optional(),
+		search: z.string().optional(),
+		title: z.string().optional(),
+		url: z.string().optional()
+	}).optional(),
+	screen: z.object({
+		density: z.number().optional(),
+		height: z.number().int().positive().optional(),
+		width: z.number().int().positive().optional()
+	}).optional(),
+	timezone: z.string().optional(),
+	groupId: z.string().optional(),
+	userAgent: z.string().optional(),
+	channel: z.enum([
+		"server",
+		"browser",
+		"mobile",
+		"api"
+	]).optional(),
+	location: z.object({
+		city: z.string().optional(),
+		country: z.string().optional(),
+		latitude: z.number().optional(),
+		longitude: z.number().optional(),
+		region: z.string().optional()
+	}).optional()
+}).passthrough();
+/**
+* Base payload schema - common fields for all event types.
+*/
+const BasePayloadSchema = z.object({
+	anonymousId: z.string().max(255).optional(),
+	userId: z.string().max(255).optional(),
+	timestamp: z.union([z.string().datetime(), z.date()]).optional(),
+	originalTimestamp: z.union([z.string().datetime(), z.date()]).optional(),
+	context: EmitterContextSchema.optional(),
+	messageId: z.string().uuid().optional()
+}).refine((data) => Boolean(data.anonymousId) || Boolean(data.userId), { message: "Either anonymousId or userId must be provided" });
+/**
+* Track event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const TrackEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("track"),
+	event: z.string().min(1).max(255),
+	properties: PropertyObjectSchema.optional()
+});
+/**
+* Identify event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const IdentifyEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("identify"),
+	userId: z.string().min(1).max(255),
+	traits: PropertyObjectSchema.optional()
+});
+/**
+* Page event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const PageEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("page"),
+	name: z.string().max(255).optional(),
+	category: z.string().max(255).optional(),
+	properties: PropertyObjectSchema.optional()
+});
+/**
+* Screen event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const ScreenEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("screen"),
+	name: z.string().max(255).optional(),
+	category: z.string().max(255).optional(),
+	properties: PropertyObjectSchema.optional()
+});
+/**
+* Group event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const GroupEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("group"),
+	groupId: z.string().min(1).max(255),
+	traits: PropertyObjectSchema.optional()
+});
+/**
+* Alias event payload schema.
+* Uses safeExtend() because BasePayloadSchema has refinements (Zod v4 requirement).
+*/
+const AliasEventSchema = BasePayloadSchema.safeExtend({
+	type: z.literal("alias"),
+	userId: z.string().min(1).max(255),
+	previousId: z.string().min(1).max(255)
+});
+/**
+* Union of all event payload schemas.
+*/
+const EventPayloadSchema = z.discriminatedUnion("type", [
+	TrackEventSchema,
+	IdentifyEventSchema,
+	PageEventSchema,
+	ScreenEventSchema,
+	GroupEventSchema,
+	AliasEventSchema
+]);
+/**
+* Single event ingestion request schema.
+*/
+const SingleEventRequestSchema = EventPayloadSchema;
+/**
+* Batch event ingestion request schema.
+*
+* The batch size limit is enforced at the service level via `maxBatchSize` config
+* (default: 100) rather than in the schema, allowing for flexible configuration.
+*/
+const BatchEventRequestSchema = z.object({ batch: z.array(EventPayloadSchema).min(1) });
+/**
+* Combined ingestion request schema - accepts single event or batch.
+*/
+const IngestionRequestSchema = z.union([BatchEventRequestSchema, SingleEventRequestSchema]);
+/**
+* Event processing result.
+*/
+const EventResultSchema = z.object({
+	id: z.string().uuid(),
+	messageId: z.string().uuid().optional(),
+	type: z.enum([
+		"track",
+		"identify",
+		"page",
+		"screen",
+		"group",
+		"alias"
+	]),
+	status: z.enum(["accepted", "rejected"]),
+	error: z.string().optional()
+});
+/**
+* Successful ingestion response schema.
+*/
+const IngestionSuccessResponseSchema = z.object({
+	success: z.literal(true),
+	accepted: z.number().int().nonnegative(),
+	rejected: z.number().int().nonnegative(),
+	results: z.array(EventResultSchema),
+	receivedAt: z.string().datetime()
+});
+/**
+* Error response schema.
+*/
+const IngestionErrorResponseSchema = z.object({
+	success: z.literal(false),
+	code: z.string(),
+	error: z.string(),
+	fieldErrors: z.array(z.object({
+		path: z.array(z.union([z.string(), z.number()])),
+		message: z.string()
+	})).optional()
+});
+/**
+* Combined response schema.
+*/
+const IngestionResponseSchema = z.union([IngestionSuccessResponseSchema, IngestionErrorResponseSchema]);
+
+//#endregion
+//#region src/shared/ingestion/service.ts
+/**
+* @fileoverview Event Ingestion Service
+*
+* Provides server-side event ingestion functionality. Handles validation,
+* normalization, and forwarding of events to the analytics system.
+*
+* **Key Features**:
+* - Validates incoming events against Zod schemas
+* - Normalizes event payloads with defaults
+* - Forwards events to AnalyticsManager
+* - Tracks ingestion metrics
+* - Handles batch processing efficiently
+*
+* @module @od-oneapp/analytics/shared/ingestion/service
+*/
+const DEFAULT_CONFIG = {
+	maxBatchSize: 100,
+	maxPayloadSize: 1024 * 1024,
+	stripPII: true,
+	stripHTML: true,
+	eventTimeout: 5e3,
+	batchConcurrency: 10
+};
+/**
+* Generate a UUID v4.
+*/
+function generateUUID() {
+	return crypto.randomUUID();
+}
+/**
+* Get current ISO timestamp.
+*/
+function getCurrentTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/**
+* Check if request is a batch request.
+*/
+function isBatchRequest(request) {
+	return "batch" in request && Array.isArray(request.batch);
+}
+/**
+* Normalize an event payload with defaults and server metadata.
+*/
+function normalizeEvent(event, context, receivedAt) {
+	const normalized = { ...event };
+	if (!normalized.messageId) normalized.messageId = generateUUID();
+	if (!normalized.timestamp) normalized.timestamp = receivedAt;
+	if (!normalized.originalTimestamp) normalized.originalTimestamp = normalized.timestamp;
+	normalized.context = {
+		...normalized.context,
+		channel: normalized.context?.channel ?? "api",
+		ip: context.ip ?? normalized.context?.ip,
+		userAgent: context.userAgent ?? normalized.context?.userAgent,
+		library: normalized.context?.library ?? {
+			name: context.source,
+			version: context.sdkVersion ?? "unknown"
+		}
+	};
+	if (!normalized.userId && context.userId) normalized.userId = context.userId;
+	return normalized;
+}
+/**
+* Convert EventPayload to EmitterPayload format for AnalyticsManager.
+* Explicitly maps fields to ensure type safety.
+*/
+function toEmitterPayload(event) {
+	const basePayload = {
+		userId: event.userId,
+		anonymousId: event.anonymousId,
+		timestamp: event.timestamp,
+		context: event.context,
+		messageId: event.messageId
+	};
+	switch (event.type) {
+		case "track": return {
+			type: "track",
+			event: event.event,
+			properties: event.properties,
+			...basePayload
+		};
+		case "identify": return {
+			type: "identify",
+			traits: event.traits,
+			...basePayload
+		};
+		case "page": return {
+			type: "page",
+			name: event.name,
+			category: event.category,
+			properties: event.properties,
+			...basePayload
+		};
+		case "screen": return {
+			type: "screen",
+			name: event.name,
+			category: event.category,
+			properties: event.properties,
+			...basePayload
+		};
+		case "group": return {
+			type: "group",
+			groupId: event.groupId,
+			traits: event.traits,
+			...basePayload
+		};
+		case "alias": return {
+			type: "alias",
+			previousId: event.previousId,
+			...basePayload
+		};
+		default: throw new Error(`Unknown event type: ${event.type}`);
+	}
+}
+/**
+* Event Ingestion Service.
+*
+* Handles validation, normalization, and forwarding of analytics events.
+* Designed for high-volume ingestion with batching and rate limiting support.
+*
+* @example
+* ```typescript
+* const service = new IngestionService(analyticsManager);
+*
+* const result = await service.ingest(requestBody, {
+*   source: 'web-app',
+*   tenantId: 'tenant-123',
+*   userId: 'user-456',
+* });
+*
+* if (result.success) {
+*   console.log(`Accepted ${result.accepted} events`);
+* }
+* ```
+*/
+var IngestionService = class {
+	config;
+	constructor(analyticsManager, config = {}) {
+		this.analyticsManager = analyticsManager;
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Parse and validate the ingestion request payload.
+	*
+	* @param payload - Raw request payload (parsed JSON)
+	* @returns Parsed and validated request, or error response
+	*/
+	parseRequest(payload) {
+		try {
+			const payloadSize = JSON.stringify(payload).length;
+			if (payloadSize > this.config.maxPayloadSize) return {
+				success: false,
+				error: {
+					success: false,
+					code: "PAYLOAD_TOO_LARGE",
+					error: `Payload size ${payloadSize} exceeds maximum ${this.config.maxPayloadSize} bytes`
+				}
+			};
+		} catch {
+			return {
+				success: false,
+				error: {
+					success: false,
+					code: "INVALID_JSON",
+					error: "Failed to serialize payload for size check"
+				}
+			};
+		}
+		const result = IngestionRequestSchema.safeParse(payload);
+		if (!result.success) return {
+			success: false,
+			error: {
+				success: false,
+				code: "VALIDATION_ERROR",
+				error: "Request validation failed",
+				fieldErrors: result.error.issues.map((err) => ({
+					path: err.path.map((p) => typeof p === "symbol" ? String(p) : p),
+					message: err.message
+				}))
+			}
+		};
+		if (isBatchRequest(result.data) && result.data.batch.length > this.config.maxBatchSize) return {
+			success: false,
+			error: {
+				success: false,
+				code: "BATCH_TOO_LARGE",
+				error: `Batch size ${result.data.batch.length} exceeds maximum ${this.config.maxBatchSize}`
+			}
+		};
+		return {
+			success: true,
+			data: result.data
+		};
+	}
+	/**
+	* Ingest events from a validated request.
+	*
+	* @param request - Validated ingestion request
+	* @param context - Ingestion context from the caller
+	* @returns Ingestion response with per-event results
+	*/
+	async ingest(request, context) {
+		const startTime = process.hrtime.bigint();
+		const receivedAt = getCurrentTimestamp();
+		const events = isBatchRequest(request) ? request.batch : [request];
+		const results = [];
+		const metrics = {
+			totalReceived: events.length,
+			accepted: 0,
+			rejected: 0,
+			byType: {},
+			processingTimeMs: 0
+		};
+		const processedEvents = [];
+		for (const event of events) {
+			const eventId = generateUUID();
+			try {
+				if (event.type === "track") {
+					const validation = validateEventName(event.event);
+					if (!validation.valid) {
+						results.push({
+							id: eventId,
+							messageId: event.messageId,
+							type: event.type,
+							status: "rejected",
+							error: `Invalid event name: ${validation.reason}`
+						});
+						metrics.rejected++;
+						continue;
+					}
+				}
+				const normalized = normalizeEvent(event, context, receivedAt);
+				if ("properties" in normalized && normalized.properties) {
+					const sanitized = sanitizeProperties(normalized.properties, {
+						stripPII: this.config.stripPII,
+						stripHTML: this.config.stripHTML,
+						allowDangerousKeys: false
+					});
+					normalized.properties = sanitized.data;
+					if (sanitized.warnings.length > 0) logDebug$1("Event properties sanitized", {
+						eventId,
+						warnings: sanitized.warnings
+					});
+				}
+				if ("traits" in normalized && normalized.traits) normalized.traits = sanitizeProperties(normalized.traits, {
+					stripPII: this.config.stripPII,
+					stripHTML: this.config.stripHTML,
+					allowDangerousKeys: false
+				}).data;
+				const emitterPayload = toEmitterPayload(normalized);
+				processedEvents.push(emitterPayload);
+				results.push({
+					id: eventId,
+					messageId: normalized.messageId,
+					type: event.type,
+					status: "accepted"
+				});
+				metrics.accepted++;
+				metrics.byType[event.type] = (metrics.byType[event.type] ?? 0) + 1;
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error";
+				results.push({
+					id: eventId,
+					messageId: event.messageId,
+					type: event.type,
+					status: "rejected",
+					error: errorMessage
+				});
+				metrics.rejected++;
+				logWarn$1("Event processing failed", {
+					eventId,
+					type: event.type,
+					error: errorMessage
+				});
+			}
+		}
+		if (processedEvents.length > 0) (async () => {
+			try {
+				await this.analyticsManager.emitBatch(processedEvents, {
+					timeout: this.config.eventTimeout,
+					concurrency: this.config.batchConcurrency,
+					failFast: false
+				});
+			} catch (error) {
+				logError$1("Failed to emit events to analytics manager", {
+					error: error instanceof Error ? error.message : "Unknown error",
+					eventCount: processedEvents.length,
+					traceId: context.traceId
+				});
+			}
+		})();
+		const endTime = process.hrtime.bigint();
+		metrics.processingTimeMs = Number(endTime - startTime) / 1e6;
+		logInfo$1("Event ingestion completed", {
+			traceId: context.traceId,
+			source: context.source,
+			tenantId: context.tenantId,
+			totalReceived: metrics.totalReceived,
+			accepted: metrics.accepted,
+			rejected: metrics.rejected,
+			processingTimeMs: metrics.processingTimeMs.toFixed(2),
+			byType: metrics.byType
+		});
+		return {
+			success: true,
+			accepted: metrics.accepted,
+			rejected: metrics.rejected,
+			results,
+			receivedAt
+		};
+	}
+	/**
+	* Process a raw request body through parsing and ingestion.
+	*
+	* Convenience method that combines parseRequest and ingest.
+	*
+	* @param payload - Raw request payload
+	* @param context - Ingestion context
+	* @returns Ingestion response (success or error)
+	*/
+	async processRequest(payload, context) {
+		const parseResult = this.parseRequest(payload);
+		if (!parseResult.success) return parseResult.error;
+		return this.ingest(parseResult.data, context);
+	}
+};
+/**
+* Create an ingestion service instance.
+*
+* @param analyticsManager - Initialized AnalyticsManager instance
+* @param config - Optional service configuration
+* @returns Configured IngestionService instance
+*
+* @example
+* ```typescript
+* import { createServerAnalytics } from '@od-oneapp/analytics/server';
+* import { createIngestionService } from '@od-oneapp/analytics/server';
+*
+* const analytics = await createServerAnalytics(config);
+* const ingestionService = createIngestionService(analytics);
+* ```
+*/
+function createIngestionService(analyticsManager, config) {
+	return new IngestionService(analyticsManager, config);
+}
+/**
+* Validate a single event payload.
+*
+* Useful for pre-validation before queuing events.
+*
+* @param payload - Event payload to validate
+* @returns Validation result with parsed data or errors
+*/
+function validateEventPayload(payload) {
+	const result = EventPayloadSchema.safeParse(payload);
+	if (!result.success) return {
+		success: false,
+		errors: result.error.issues.map((e) => `${e.path.map((p) => typeof p === "symbol" ? String(p) : p).join(".")}: ${e.message}`)
+	};
+	return {
+		success: true,
+		data: result.data
+	};
+}
+/**
+* Validate a batch of event payloads.
+*
+* @param payloads - Array of event payloads to validate
+* @returns Validation result with parsed data or errors
+*/
+function validateBatchPayload(payloads) {
+	const result = BatchEventRequestSchema.safeParse({ batch: payloads });
+	if (!result.success) return {
+		success: false,
+		errors: result.error.issues.map((e) => `${e.path.map((p) => typeof p === "symbol" ? String(p) : p).join(".")}: ${e.message}`)
+	};
+	return {
+		success: true,
+		data: result.data.batch
+	};
+}
+
+//#endregion
+export { debugConfig as a, validateProvider as c, validateEventPayload as i, createServerAnalytics as l, createIngestionService as n, validateAnalyticsConfig as o, validateBatchPayload as r, validateConfigOrThrow as s, IngestionService as t, createServerAnalyticsUninitialized as u };
+//# sourceMappingURL=service-Duqnlppl.mjs.map