@teardown/ingest-api 0.1.46 → 0.1.47-alpha-01

package/generated/app.d.ts

@@ -8,6 +8,12 @@ export declare const baseApp: Elysia<"", {
 }, {
     typebox: {};
     error: {};
+} & {
+    typebox: {};
+    error: {};
+} & {
+    typebox: {};
+    error: {};
 } & {
     typebox: {};
     error: {
@@ -30,6 +36,20 @@ export declare const baseApp: Elysia<"", {
     macroFn: {};
     parser: {};
     response: {};
+} & {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
 } & {
     schema: {};
     standaloneSchema: {};
@@ -51,12 +71,23 @@ export declare const baseApp: Elysia<"", {
         body: unknown;
         params: {};
         query: unknown;
-        headers: unknown;
+        headers: {
+            "td-api-version"?: string | undefined;
+        };
         response: {
             200: import("@teardown/errors").ErrorResponse | {
                 message: string;
                 version: string;
             };
+            422: {
+                type: "validation";
+                on: string;
+                summary?: string;
+                message?: string;
+                found?: unknown;
+                property?: string;
+                expected?: string;
+            };
         };
     };
 } & {
@@ -65,7 +96,9 @@ export declare const baseApp: Elysia<"", {
             body: unknown;
             params: {};
             query: unknown;
-            headers: unknown;
+            headers: {
+                "td-api-version"?: string | undefined;
+            };
             response: {
                 200: import("@teardown/errors").ErrorResponse | {
                     status: string;
@@ -73,6 +106,15 @@ export declare const baseApp: Elysia<"", {
                     build_id: string;
                     service_id: string | undefined;
                 };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
             };
         };
     };
@@ -85,8 +127,9 @@ export declare const baseApp: Elysia<"", {
                 body: {
                     user?: {
                         name?: string | undefined;
-                        email?: string | undefined;
+                        persona_id?: string | undefined;
                         user_id?: string | undefined;
+                        email?: string | undefined;
                     } | undefined;
                     device: {
                         timestamp?: Date | undefined;
@@ -96,19 +139,17 @@ export declare const baseApp: Elysia<"", {
                             platform: import("@teardown/types").DevicePlatformEnum;
                         };
                         application: {
-                            build_number: number;
                             version: string;
+                            build_number: number;
                         };
                         hardware: {
-                            device_brand: string;
                             device_name: string;
                             device_type: string;
+                            device_brand: string;
                         };
                         update: {
-                            created_at: string;
-                            is_embedded_launch: boolean;
-                            update_id: string;
                             is_enabled: boolean;
+                            update_id: string;
                             update_channel: string;
                             runtime_version: string;
                             emergency_launch: {
@@ -118,6 +159,8 @@ export declare const baseApp: Elysia<"", {
                                 reason?: undefined;
                                 is_emergency_launch: false;
                             };
+                            is_embedded_launch: boolean;
+                            created_at: string;
                         } | null;
                     };
                 };
@@ -135,9 +178,9 @@ export declare const baseApp: Elysia<"", {
                     200: {
                         success: true;
                         data: {
-                            device_id: string;
                             user_id: string;
                             session_id: string;
+                            device_id: string;
                             token: string;
                             version_info: {
                                 status: import("@teardown/schemas").IdentifyVersionStatusEnum;
@@ -162,32 +205,32 @@ export declare const baseApp: Elysia<"", {
                         };
                     };
                     400: {
-                        success: false;
                         error: {
-                            message: string;
                             code: "MISSING_ORG_ID";
-                        } | {
                             message: string;
-                            code: "MISSING_PROJECT_ID";
                         } | {
+                            code: "MISSING_PROJECT_ID";
                             message: string;
-                            code: "MISSING_ENVIRONMENT_SLUG";
                         } | {
+                            code: "MISSING_ENVIRONMENT_SLUG";
                             message: string;
-                            code: "MISSING_DEVICE_ID";
                         } | {
+                            code: "MISSING_DEVICE_ID";
                             message: string;
-                            code: "IDENTIFY_FAILED";
                         } | {
+                            code: "IDENTIFY_FAILED";
                             message: string;
-                            code: "NO_SESSION_ID_GENERATED";
                         } | {
+                            code: "NO_SESSION_ID_GENERATED";
                             message: string;
-                            code: "NO_DEVICE_ID_GENERATED";
                         } | {
+                            code: "NO_DEVICE_ID_GENERATED";
                             message: string;
+                        } | {
                             code: "NO_USER_ID_GENERATED";
+                            message: string;
                         };
+                        success: false;
                     };
                     422: {
                         type: "validation";
@@ -209,13 +252,13 @@ export declare const baseApp: Elysia<"", {
         events: {
             post: {
                 body: {
-                    device_id?: string | undefined;
                     session_id?: string | undefined;
+                    device_id?: string | undefined;
                     events: {
                         properties?: {} | undefined;
-                        device_id?: string | undefined;
-                        session_id?: string | undefined;
                         timestamp?: string | undefined;
+                        session_id?: string | undefined;
+                        device_id?: string | undefined;
                         event_name: string;
                         event_type: "action" | "screen_view" | "custom";
                     }[];
@@ -240,35 +283,35 @@ export declare const baseApp: Elysia<"", {
                         };
                     };
                     400: {
-                        success: false;
                         error: {
-                            message: string;
                             code: "MISSING_ORG_ID";
-                        } | {
                             message: string;
-                            code: "MISSING_PROJECT_ID";
                         } | {
+                            code: "MISSING_PROJECT_ID";
                             message: string;
-                            code: "MISSING_ENVIRONMENT_SLUG";
                         } | {
+                            code: "MISSING_ENVIRONMENT_SLUG";
                             message: string;
-                            code: "MISSING_DEVICE_ID";
                         } | {
+                            code: "MISSING_DEVICE_ID";
                             message: string;
-                            code: "EVENTS_PROCESSING_FAILED";
                         } | {
+                            code: "EVENTS_PROCESSING_FAILED";
                             message: string;
-                            code: "INVALID_SESSION";
                         } | {
+                            code: "INVALID_SESSION";
                             message: string;
-                            code: "INVALID_DEVICE";
                         } | {
+                            code: "INVALID_DEVICE";
                             message: string;
-                            code: "BATCH_SIZE_EXCEEDED";
                         } | {
+                            code: "BATCH_SIZE_EXCEEDED";
                             message: string;
+                        } | {
                             code: "VALIDATION_ERROR";
+                            message: string;
                         };
+                        success: false;
                     };
                     422: {
                         type: "validation";
@@ -291,7 +334,10 @@ export declare const baseApp: Elysia<"", {
     response: {};
 }, {
     derive: {};
-    resolve: {};
+    resolve: {
+        readonly apiVersion: "2024-12-12";
+        readonly requestedVersion: string | null;
+    };
     schema: import("elysia").UnwrapRoute<{
         headers: z.ZodObject<{
             authorization: z.ZodOptional<z.ZodString>;
@@ -304,7 +350,10 @@ export declare const baseApp: Elysia<"", {
         }, z.core.$strip>;
     }, {}, "">;
     standaloneSchema: {};
-    response: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly apiVersion: "2024-12-12";
+        readonly requestedVersion: string | null;
+    }>;
 } & {
     derive: {};
     resolve: {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/ingest-api",
-	"version": "0.1.46",
+	"version": "0.1.47-alpha-01",
 	"private": false,
 	"publishConfig": {
 		"access": "public"

package/src/client/index.ts

@@ -1,2 +1,3 @@
 export * from "./client";
 export * from "./types";
+export * from "./ingest.client";

package/src/client/ingest.client.ts

@@ -0,0 +1,171 @@
+import { edenFetch } from "@elysiajs/eden";
+import { API_VERSION_HEADER } from "@teardown/schemas/contracts";
+import type { IdentifyRequest, IdentifyResponse } from "@teardown/schemas/identify";
+import type { IngestApp } from "../../generated/app";
+import type { ClientConfig, RequestOptions } from "./client";
+
+/**
+ * Ingest API Target Version
+ *
+ * This is the API contract version this client is built for.
+ * The client will send this version in the td-api-version header.
+ * Ingest API will validate and respond with the version used.
+ */
+export const INGEST_TARGET_API_VERSION = "2024-12-12";
+
+export type IngestApiClientOptions = {
+	/**
+	 * Base URL for the Ingest API
+	 */
+	url: string;
+	/**
+	 * API key for authentication
+	 */
+	apiKey: string;
+	/**
+	 * Organization ID
+	 */
+	orgId: string;
+	/**
+	 * Project ID
+	 */
+	projectId: string;
+	/**
+	 * Environment slug (e.g., "production", "staging")
+	 */
+	environmentSlug: string;
+	/**
+	 * Device ID (unique identifier for this device)
+	 */
+	deviceId: string;
+	/**
+	 * Session ID (optional, set after identify)
+	 */
+	sessionId?: string;
+	/**
+	 * Override the API version to use.
+	 * Defaults to INGEST_TARGET_API_VERSION.
+	 */
+	apiVersion?: string;
+	/**
+	 * Optional Eden fetch config
+	 */
+	config?: ClientConfig;
+	/**
+	 * Hook to modify request options before each request
+	 */
+	onRequest?: (endpoint: string, options: RequestOptions) => Promise<RequestOptions>;
+};
+
+type IngestClient = ReturnType<typeof edenFetch<typeof IngestApp>>;
+
+export class IngestApiClient {
+	private readonly client: IngestClient;
+	private readonly apiVersion: string;
+	private sessionId: string | undefined;
+
+	constructor(private readonly options: IngestApiClientOptions) {
+		this.client = edenFetch<typeof IngestApp>(this.options.url, this.options.config);
+		this.apiVersion = options.apiVersion ?? INGEST_TARGET_API_VERSION;
+		this.sessionId = options.sessionId;
+	}
+
+	/**
+	 * Get the API version this client is using
+	 */
+	getApiVersion(): string {
+		return this.apiVersion;
+	}
+
+	/**
+	 * Get the current session ID (if set)
+	 */
+	getSessionId(): string | undefined {
+		return this.sessionId;
+	}
+
+	/**
+	 * Set the session ID (typically after identify)
+	 */
+	setSessionId(sessionId: string): void {
+		this.sessionId = sessionId;
+	}
+
+	/**
+	 * Generate base headers for all requests
+	 */
+	generateBaseHeaders(): Record<string, string> {
+		const headers: Record<string, string> = {
+			// Always send API version header
+			[API_VERSION_HEADER]: this.apiVersion,
+			"td-api-key": this.options.apiKey,
+			"td-org-id": this.options.orgId,
+			"td-project-id": this.options.projectId,
+			"td-environment-slug": this.options.environmentSlug,
+			"td-device-id": this.options.deviceId,
+		};
+
+		if (this.sessionId) {
+			headers["td-session-id"] = this.sessionId;
+		}
+
+		return headers;
+	}
+
+	/**
+	 * Make a fetch request to the Ingest API
+	 * @internal Use typed convenience methods like identify() instead
+	 */
+	// biome-ignore lint/suspicious/noExplicitAny: Eden types are complex, using any for flexibility
+	async fetch(endpoint: string, options?: Record<string, any>): Promise<any> {
+		const baseHeaders = this.generateBaseHeaders();
+		const baseOptions = {
+			...options,
+			headers: {
+				...baseHeaders,
+				...options?.headers,
+			},
+		};
+
+		const requestOptions = this.options.onRequest
+			? await this.options.onRequest(endpoint, baseOptions as RequestOptions)
+			: baseOptions;
+
+		// biome-ignore lint/suspicious/noExplicitAny: Eden types require any cast
+		const result = await this.client(endpoint as any, requestOptions as any);
+
+		if (result.error) {
+			throw result.error;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Identify the current device/user
+	 * This should be called at app startup to establish a session
+	 */
+	async identify(request: IdentifyRequest): Promise<IdentifyResponse> {
+		const baseHeaders = this.generateBaseHeaders();
+
+		// biome-ignore lint/suspicious/noExplicitAny: Eden types are complex
+		const result = await this.client("/v1/identify" as any, {
+			method: "POST",
+			body: request,
+			headers: baseHeaders,
+		} as any);
+
+		if (result.error) {
+			throw result.error;
+		}
+
+		const data = result.data as IdentifyResponse;
+
+		// Automatically set session ID from response
+		if (data.success && data.data.session_id) {
+			this.setSessionId(data.data.session_id);
+		}
+
+		return data;
+	}
+}