@teardown/ingest-api 0.0.20 → 0.0.21-alpha.11

package/dist/client/client.d.ts

@@ -1,9 +1,239 @@
 import { edenFetch } from "@elysiajs/eden";
-import type { IngestApp } from "../types/app";
-export type ClientConfig = NonNullable<Parameters<typeof edenFetch<IngestApp>>[1]>;
-export declare const client: (server: string, config?: import("@elysiajs/eden/fetch").EdenFetch.Config) => import("@elysiajs/eden/fetch").EdenFetch.Fn<unknown>;
+import type { IngestApp } from "@teardown/ingest/types";
+export type ClientConfig = NonNullable<Parameters<typeof edenFetch<typeof IngestApp>>[1]>;
+export declare const client: (server: string, config?: import("@elysiajs/eden/fetch").EdenFetch.Config) => import("@elysiajs/eden/fetch").EdenFetch.Fn<{
+    "/health": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("@teardown/errors").ErrorResponse | {
+                    status: string;
+                    timestamp: string;
+                };
+            };
+        };
+    };
+} & {
+    "": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("@teardown/errors").ErrorResponse | {
+                    message: string;
+                    version: string;
+                };
+            };
+        };
+    };
+} & {
+    "/v1/identify": {
+        post: {
+            body: {
+                device: {
+                    application: {
+                        version: string;
+                        build_number: string;
+                    };
+                    update: {
+                        is_enabled: boolean;
+                        update_id: string;
+                        update_channel: string;
+                        runtime_version: string;
+                        emergency_launch: {
+                            is_emergency_launch: true;
+                            reason: string;
+                        } | {
+                            is_emergency_launch: false;
+                            reason?: undefined;
+                        };
+                        is_embedded_launch: boolean;
+                        created_at: Date;
+                    } | null;
+                    hardware: {
+                        device_name: string;
+                        device_type: string;
+                        device_brand: string;
+                    };
+                    os: {
+                        platform: import("@teardown/types").DevicePlatformEnum;
+                        name: string;
+                        version: string;
+                    };
+                    notifications: {
+                        push: {
+                            enabled: boolean;
+                            granted: boolean;
+                            token: string | null;
+                            platform: import("@teardown/schemas").NotificationPlatform;
+                        };
+                    };
+                    timestamp?: Date | undefined;
+                };
+                persona?: {
+                    user_id?: string | undefined;
+                    email?: string | undefined;
+                    name?: string | undefined;
+                } | undefined;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                "td-org-id": string;
+                "td-project-id": string;
+                "td-environment-slug": string;
+                "td-device-id": string;
+                authorization?: string | undefined;
+                "td-session-id"?: string | undefined;
+            };
+            response: {
+                200: {
+                    success: true;
+                    data: {
+                        session_id: string;
+                        device_id: string;
+                        persona_id: string;
+                        token: string;
+                        version_info: {
+                            status: import("@teardown/schemas").IdentifyVersionStatusEnum;
+                            update?: {
+                                status: import("@teardown/schemas").IdentifyVersionStatusEnum.UPDATE_AVAILABLE;
+                                update: {
+                                    version: string;
+                                    build: string;
+                                    update_id: string;
+                                    effective_date: Date;
+                                };
+                            } | null | undefined;
+                        };
+                    };
+                };
+                400: {
+                    success: false;
+                    error: {
+                        code: "MISSING_ORG_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_PROJECT_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_ENVIRONMENT_SLUG";
+                        message: string;
+                    } | {
+                        code: "MISSING_DEVICE_ID";
+                        message: string;
+                    } | {
+                        code: "IDENTIFY_FAILED";
+                        message: string;
+                    } | {
+                        code: "NO_SESSION_ID_GENERATED";
+                        message: string;
+                    } | {
+                        code: "NO_DEVICE_ID_GENERATED";
+                        message: string;
+                    } | {
+                        code: "NO_PERSONA_ID_GENERATED";
+                        message: string;
+                    };
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    "/v1/events": {
+        post: {
+            body: {
+                events: {
+                    event_name: string;
+                    event_type: "action" | "screen_view" | "custom";
+                    properties?: Record<string, unknown> | undefined;
+                    timestamp?: Date | undefined;
+                    session_id?: string | undefined;
+                    device_id?: string | undefined;
+                }[];
+                session_id?: string | undefined;
+                device_id?: string | undefined;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                "td-org-id": string;
+                "td-project-id": string;
+                "td-environment-slug": string;
+                authorization?: string | undefined;
+                "td-device-id"?: string | undefined;
+                "td-session-id"?: string | undefined;
+            };
+            response: {
+                200: {
+                    success: true;
+                    data: {
+                        event_ids: string[];
+                        processed_count: number;
+                        failed_count: number;
+                    };
+                };
+                400: {
+                    success: false;
+                    error: {
+                        code: "MISSING_ORG_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_PROJECT_ID";
+                        message: string;
+                    } | {
+                        code: "MISSING_ENVIRONMENT_SLUG";
+                        message: string;
+                    } | {
+                        code: "MISSING_DEVICE_ID";
+                        message: string;
+                    } | {
+                        code: "EVENTS_PROCESSING_FAILED";
+                        message: string;
+                    } | {
+                        code: "INVALID_SESSION";
+                        message: string;
+                    } | {
+                        code: "INVALID_DEVICE";
+                        message: string;
+                    } | {
+                        code: "BATCH_SIZE_EXCEEDED";
+                        message: string;
+                    } | {
+                        code: "VALIDATION_ERROR";
+                        message: string;
+                    };
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+}>;
 export type Client = ReturnType<typeof client>;
 export type RequestOptions = Omit<NonNullable<Parameters<Client>[1]>, "headers"> & {
     headers?: Record<string, string>;
 };
 export type Endpoints = Parameters<Client>[0];
+export type App = typeof IngestApp;

package/dist/client/types.d.ts

@@ -17,7 +17,23 @@ export type UnionToIntersect<U> = (U extends any ? (arg: U) => any : never) exte
 export type IsAny<T> = 0 extends 1 & T ? true : false;
 export type IsNever<T> = [T] extends [never] ? true : false;
 export type IsUnknown<T> = IsAny<T> extends true ? false : unknown extends T ? true : false;
-export type AnyTypedRoute = {
+export type IsExactlyUnknown<T> = [T] extends [unknown] ? ([unknown] extends [T] ? true : false) : false;
+export type IsUndefined<T> = [T] extends [undefined] ? true : false;
+export type IsMatchingEmptyObject<T> = [T] extends [{}] ? ([{}] extends [T] ? true : false) : false;
+export type MaybeEmptyObject<TObj, TKey extends PropertyKey, TFallback = Record<string, unknown>> = IsUndefined<TObj> extends true ? {
+    [K in TKey]?: TFallback;
+} : IsExactlyUnknown<TObj> extends true ? {
+    [K in TKey]?: TFallback;
+} : IsMatchingEmptyObject<TObj> extends true ? {
+    [K in TKey]?: TObj;
+} : undefined extends TObj ? {
+    [K in TKey]?: TObj;
+} : null extends TObj ? {
+    [K in TKey]?: TObj;
+} : {
+    [K in TKey]: TObj;
+};
+type AnyTypedRoute = {
     body?: unknown;
     headers?: unknown;
     query?: unknown;
@@ -39,36 +55,4 @@ export type TreatyToPath<T, Path extends string = ""> = UnionToIntersect<T exten
     } : TreatyToPath<T[K], `${Path}/${K & string}`>;
 }[keyof T] : {}>;
 export type Not<T> = T extends true ? false : true;
-export type Fn<Schema extends Record<string, any>> = <Endpoint extends keyof Schema, Method extends Uppercase<Extract<keyof Schema[Endpoint], string>>, Route extends Schema[Endpoint][Lowercase<Method>]>(endpoint: Endpoint, options: Omit<RequestInit, "body" | "method" | "headers"> & ("GET" extends Method ? {
-    method?: Method;
-} : {
-    method: Method;
-}) & (IsNever<keyof Route["params"]> extends true ? {
-    params?: Record<never, string>;
-} : {
-    params: Route["params"];
-}) & (IsNever<keyof Route["query"]> extends true ? {
-    query?: Record<never, string>;
-} : {
-    query: Route["query"];
-}) & (undefined extends Route["headers"] ? {
-    headers?: Record<string, string>;
-} : {
-    headers: Route["headers"];
-}) & (IsUnknown<Route["body"]> extends false ? {
-    body: Route["body"];
-} : {
-    body?: unknown;
-})) => Promise<Prettify<{
-    data: Awaited<Route["response"][200]>;
-    error: null;
-    status: number;
-    headers: Record<string, unknown>;
-    retry(): Promise<void>;
-} | {
-    data: null;
-    error: MapError<Route["response"]> extends infer Errors ? IsNever<Errors> extends true ? EdenFetchError<number, string> : Errors : EdenFetchError<number, string>;
-    status: number;
-    headers: Record<string, unknown>;
-    retry(): Promise<void>;
-}>>;
+export {};

package/dist/schemas/index.d.ts

@@ -1 +1 @@
-export * from "./identify.schema";
+export * from "../vendored/schemas/identify";

package/dist/schemas/index.js

@@ -1 +1 @@
-export * from "./identify.schema";
+export * from "../vendored/schemas/identify";

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
-export type { OSType, DeviceType, ApplicationInfo, OSInfo, HardwareInfo, UpdateInfo, DeviceInfo, PersonaInfo, IdentifyRequest, IdentifyResponse, IdentifyErrorResponse, } from "../schemas/identify.schema";
-export type { IngestApp } from "./app";
+import * as IdentifySchemas from "../vendored/schemas/identify";
+export { IdentifySchemas };

package/dist/types/index.js

@@ -1 +1,2 @@
-export {};
+import * as IdentifySchemas from "../vendored/schemas/identify";
+export { IdentifySchemas };

package/dist/vendored/schemas/identify.d.ts

@@ -0,0 +1,303 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
+import { z } from "zod";
+export { DevicePlatformEnum };
+/**
+ * Application info schema
+ */
+export declare const ApplicationInfoSchema: z.ZodObject<{
+    version: z.ZodString;
+    build_number: z.ZodString;
+}, z.core.$strip>;
+export type ApplicationInfo = z.infer<typeof ApplicationInfoSchema>;
+/**
+ * OS info schema
+ */
+export declare const OSInfoSchema: z.ZodObject<{
+    platform: z.ZodEnum<typeof DevicePlatformEnum>;
+    name: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type OSInfo = z.infer<typeof OSInfoSchema>;
+/**
+ * Hardware info schema
+ */
+export declare const HardwareInfoSchema: z.ZodObject<{
+    device_name: z.ZodString;
+    device_type: z.ZodString;
+    device_brand: z.ZodString;
+}, z.core.$strip>;
+export type HardwareInfo = z.infer<typeof HardwareInfoSchema>;
+export declare const EmergencyLaunchSchema: z.ZodUnion<readonly [z.ZodObject<{
+    is_emergency_launch: z.ZodLiteral<true>;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    is_emergency_launch: z.ZodLiteral<false>;
+    reason: z.ZodOptional<z.ZodNever>;
+}, z.core.$strip>]>;
+export type EmergencyLaunch = z.infer<typeof EmergencyLaunchSchema>;
+/**
+ * Update info schema
+ */
+export declare const DeviceUpdateInfoSchema: z.ZodObject<{
+    is_enabled: z.ZodBoolean;
+    update_id: z.ZodString;
+    update_channel: z.ZodString;
+    runtime_version: z.ZodString;
+    emergency_launch: z.ZodUnion<readonly [z.ZodObject<{
+        is_emergency_launch: z.ZodLiteral<true>;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        is_emergency_launch: z.ZodLiteral<false>;
+        reason: z.ZodOptional<z.ZodNever>;
+    }, z.core.$strip>]>;
+    is_embedded_launch: z.ZodBoolean;
+    created_at: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type DeviceUpdateInfo = z.infer<typeof DeviceUpdateInfoSchema>;
+export declare enum NotificationPlatform {
+    APNS = "APNS",// Apple Push Notification Service
+    FCM = "FCM",// Firebase Cloud Messaging
+    EXPO = "EXPO"
+}
+/**
+ * Push notification info schema
+ */
+export declare const PushNotificationInfoSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    granted: z.ZodBoolean;
+    token: z.ZodNullable<z.ZodString>;
+    platform: z.ZodEnum<typeof NotificationPlatform>;
+}, z.core.$strip>;
+export type PushNotificationInfo = z.infer<typeof PushNotificationInfoSchema>;
+export declare const NotificationsInfoSchema: z.ZodObject<{
+    push: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        granted: z.ZodBoolean;
+        token: z.ZodNullable<z.ZodString>;
+        platform: z.ZodEnum<typeof NotificationPlatform>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NotificationsInfo = z.infer<typeof NotificationsInfoSchema>;
+/**
+ * Device info schema
+ */
+export declare const DeviceInfoSchema: z.ZodObject<{
+    timestamp: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    application: z.ZodObject<{
+        version: z.ZodString;
+        build_number: z.ZodString;
+    }, z.core.$strip>;
+    update: z.ZodNullable<z.ZodObject<{
+        is_enabled: z.ZodBoolean;
+        update_id: z.ZodString;
+        update_channel: z.ZodString;
+        runtime_version: z.ZodString;
+        emergency_launch: z.ZodUnion<readonly [z.ZodObject<{
+            is_emergency_launch: z.ZodLiteral<true>;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            is_emergency_launch: z.ZodLiteral<false>;
+            reason: z.ZodOptional<z.ZodNever>;
+        }, z.core.$strip>]>;
+        is_embedded_launch: z.ZodBoolean;
+        created_at: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>>;
+    hardware: z.ZodObject<{
+        device_name: z.ZodString;
+        device_type: z.ZodString;
+        device_brand: z.ZodString;
+    }, z.core.$strip>;
+    os: z.ZodObject<{
+        platform: z.ZodEnum<typeof DevicePlatformEnum>;
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    notifications: z.ZodObject<{
+        push: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            granted: z.ZodBoolean;
+            token: z.ZodNullable<z.ZodString>;
+            platform: z.ZodEnum<typeof NotificationPlatform>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DeviceInfo = z.infer<typeof DeviceInfoSchema>;
+/**
+ * Persona info schema (optional fields)
+ * Matches personas table structure
+ */
+export declare const PersonaInfoSchema: z.ZodObject<{
+    user_id: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PersonaInfo = z.infer<typeof PersonaInfoSchema>;
+/**
+ * Identify request schema
+ * Ties a device to a persona with optional persona data
+ */
+export declare const IdentifyRequestSchema: z.ZodObject<{
+    device: z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        application: z.ZodObject<{
+            version: z.ZodString;
+            build_number: z.ZodString;
+        }, z.core.$strip>;
+        update: z.ZodNullable<z.ZodObject<{
+            is_enabled: z.ZodBoolean;
+            update_id: z.ZodString;
+            update_channel: z.ZodString;
+            runtime_version: z.ZodString;
+            emergency_launch: z.ZodUnion<readonly [z.ZodObject<{
+                is_emergency_launch: z.ZodLiteral<true>;
+                reason: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                is_emergency_launch: z.ZodLiteral<false>;
+                reason: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>]>;
+            is_embedded_launch: z.ZodBoolean;
+            created_at: z.ZodCoercedDate<unknown>;
+        }, z.core.$strip>>;
+        hardware: z.ZodObject<{
+            device_name: z.ZodString;
+            device_type: z.ZodString;
+            device_brand: z.ZodString;
+        }, z.core.$strip>;
+        os: z.ZodObject<{
+            platform: z.ZodEnum<typeof DevicePlatformEnum>;
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        notifications: z.ZodObject<{
+            push: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                granted: z.ZodBoolean;
+                token: z.ZodNullable<z.ZodString>;
+                platform: z.ZodEnum<typeof NotificationPlatform>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    persona: z.ZodOptional<z.ZodObject<{
+        user_id: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IdentifyRequest = z.infer<typeof IdentifyRequestSchema>;
+export declare enum IdentifyVersionStatusEnum {
+    /**
+     * A new version is available
+     */
+    UPDATE_AVAILABLE = "UPDATE_AVAILABLE",
+    /**
+     * An update is required
+     */
+    UPDATE_REQUIRED = "UPDATE_REQUIRED",
+    /**
+     * The current version is valid & up to date
+     */
+    UP_TO_DATE = "UP_TO_DATE"
+}
+export declare const UpdateInfoSchema: z.ZodObject<{
+    version: z.ZodString;
+    build: z.ZodString;
+    update_id: z.ZodString;
+    effective_date: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type UpdateAvailableInfo = z.infer<typeof UpdateAvailableInfoSchema>;
+export declare const UpToDateInfoSchema: z.ZodObject<{
+    status: z.ZodLiteral<IdentifyVersionStatusEnum.UP_TO_DATE>;
+    update: z.ZodNull;
+}, z.core.$strip>;
+export type UpToDateInfo = z.infer<typeof UpToDateInfoSchema>;
+export declare const UpdateRequiredInfoSchema: z.ZodObject<{
+    status: z.ZodLiteral<IdentifyVersionStatusEnum.UPDATE_REQUIRED>;
+    update: z.ZodObject<{
+        version: z.ZodString;
+        build: z.ZodString;
+        update_id: z.ZodString;
+        effective_date: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UpdateRequiredInfo = z.infer<typeof UpdateRequiredInfoSchema>;
+export declare const UpdateAvailableInfoSchema: z.ZodObject<{
+    status: z.ZodLiteral<IdentifyVersionStatusEnum.UPDATE_AVAILABLE>;
+    update: z.ZodObject<{
+        version: z.ZodString;
+        build: z.ZodString;
+        update_id: z.ZodString;
+        effective_date: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const VersionInfoSchema: z.ZodObject<{
+    status: z.ZodEnum<typeof IdentifyVersionStatusEnum>;
+    update: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        status: z.ZodLiteral<IdentifyVersionStatusEnum.UPDATE_AVAILABLE>;
+        update: z.ZodObject<{
+            version: z.ZodString;
+            build: z.ZodString;
+            update_id: z.ZodString;
+            effective_date: z.ZodCoercedDate<unknown>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type VersionInfo = z.infer<typeof VersionInfoSchema>;
+/**
+ * Identify response schema
+ */
+export declare const IdentifyResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        session_id: z.ZodString;
+        device_id: z.ZodString;
+        persona_id: z.ZodString;
+        token: z.ZodString;
+        version_info: z.ZodObject<{
+            status: z.ZodEnum<typeof IdentifyVersionStatusEnum>;
+            update: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                status: z.ZodLiteral<IdentifyVersionStatusEnum.UPDATE_AVAILABLE>;
+                update: z.ZodObject<{
+                    version: z.ZodString;
+                    build: z.ZodString;
+                    update_id: z.ZodString;
+                    effective_date: z.ZodCoercedDate<unknown>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IdentifyResponse = z.infer<typeof IdentifyResponseSchema>;
+export declare const IdentifyErrorResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_ORG_ID">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_PROJECT_ID">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_ENVIRONMENT_SLUG">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"MISSING_DEVICE_ID">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"IDENTIFY_FAILED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_SESSION_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_DEVICE_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodLiteral<"NO_PERSONA_ID_GENERATED">;
+        message: z.ZodString;
+    }, z.core.$strip>], "code">;
+}, z.core.$strip>;
+export type IdentifyErrorResponse = z.infer<typeof IdentifyErrorResponseSchema>;
+export declare const ValidationErrorSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodLiteral<"VALIDATION">;
+    message: z.ZodString;
+}, z.core.$strip>;