@teardown/ingest-api 0.0.21-alpha.3 → 0.0.21-alpha.4

package/dist/schemas/index.d.ts

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

package/dist/schemas/index.js

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

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
 export type * from "@teardown/schemas/environment";
-export type * from "@teardown/schemas/identify";
+export type * from "../vendored/schemas/identify";

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

@@ -0,0 +1,222 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
+import { z } from "zod";
+/**
+ * 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 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>;
+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>;
+/**
+ * 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;
+    token: z.ZodString;
+}, 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<"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>;

package/dist/vendored/schemas/identify.js

@@ -0,0 +1,168 @@
+import { DevicePlatformEnum } from "../types/generated-consts";
+import { z } from "zod";
+/**
+ * Application info schema
+ */
+export const ApplicationInfoSchema = z.object({
+    version: z.string(),
+    build_number: z.string(),
+});
+/**
+ * OS info schema
+ */
+export const OSInfoSchema = z.object({
+    /**
+     * Device platform
+     */
+    platform: z.enum(DevicePlatformEnum),
+    /**
+     * OS name
+     */
+    name: z.string(),
+    /**
+     * OS version
+     */
+    version: z.string(),
+});
+/**
+ * Hardware info schema
+ */
+export const HardwareInfoSchema = z.object({
+    device_name: z.string(),
+    device_type: z.string(),
+    device_brand: z.string(),
+});
+export const EmergencyLaunchSchema = z.union([
+    z.object({
+        is_emergency_launch: z.literal(true),
+        reason: z.string(),
+    }),
+    z.object({
+        is_emergency_launch: z.literal(false),
+        reason: z.never().optional(),
+    }),
+]);
+/**
+ * Update info schema
+ */
+export const UpdateInfoSchema = z.object({
+    is_enabled: z.boolean(),
+    update_id: z.string(),
+    update_channel: z.string(),
+    runtime_version: z.string(),
+    emergency_launch: EmergencyLaunchSchema,
+    is_embedded_launch: z.boolean(),
+    created_at: z.coerce.date(),
+});
+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(),
+    granted: z.boolean(),
+    token: z.string().nullable(),
+    platform: z.enum(NotificationPlatform),
+});
+export const NotificationsInfoSchema = z.object({
+    push: PushNotificationInfoSchema,
+});
+/**
+ * Device info schema
+ */
+export const DeviceInfoSchema = z.object({
+    /**
+     * Timestamp of collection on device (optional, generated server-side if not provided)
+     */
+    timestamp: z.coerce.date().optional(),
+    /**
+     * Application info, required
+     */
+    application: ApplicationInfoSchema,
+    /**
+     * Update info (optional) - not all builds will have an update
+     */
+    update: UpdateInfoSchema.nullable(),
+    /**
+     * Hardware info, required
+     */
+    hardware: HardwareInfoSchema,
+    /**
+     * OS info, required
+     */
+    os: OSInfoSchema,
+    /**
+     * Notifications info, required
+     */
+    notifications: NotificationsInfoSchema,
+});
+/**
+ * Persona info schema (optional fields)
+ * Matches personas table structure
+ */
+export const PersonaInfoSchema = z.object({
+    user_id: z.string().optional(),
+    email: z
+        .string()
+        .refine((val) => !val || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val), {
+        message: "Invalid email format",
+    })
+        .optional(),
+    name: z.string().optional(),
+});
+/**
+ * Identify request schema
+ * Ties a device to a persona with optional persona data
+ */
+export const IdentifyRequestSchema = z.object({
+    device: DeviceInfoSchema,
+    persona: PersonaInfoSchema.optional(),
+});
+/**
+ * Identify response schema
+ */
+export const IdentifyResponseSchema = z.object({
+    success: z.literal(true),
+    session_id: z.string(),
+    device_id: z.string(),
+    persona_id: z.string(),
+    token: z.string(), // JWT token for session authentication
+});
+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("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(),
+        }),
+    ]),
+});

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.21-alpha.3",
+	"version": "0.0.21-alpha.4",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -27,14 +27,15 @@
 		}
 	},
 	"scripts": {
+		"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 run build"
 	},
 	"dependencies": {
-		"@elysiajs/eden": "1.4.4",
-		"@teardown/schemas": "0.1.0"
+		"@elysiajs/eden": "1.4.4"
 	},
 	"peerDependencies": {
 		"typescript": "^5.9.3",
@@ -45,7 +46,6 @@
 		"@types/bun": "1.1.14",
 		"@teardown/ingest": "0.0.1",
 		"@teardown/tsconfig": "1.0.0",
-		"@teardown/types": "0.0.2",
 		"elysia": "1.4.0"
 	}
 }