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

package/dist/vendored/schemas/identify.js

@@ -0,0 +1,260 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
+import { ValidationError } from "elysia";
+import { z } from "zod";
+export { DevicePlatformEnum };
+/**
+ * Application info schema
+ */
+export const ApplicationInfoSchema = z.object({
+    version: z.string("version is required"),
+    build_number: z.string("build_number is required"),
+}, {
+    error: "Application info is required",
+});
+/**
+ * OS info schema
+ */
+export const OSInfoSchema = z.object({
+    /**
+     * Device platform
+     */
+    platform: z.enum(DevicePlatformEnum, "platform is required"),
+    /**
+     * OS name
+     */
+    name: z.string("name is required"),
+    /**
+     * OS version
+     */
+    version: z.string("version is required"),
+}, {
+    error: "OS info is required",
+});
+/**
+ * Hardware info schema
+ */
+export const HardwareInfoSchema = z.object({
+    device_name: z.string("device_name is required"),
+    device_type: z.string("device_type is required"),
+    device_brand: z.string("device_brand is required"),
+}, {
+    error: "Hardware info is required",
+});
+export const EmergencyLaunchSchema = z.union([
+    z.object({
+        is_emergency_launch: z.literal(true),
+        reason: z.string("reason is required when is_emergency_launch is true"),
+    }),
+    z.object({
+        is_emergency_launch: z.literal(false),
+        reason: z.never().optional(),
+    }),
+], {
+    error: "Emergency launch is required",
+});
+/**
+ * Update info schema
+ */
+export const DeviceUpdateInfoSchema = z.object({
+    is_enabled: z.boolean(),
+    update_id: z.string("update_id is required"),
+    update_channel: z.string("update_channel is required"),
+    runtime_version: z.string("runtime_version is required"),
+    emergency_launch: EmergencyLaunchSchema,
+    is_embedded_launch: z.boolean("is_embedded_launch is required"),
+    created_at: z.coerce.date(),
+}, {
+    error: "Update info is required",
+});
+export var NotificationPlatform;
+(function (NotificationPlatform) {
+    NotificationPlatform["APNS"] = "APNS";
+    NotificationPlatform["FCM"] = "FCM";
+    NotificationPlatform["EXPO"] = "EXPO";
+})(NotificationPlatform || (NotificationPlatform = {}));
+/**
+ * Push notification info schema
+ */
+export const PushNotificationInfoSchema = z.object({
+    enabled: z.boolean("enabled is required"),
+    granted: z.boolean("granted is required"),
+    token: z.string("token is required").nullable(),
+    platform: z.enum(NotificationPlatform, "platform is required"),
+}, {
+    error: "Push notification info is required",
+});
+export const NotificationsInfoSchema = z.object({
+    push: PushNotificationInfoSchema,
+}, {
+    error: "Notifications info is required",
+});
+/**
+ * Device info schema
+ */
+export const DeviceInfoSchema = z.object({
+    /**
+     * Timestamp of collection on device (optional, generated server-side if not provided)
+     */
+    timestamp: z.coerce.date("timestamp is required").optional(),
+    /**
+     * Application info, required
+     */
+    application: ApplicationInfoSchema,
+    /**
+     * Update info (optional) - not all builds will have an update
+     */
+    update: DeviceUpdateInfoSchema.nullable(),
+    /**
+     * Hardware info, required
+     */
+    hardware: HardwareInfoSchema,
+    /**
+     * OS info, required
+     */
+    os: OSInfoSchema,
+    /**
+     * Notifications info, required
+     */
+    notifications: NotificationsInfoSchema,
+}, {
+    error: "Device info is required",
+});
+/**
+ * Persona info schema (optional fields)
+ * Matches personas table structure
+ */
+export const PersonaInfoSchema = z.object({
+    user_id: z.string("user_id is required").optional(),
+    email: z
+        .string("email is required")
+        .refine((val) => !val || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), {
+        message: "Invalid email format",
+    })
+        .optional(),
+    name: z.string("name is required").optional(),
+}, {
+    error: "Persona info is required",
+});
+/**
+ * Identify request schema
+ * Ties a device to a persona with optional persona data
+ */
+export const IdentifyRequestSchema = z.object({
+    device: DeviceInfoSchema,
+    persona: PersonaInfoSchema.optional(),
+}, {
+    error: "Identify request is required",
+});
+export var IdentifyVersionStatusEnum;
+(function (IdentifyVersionStatusEnum) {
+    /**
+     * A new version is available
+     */
+    IdentifyVersionStatusEnum["UPDATE_AVAILABLE"] = "UPDATE_AVAILABLE";
+    /**
+     * An update is required
+     */
+    IdentifyVersionStatusEnum["UPDATE_REQUIRED"] = "UPDATE_REQUIRED";
+    /**
+     * The current version is valid & up to date
+     */
+    IdentifyVersionStatusEnum["UP_TO_DATE"] = "UP_TO_DATE";
+})(IdentifyVersionStatusEnum || (IdentifyVersionStatusEnum = {}));
+export const UpdateInfoSchema = z.object({
+    version: z.string("version is required"),
+    build: z.string("build is required"),
+    update_id: z.string("update_id is required"),
+    effective_date: z.coerce.date("effective_date is required"),
+}, {
+    error: "Update available info is required",
+});
+export const UpToDateInfoSchema = z.object({
+    status: z.literal(IdentifyVersionStatusEnum.UP_TO_DATE),
+    update: z.null(),
+}, {
+    error: "Up to date info is required",
+});
+export const UpdateRequiredInfoSchema = z.object({
+    status: z.literal(IdentifyVersionStatusEnum.UPDATE_REQUIRED),
+    update: UpdateInfoSchema,
+}, {
+    error: "Update required info is required",
+});
+export const UpdateAvailableInfoSchema = z.object({
+    status: z.literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
+    update: UpdateInfoSchema,
+}, {
+    error: "Update available info is required",
+});
+export const VersionInfoSchema = z.object({
+    /**
+     * The status of the version
+     */
+    status: z.enum(IdentifyVersionStatusEnum, "status is required"),
+    update: UpdateAvailableInfoSchema.nullish(),
+}, {
+    error: "Version info is required",
+});
+/**
+ * Identify response schema
+ */
+export const IdentifyResponseSchema = z.object({
+    success: z.literal(true),
+    data: z.object({
+        session_id: z.string("session_id is required"),
+        device_id: z.string("device_id is required"),
+        persona_id: z.string("persona_id is required"),
+        token: z.string("token is required"), // JWT token for session authentication
+        version_info: VersionInfoSchema,
+    }),
+}, {
+    error: "Identify response is required",
+});
+export const IdentifyErrorResponseSchema = z.object({
+    success: z.literal(false),
+    error: z.discriminatedUnion("code", [
+        z.object({
+            code: z.literal("MISSING_ORG_ID"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("MISSING_PROJECT_ID"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("MISSING_ENVIRONMENT_SLUG"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("MISSING_DEVICE_ID"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("IDENTIFY_FAILED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_SESSION_ID_GENERATED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_DEVICE_ID_GENERATED"),
+            message: z.string(),
+        }),
+        z.object({
+            code: z.literal("NO_PERSONA_ID_GENERATED"),
+            message: z.string(),
+        }),
+    ]),
+}, {
+    error: "Identify error response is required",
+});
+export const ValidationErrorSchema = z.object({
+    success: z.literal(false),
+    error: z.literal("VALIDATION"),
+    message: z.string(),
+}, {
+    error: "Validation error is required",
+});
+// export type ValidationError = z.infer<typeof ValidationErrorSchema>;
+ValidationError;

package/dist/vendored/types/generated-consts.d.ts

@@ -0,0 +1,47 @@
+export declare enum DevicePlatformEnum {
+    IOS = "IOS",
+    ANDROID = "ANDROID",
+    WEB = "WEB",
+    WINDOWS = "WINDOWS",
+    MACOS = "MACOS",
+    LINUX = "LINUX",
+    PHONE = "PHONE",
+    TABLET = "TABLET",
+    DESKTOP = "DESKTOP",
+    CONSOLE = "CONSOLE",
+    TV = "TV",
+    WEARABLE = "WEARABLE",
+    GAME_CONSOLE = "GAME_CONSOLE",
+    VR = "VR",
+    UNKNOWN = "UNKNOWN",
+    OTHER = "OTHER"
+}
+export declare enum EnvironmentTypeEnum {
+    DEVELOPMENT = "DEVELOPMENT",
+    STAGING = "STAGING",
+    PRODUCTION = "PRODUCTION"
+}
+export declare enum OrgRoleTypeEnum {
+    OWNER = "OWNER",
+    ADMIN = "ADMIN",
+    ENGINEER = "ENGINEER"
+}
+export declare enum OrgTypeEnum {
+    PERSONAL = "PERSONAL",
+    START_UP = "START_UP",
+    SCALE_UP = "SCALE_UP",
+    AGENCY = "AGENCY",
+    ENTERPRISE = "ENTERPRISE"
+}
+export declare enum ProjectApiKeyKindEnum {
+    publishable = "publishable",
+    secret = "secret"
+}
+export declare enum ProjectTypeEnum {
+    REACT_NATIVE = "REACT_NATIVE",
+    EXPO = "EXPO"
+}
+export declare enum VersionStatusEnum {
+    LIVE = "LIVE",
+    DISABLED = "DISABLED"
+}

package/dist/vendored/types/generated-consts.js

@@ -0,0 +1,54 @@
+export var DevicePlatformEnum;
+(function (DevicePlatformEnum) {
+    DevicePlatformEnum["IOS"] = "IOS";
+    DevicePlatformEnum["ANDROID"] = "ANDROID";
+    DevicePlatformEnum["WEB"] = "WEB";
+    DevicePlatformEnum["WINDOWS"] = "WINDOWS";
+    DevicePlatformEnum["MACOS"] = "MACOS";
+    DevicePlatformEnum["LINUX"] = "LINUX";
+    DevicePlatformEnum["PHONE"] = "PHONE";
+    DevicePlatformEnum["TABLET"] = "TABLET";
+    DevicePlatformEnum["DESKTOP"] = "DESKTOP";
+    DevicePlatformEnum["CONSOLE"] = "CONSOLE";
+    DevicePlatformEnum["TV"] = "TV";
+    DevicePlatformEnum["WEARABLE"] = "WEARABLE";
+    DevicePlatformEnum["GAME_CONSOLE"] = "GAME_CONSOLE";
+    DevicePlatformEnum["VR"] = "VR";
+    DevicePlatformEnum["UNKNOWN"] = "UNKNOWN";
+    DevicePlatformEnum["OTHER"] = "OTHER";
+})(DevicePlatformEnum || (DevicePlatformEnum = {}));
+export var EnvironmentTypeEnum;
+(function (EnvironmentTypeEnum) {
+    EnvironmentTypeEnum["DEVELOPMENT"] = "DEVELOPMENT";
+    EnvironmentTypeEnum["STAGING"] = "STAGING";
+    EnvironmentTypeEnum["PRODUCTION"] = "PRODUCTION";
+})(EnvironmentTypeEnum || (EnvironmentTypeEnum = {}));
+export var OrgRoleTypeEnum;
+(function (OrgRoleTypeEnum) {
+    OrgRoleTypeEnum["OWNER"] = "OWNER";
+    OrgRoleTypeEnum["ADMIN"] = "ADMIN";
+    OrgRoleTypeEnum["ENGINEER"] = "ENGINEER";
+})(OrgRoleTypeEnum || (OrgRoleTypeEnum = {}));
+export var OrgTypeEnum;
+(function (OrgTypeEnum) {
+    OrgTypeEnum["PERSONAL"] = "PERSONAL";
+    OrgTypeEnum["START_UP"] = "START_UP";
+    OrgTypeEnum["SCALE_UP"] = "SCALE_UP";
+    OrgTypeEnum["AGENCY"] = "AGENCY";
+    OrgTypeEnum["ENTERPRISE"] = "ENTERPRISE";
+})(OrgTypeEnum || (OrgTypeEnum = {}));
+export var ProjectApiKeyKindEnum;
+(function (ProjectApiKeyKindEnum) {
+    ProjectApiKeyKindEnum["publishable"] = "publishable";
+    ProjectApiKeyKindEnum["secret"] = "secret";
+})(ProjectApiKeyKindEnum || (ProjectApiKeyKindEnum = {}));
+export var ProjectTypeEnum;
+(function (ProjectTypeEnum) {
+    ProjectTypeEnum["REACT_NATIVE"] = "REACT_NATIVE";
+    ProjectTypeEnum["EXPO"] = "EXPO";
+})(ProjectTypeEnum || (ProjectTypeEnum = {}));
+export var VersionStatusEnum;
+(function (VersionStatusEnum) {
+    VersionStatusEnum["LIVE"] = "LIVE";
+    VersionStatusEnum["DISABLED"] = "DISABLED";
+})(VersionStatusEnum || (VersionStatusEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/ingest-api",
-	"version": "0.0.20",
+	"version": "0.0.21-alpha.11",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -24,29 +24,33 @@
 		},
 		"./types": {
 			"types": "./dist/types/index.d.ts"
+		},
+		"./vendored/consts": {
+			"types": "./dist/vendored/types/generated-consts.d.ts",
+			"import": "./dist/vendored/types/generated-consts.js",
+			"default": "./dist/vendored/types/generated-consts.js"
 		}
 	},
 	"scripts": {
-		"sync:schemas": "bun run scripts/sync-schemas.ts",
-		"postinstall": "bun run sync:schemas",
-		"build": "tsc --project ./tsconfig.lib.json",
-		"predev": "bun run sync:schemas",
-		"dev": "rm -rf dist; bun x tsc --watch --project ./tsconfig.lib.json",
-		"check:types": "tsc --noEmit --project ./tsconfig.lib.json",
-		"prepublishOnly": "bun run sync:schemas && bun run build"
+		"copy:schemas": "bun run scripts/copy-schemas.ts",
+		"prebuild": "bun run copy:schemas",
+		"build": "bun x tsc --project ./tsconfig.lib.json",
+		"dev": "bun x tsc --watch --project ./tsconfig.lib.json",
+		"check:types": "bun x tsc --noEmit --project ./tsconfig.lib.json",
+		"prepublishOnly": "bun x turbo run build"
 	},
 	"dependencies": {
-		"@elysiajs/eden": "^1.4.4",
-		"elysia": "^1.4.13"
+		"@elysiajs/eden": "1.4.5"
 	},
 	"peerDependencies": {
-		"typescript": "^5",
-		"zod": "^4"
+		"typescript": "^5.9.3",
+		"zod": "^4",
+		"elysia": ">= 1.4.0"
 	},
 	"devDependencies": {
-		"@types/bun": "latest",
+		"@types/bun": "1.3.3",
 		"@teardown/ingest": "0.0.1",
 		"@teardown/tsconfig": "1.0.0",
-		"@teardown/types": "0.0.1"
+		"elysia": "1.4.16"
 	}
-}
+}

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

@@ -1,203 +0,0 @@
-import { z } from "zod";
-/**
- * OS types
- */
-export declare enum OSType {
-    IOS = "IOS",
-    ANDROID = "ANDROID",
-    WEB = "WEB",
-    WINDOWS = "WINDOWS",
-    MACOS = "MACOS",
-    LINUX = "LINUX"
-}
-/**
- * Device types
- */
-export type DeviceType = "UNKNOWN" | "PHONE" | "TABLET" | "DESKTOP" | "CONSOLE" | "TV" | "WEARABLE" | "GAME_CONSOLE" | "VR" | "OTHER";
-/**
- * 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<{
-    type: z.ZodEnum<typeof OSType>;
-    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 UpdateInfoSchema: 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 UpdateInfo = z.infer<typeof UpdateInfoSchema>;
-/**
- * Push notification info schema
- */
-export declare const PushNotificationInfoSchema: z.ZodObject<{
-    token: z.ZodString;
-    platform: z.ZodEnum<{
-        APNS: "APNS";
-        FCM: "FCM";
-        EXPO: "EXPO";
-    }>;
-}, z.core.$strip>;
-export type PushNotificationInfo = z.infer<typeof PushNotificationInfoSchema>;
-/**
- * Device info schema
- */
-export declare const DeviceInfoSchema: z.ZodObject<{
-    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<{
-        type: z.ZodEnum<typeof OSType>;
-        name: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strip>;
-    push_notification: z.ZodOptional<z.ZodObject<{
-        token: z.ZodString;
-        platform: z.ZodEnum<{
-            APNS: "APNS";
-            FCM: "FCM";
-            EXPO: "EXPO";
-        }>;
-    }, 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<{
-        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<{
-            type: z.ZodEnum<typeof OSType>;
-            name: z.ZodString;
-            version: z.ZodString;
-        }, z.core.$strip>;
-        push_notification: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            platform: z.ZodEnum<{
-                APNS: "APNS";
-                FCM: "FCM";
-                EXPO: "EXPO";
-            }>;
-        }, 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>;
-/**
- * Identify response schema
- */
-export declare const IdentifyResponseSchema: z.ZodObject<{
-    success: z.ZodLiteral<true>;
-    session_id: z.ZodString;
-    device_id: z.ZodString;
-    persona_id: z.ZodString;
-}, z.core.$strip>;
-export type IdentifyResponse = z.infer<typeof IdentifyResponseSchema>;
-export declare const IdentifyErrorResponseSchema: z.ZodObject<{
-    success: z.ZodLiteral<false>;
-    error: z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type IdentifyErrorResponse = z.infer<typeof IdentifyErrorResponseSchema>;