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

package/dist/vendored/schemas/identify.js

@@ -1,70 +1,60 @@
 import { DevicePlatformEnum } from "../types/generated-consts";
-import { ValidationError } from "elysia";
-import { z } from "zod";
+import { t } from "elysia";
+import { EmailSchema } from "../common/primitives";
 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",
+export const ApplicationInfoSchema = t.Object({
+    version: t.String({ error: "version is required" }),
+    build_number: t.String({ error: "build_number is required" }),
 });
 /**
  * OS info schema
  */
-export const OSInfoSchema = z.object({
+export const OSInfoSchema = t.Object({
     /**
      * Device platform
      */
-    platform: z.enum(DevicePlatformEnum, "platform is required"),
+    platform: t.Enum(DevicePlatformEnum, { error: "platform is required" }),
     /**
      * OS name
      */
-    name: z.string("name is required"),
+    name: t.String({ error: "name is required" }),
     /**
      * OS version
      */
-    version: z.string("version is required"),
-}, {
-    error: "OS info is required",
+    version: t.String({ error: "version 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"),
+export const HardwareInfoSchema = t.Object({
+    device_name: t.String({ error: "device_name is required" }),
+    device_type: t.String({ error: "device_type is required" }),
+    device_brand: t.String({ error: "device_brand is required" }),
+});
+export const EmergencyLaunchSchema = t.Union([
+    t.Object({
+        is_emergency_launch: t.Literal(true),
+        reason: t.String({ error: "reason is required when is_emergency_launch is true" }),
     }),
-    z.object({
-        is_emergency_launch: z.literal(false),
-        reason: z.never().optional(),
+    t.Object({
+        is_emergency_launch: t.Literal(false),
+        reason: t.Optional(t.Never()),
     }),
-], {
-    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"),
+export const DeviceUpdateInfoSchema = t.Object({
+    is_enabled: t.Boolean(),
+    update_id: t.String({ error: "update_id is required" }),
+    update_channel: t.String({ error: "update_channel is required" }),
+    runtime_version: t.String({ error: "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",
+    is_embedded_launch: t.Boolean({ error: "is_embedded_launch is required" }),
+    created_at: t.String(),
 });
 export var NotificationPlatform;
 (function (NotificationPlatform) {
@@ -75,27 +65,23 @@ export var 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 PushNotificationInfoSchema = t.Object({
+    enabled: t.Boolean({ error: "enabled is required" }),
+    granted: t.Boolean({ error: "granted is required" }),
+    token: t.Union([t.String({ error: "token is required" }), t.Null()]),
+    platform: t.Enum(NotificationPlatform, { error: "platform is required" }),
 });
-export const NotificationsInfoSchema = z.object({
+export const NotificationsInfoSchema = t.Object({
     push: PushNotificationInfoSchema,
-}, {
-    error: "Notifications info is required",
 });
 /**
  * Device info schema
  */
-export const DeviceInfoSchema = z.object({
+export const DeviceInfoSchema = t.Object({
     /**
      * Timestamp of collection on device (optional, generated server-side if not provided)
      */
-    timestamp: z.coerce.date("timestamp is required").optional(),
+    timestamp: t.Optional(t.Date({ error: "timestamp is required" })),
     /**
      * Application info, required
      */
@@ -103,7 +89,7 @@ export const DeviceInfoSchema = z.object({
     /**
      * Update info (optional) - not all builds will have an update
      */
-    update: DeviceUpdateInfoSchema.nullable(),
+    update: t.Union([DeviceUpdateInfoSchema, t.Null()]),
     /**
      * Hardware info, required
      */
@@ -116,34 +102,23 @@ export const DeviceInfoSchema = z.object({
      * 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",
+export const PersonaInfoSchema = t.Object({
+    user_id: t.Optional(t.String({ error: "user_id is required" })),
+    email: t.Optional(EmailSchema),
+    name: t.Optional(t.String({ error: "name is required" })),
 });
 /**
  * Identify request schema
  * Ties a device to a persona with optional persona data
  */
-export const IdentifyRequestSchema = z.object({
+export const IdentifyRequestSchema = t.Object({
     device: DeviceInfoSchema,
-    persona: PersonaInfoSchema.optional(),
-}, {
-    error: "Identify request is required",
+    persona: t.Optional(PersonaInfoSchema),
 });
 export var IdentifyVersionStatusEnum;
 (function (IdentifyVersionStatusEnum) {
@@ -159,102 +134,88 @@ export var IdentifyVersionStatusEnum;
      * The current version is valid & up to date
      */
     IdentifyVersionStatusEnum["UP_TO_DATE"] = "UP_TO_DATE";
+    /**
+     * The version or build has been disabled
+     */
+    IdentifyVersionStatusEnum["DISABLED"] = "DISABLED";
 })(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),
+export const UpdateInfoSchema = t.Object({
+    version: t.String({ error: "version is required" }),
+    build: t.String({ error: "build is required" }),
+    update_id: t.String({ error: "update_id is required" }),
+    effective_date: t.Date({ error: "effective_date is required" }),
+});
+export const UpToDateInfoSchema = t.Object({
+    status: t.Literal(IdentifyVersionStatusEnum.UP_TO_DATE),
+    update: t.Null(),
+});
+export const UpdateRequiredInfoSchema = t.Object({
+    status: t.Literal(IdentifyVersionStatusEnum.UPDATE_REQUIRED),
     update: UpdateInfoSchema,
-}, {
-    error: "Update required info is required",
 });
-export const UpdateAvailableInfoSchema = z.object({
-    status: z.literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
+export const UpdateAvailableInfoSchema = t.Object({
+    status: t.Literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
     update: UpdateInfoSchema,
-}, {
-    error: "Update available info is required",
 });
-export const VersionInfoSchema = z.object({
+export const VersionInfoSchema = t.Object({
     /**
      * The status of the version
      */
-    status: z.enum(IdentifyVersionStatusEnum, "status is required"),
-    update: UpdateAvailableInfoSchema.nullish(),
-}, {
-    error: "Version info is required",
+    status: t.Enum(IdentifyVersionStatusEnum, { error: "status is required" }),
+    update: t.Optional(t.Union([UpdateAvailableInfoSchema, t.Null()])),
 });
 /**
  * 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
+export const IdentifyResponseSchema = t.Object({
+    success: t.Literal(true),
+    data: t.Object({
+        session_id: t.String({ error: "session_id is required" }),
+        device_id: t.String({ error: "device_id is required" }),
+        persona_id: t.String({ error: "persona_id is required" }),
+        token: t.String({ error: "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(),
+export const IdentifyErrorResponseSchema = t.Object({
+    success: t.Literal(false),
+    error: t.Union([
+        t.Object({
+            code: t.Literal("MISSING_ORG_ID"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("MISSING_PROJECT_ID"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("MISSING_PROJECT_ID"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("MISSING_ENVIRONMENT_SLUG"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("MISSING_ENVIRONMENT_SLUG"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("MISSING_DEVICE_ID"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("MISSING_DEVICE_ID"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("IDENTIFY_FAILED"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("IDENTIFY_FAILED"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("NO_SESSION_ID_GENERATED"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("NO_SESSION_ID_GENERATED"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("NO_DEVICE_ID_GENERATED"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("NO_DEVICE_ID_GENERATED"),
+            message: t.String(),
         }),
-        z.object({
-            code: z.literal("NO_PERSONA_ID_GENERATED"),
-            message: z.string(),
+        t.Object({
+            code: t.Literal("NO_PERSONA_ID_GENERATED"),
+            message: t.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 const ValidationErrorSchema = t.Object({
+    success: t.Literal(false),
+    error: t.Literal("VALIDATION"),
+    message: t.String(),
 });
-// export type ValidationError = z.infer<typeof ValidationErrorSchema>;
-ValidationError;

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

@@ -37,11 +37,25 @@ export declare enum ProjectApiKeyKindEnum {
     publishable = "publishable",
     secret = "secret"
 }
+export declare enum ProjectStatusEnum {
+    PENDING_SETUP = "PENDING_SETUP",
+    ACTIVE = "ACTIVE",
+    PAUSED = "PAUSED",
+    ARCHIVED = "ARCHIVED"
+}
 export declare enum ProjectTypeEnum {
     REACT_NATIVE = "REACT_NATIVE",
     EXPO = "EXPO"
 }
-export declare enum VersionStatusEnum {
-    LIVE = "LIVE",
-    DISABLED = "DISABLED"
+export declare enum ProjectVersionStatusEnum {
+    SUPPORTED = "SUPPORTED",
+    UPDATE_AVAILABLE = "UPDATE_AVAILABLE",
+    UPDATE_RECOMMENDED = "UPDATE_RECOMMENDED",
+    UPDATE_REQUIRED = "UPDATE_REQUIRED"
+}
+export declare enum VersionBuildStatusEnum {
+    SUPPORTED = "SUPPORTED",
+    UPDATE_AVAILABLE = "UPDATE_AVAILABLE",
+    UPDATE_RECOMMENDED = "UPDATE_RECOMMENDED",
+    UPDATE_REQUIRED = "UPDATE_REQUIRED"
 }

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

@@ -42,13 +42,29 @@ export var ProjectApiKeyKindEnum;
     ProjectApiKeyKindEnum["publishable"] = "publishable";
     ProjectApiKeyKindEnum["secret"] = "secret";
 })(ProjectApiKeyKindEnum || (ProjectApiKeyKindEnum = {}));
+export var ProjectStatusEnum;
+(function (ProjectStatusEnum) {
+    ProjectStatusEnum["PENDING_SETUP"] = "PENDING_SETUP";
+    ProjectStatusEnum["ACTIVE"] = "ACTIVE";
+    ProjectStatusEnum["PAUSED"] = "PAUSED";
+    ProjectStatusEnum["ARCHIVED"] = "ARCHIVED";
+})(ProjectStatusEnum || (ProjectStatusEnum = {}));
 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 = {}));
+export var ProjectVersionStatusEnum;
+(function (ProjectVersionStatusEnum) {
+    ProjectVersionStatusEnum["SUPPORTED"] = "SUPPORTED";
+    ProjectVersionStatusEnum["UPDATE_AVAILABLE"] = "UPDATE_AVAILABLE";
+    ProjectVersionStatusEnum["UPDATE_RECOMMENDED"] = "UPDATE_RECOMMENDED";
+    ProjectVersionStatusEnum["UPDATE_REQUIRED"] = "UPDATE_REQUIRED";
+})(ProjectVersionStatusEnum || (ProjectVersionStatusEnum = {}));
+export var VersionBuildStatusEnum;
+(function (VersionBuildStatusEnum) {
+    VersionBuildStatusEnum["SUPPORTED"] = "SUPPORTED";
+    VersionBuildStatusEnum["UPDATE_AVAILABLE"] = "UPDATE_AVAILABLE";
+    VersionBuildStatusEnum["UPDATE_RECOMMENDED"] = "UPDATE_RECOMMENDED";
+    VersionBuildStatusEnum["UPDATE_REQUIRED"] = "UPDATE_REQUIRED";
+})(VersionBuildStatusEnum || (VersionBuildStatusEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/ingest-api",
-	"version": "0.0.21-alpha.11",
+	"version": "0.0.21-alpha.13",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -36,7 +36,7 @@
 		"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",
+		"typecheck": "bun x tsc --noEmit --project ./tsconfig.lib.json",
 		"prepublishOnly": "bun x turbo run build"
 	},
 	"dependencies": {
@@ -48,6 +48,7 @@
 		"elysia": ">= 1.4.0"
 	},
 	"devDependencies": {
+		"@sinclair/typebox": "^0.34.41",
 		"@types/bun": "1.3.3",
 		"@teardown/ingest": "0.0.1",
 		"@teardown/tsconfig": "1.0.0",