@teardown/schemas 0.1.0 → 0.1.2

package/dist/modules/devices/schemas.js

@@ -1,12 +1,12 @@
+import { Type } from "@sinclair/typebox";
 import { DevicePlatformEnum } from "@teardown/types";
-import { t } from "elysia";
 /**
  * Device platform enum matching database
  */
 /**
  * Device platform
  */
-export const DevicePlatformSchema = t.Enum(DevicePlatformEnum, { error: "platform is required" });
+export const DevicePlatformSchema = Type.Enum(DevicePlatformEnum, { error: "platform is required" });
 /**
  * Parse and validate a DevicePlatformEnum value
  * Uses a switch statement to ensure type safety and runtime validation
@@ -59,107 +59,107 @@ export function parseDevicePlatformEnum(value) {
  * Base device schema
  * Represents devices table structure
  */
-export const DeviceSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    persona_id: t.String({ format: "uuid" }),
-    environment_id: t.Union([t.String({ format: "uuid" }), t.Null()]),
-    device_id: t.String(),
-    platform: t.Union([DevicePlatformSchema, t.Null()]),
-    os_type: t.Union([t.String(), t.Null()]),
-    os_name: t.Union([t.String(), t.Null()]),
-    device_name: t.Union([t.String(), t.Null()]),
-    device_brand: t.Union([t.String(), t.Null()]),
-    metadata: t.Union([t.Record(t.String(), t.Unknown()), t.Null()]),
-    created_at: t.String(),
-    updated_at: t.String(),
+export const DeviceSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    persona_id: Type.String({ format: "uuid" }),
+    environment_id: Type.Union([Type.String({ format: "uuid" }), Type.Null()]),
+    device_id: Type.String(),
+    platform: Type.Union([DevicePlatformSchema, Type.Null()]),
+    os_type: Type.Union([Type.String(), Type.Null()]),
+    os_name: Type.Union([Type.String(), Type.Null()]),
+    device_name: Type.Union([Type.String(), Type.Null()]),
+    device_brand: Type.Union([Type.String(), Type.Null()]),
+    metadata: Type.Union([Type.Record(Type.String(), Type.Unknown()), Type.Null()]),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Device params schema
  */
-export const DeviceParamsSchema = t.Object({
-    device_id: t.String({ format: "uuid" }),
+export const DeviceParamsSchema = Type.Object({
+    device_id: Type.String({ format: "uuid" }),
 });
 /**
  * Search devices query schema
  * Supports pagination, search, and sorting
  */
-export const SearchDevicesQuerySchema = t.Object({
-    project_id: t.String({ format: "uuid" }),
-    page: t.Numeric({ minimum: 1, default: 1 }),
-    limit: t.Numeric({ minimum: 1, maximum: 100, default: 20 }),
-    search: t.Optional(t.String()),
-    sort_by: t.Union([
-        t.Literal("created_at"),
-        t.Literal("updated_at"),
-        t.Literal("device_name"),
-        t.Literal("platform"),
-        t.Literal("os_name"),
+export const SearchDevicesQuerySchema = Type.Object({
+    project_id: Type.String({ format: "uuid" }),
+    page: Type.Number({ minimum: 1, default: 1 }),
+    limit: Type.Number({ minimum: 1, maximum: 100, default: 20 }),
+    search: Type.Optional(Type.String()),
+    sort_by: Type.Union([
+        Type.Literal("created_at"),
+        Type.Literal("updated_at"),
+        Type.Literal("device_name"),
+        Type.Literal("platform"),
+        Type.Literal("os_name"),
     ], { default: "created_at" }),
-    sort_order: t.Union([t.Literal("asc"), t.Literal("desc")], { default: "desc" }),
+    sort_order: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
 });
 /**
  * Search devices query schema without project_id (injected from headers)
  */
-export const SearchDevicesQueryParamsSchema = t.Omit(SearchDevicesQuerySchema, ["project_id"]);
+export const SearchDevicesQueryParamsSchema = Type.Omit(SearchDevicesQuerySchema, ["project_id"]);
 /**
  * Devices by IDs request schema
  */
-export const DevicesByIdsSchema = t.Object({
-    device_ids: t.Array(t.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+export const DevicesByIdsSchema = Type.Object({
+    device_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
 });
 /**
  * Paginated devices response schema
  */
-export const DevicesResponseSchema = t.Object({
-    devices: t.Array(DeviceSchema),
-    pagination: t.Object({
-        page: t.Integer({ minimum: 1 }),
-        limit: t.Integer({ minimum: 1 }),
-        total: t.Integer({ minimum: 0 }),
-        total_pages: t.Integer({ minimum: 0 }),
+export const DevicesResponseSchema = Type.Object({
+    devices: Type.Array(DeviceSchema),
+    pagination: Type.Object({
+        page: Type.Integer({ minimum: 1 }),
+        limit: Type.Integer({ minimum: 1 }),
+        total: Type.Integer({ minimum: 0 }),
+        total_pages: Type.Integer({ minimum: 0 }),
     }),
 });
 /**
  * Single device response schema
  */
-export const DeviceResponseSchema = t.Object({
-    success: t.Literal(true),
+export const DeviceResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: DeviceSchema,
 });
 /**
  * Device error response schema
  * Discriminated union by error code
  */
-export const DeviceErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("DEVICE_NOT_FOUND"),
-        message: t.String(),
+export const DeviceErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("DEVICE_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("PROJECT_NOT_FOUND"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("PROJECT_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("FORBIDDEN"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("FORBIDDEN"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("FETCH_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("FETCH_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("INVALID_PARAMS"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("INVALID_PARAMS"),
+        message: Type.String(),
     }),
 ]);
 /**
  * Device error response wrapper
  */
-export const DeviceErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const DeviceErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: DeviceErrorSchema,
 });
 /**
  * Device request response schema
  */
-export const DeviceRequestResponseSchema = t.Union([DeviceResponseSchema, DeviceErrorResponseSchema]);
+export const DeviceRequestResponseSchema = Type.Union([DeviceResponseSchema, DeviceErrorResponseSchema]);

package/dist/modules/environment/schemas.d.ts

@@ -1,5 +1,5 @@
+import { type Static } from "@sinclair/typebox";
 import { EnvironmentTypeEnum } from "@teardown/types";
-import { type Static } from "elysia";
 import type { AssertSchemaCompatibleWithInsert, AssertSchemaCompatibleWithRow, AssertSchemaCompatibleWithUpdate, AssertTrue } from "../../common";
 /**
  * Environment type enum (re-exported for backward compatibility)

package/dist/modules/environment/schemas.js

@@ -1,5 +1,5 @@
+import { Type } from "@sinclair/typebox";
 import { EnvironmentTypeEnum } from "@teardown/types";
-import { t } from "elysia";
 /**
  * Environment type enum (re-exported for backward compatibility)
  * @deprecated Use EnvironmentTypeEnum from @teardown/types instead
@@ -9,14 +9,14 @@ export { EnvironmentTypeEnum as EnvironmentType };
  * Environment schema
  * Represents an environment within a project
  */
-export const EnvironmentSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    project_id: t.String({ format: "uuid" }),
-    name: t.String({ minLength: 1 }),
-    slug: t.String({ minLength: 1 }),
-    type: t.Enum(EnvironmentTypeEnum),
-    created_at: t.String(),
-    updated_at: t.String(),
+export const EnvironmentSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    project_id: Type.String({ format: "uuid" }),
+    name: Type.String({ minLength: 1 }),
+    slug: Type.String({ minLength: 1 }),
+    type: Type.Enum(EnvironmentTypeEnum),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Parse and validate an EnvironmentTypeEnum value
@@ -41,17 +41,17 @@ export function parseEnvironmentTypeEnum(value) {
  * Create environment schema
  * Used for creating new environments
  */
-export const CreateEnvironmentSchema = t.Object({
-    project_id: t.String({ format: "uuid" }),
-    name: t.String({ minLength: 1 }),
-    slug: t.String({ minLength: 1 }),
-    type: t.Enum(EnvironmentTypeEnum),
+export const CreateEnvironmentSchema = Type.Object({
+    project_id: Type.String({ format: "uuid" }),
+    name: Type.String({ minLength: 1 }),
+    slug: Type.String({ minLength: 1 }),
+    type: Type.Enum(EnvironmentTypeEnum),
 });
 /**
  * Update environment schema
  * Used for updating existing environments
  */
-export const UpdateEnvironmentSchema = t.Object({
-    name: t.String({ minLength: 1 }),
-    type: t.Enum(EnvironmentTypeEnum),
+export const UpdateEnvironmentSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    type: Type.Enum(EnvironmentTypeEnum),
 });

package/dist/modules/events/schemas.d.ts

@@ -1,4 +1,4 @@
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
 /**
  * Event type enum

package/dist/modules/events/schemas.js

@@ -1,4 +1,4 @@
-import { t } from "elysia";
+import { Type } from "@sinclair/typebox";
 /**
  * Event type enum
  */
@@ -6,111 +6,111 @@ export const EventTypeEnum = ["action", "screen_view", "custom"];
 /**
  * Single event schema
  */
-export const EventSchema = t.Object({
+export const EventSchema = Type.Object({
     /**
      * Name of the event (required)
      */
-    event_name: t.String({ minLength: 1, error: "event_name is required" }),
+    event_name: Type.String({ minLength: 1, error: "event_name is required" }),
     /**
      * Type of event
      */
-    event_type: t.Union([t.Literal("action"), t.Literal("screen_view"), t.Literal("custom")], { default: "custom" }),
+    event_type: Type.Union([Type.Literal("action"), Type.Literal("screen_view"), Type.Literal("custom")], { default: "custom" }),
     /**
      * Custom properties for the event (optional)
      */
-    properties: t.Optional(t.Record(t.String(), t.Unknown())),
+    properties: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
     /**
      * Client-side timestamp (optional, defaults to server time)
      */
-    timestamp: t.Optional(t.String()),
+    timestamp: Type.Optional(Type.String()),
     /**
      * Session ID (optional, can come from header)
      */
-    session_id: t.Optional(t.String({ format: "uuid" })),
+    session_id: Type.Optional(Type.String({ format: "uuid" })),
     /**
      * Device ID (optional, can come from header)
      */
-    device_id: t.Optional(t.String()),
+    device_id: Type.Optional(Type.String()),
 });
 /**
  * Batch events request schema
  * Accepts 1-100 events per request
  */
-export const EventsRequestSchema = t.Object({
+export const EventsRequestSchema = Type.Object({
     /**
      * Array of events to ingest (1-100)
      */
-    events: t.Array(EventSchema, { minItems: 1, maxItems: 100, error: "At least one event is required, maximum 100" }),
+    events: Type.Array(EventSchema, { minItems: 1, maxItems: 100, error: "At least one event is required, maximum 100" }),
     /**
      * Session ID (optional, applies to all events if not specified per-event)
      */
-    session_id: t.Optional(t.String({ format: "uuid" })),
+    session_id: Type.Optional(Type.String({ format: "uuid" })),
     /**
      * Device ID (optional, applies to all events if not specified per-event)
      */
-    device_id: t.Optional(t.String()),
+    device_id: Type.Optional(Type.String()),
 });
 /**
  * Events response schema
  */
-export const EventsResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Object({
+export const EventsResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Object({
         /**
          * IDs of created events
          */
-        event_ids: t.Array(t.String()),
+        event_ids: Type.Array(Type.String()),
         /**
          * Number of successfully processed events
          */
-        processed_count: t.Number(),
+        processed_count: Type.Number(),
         /**
          * Number of failed events
          */
-        failed_count: t.Number(),
+        failed_count: Type.Number(),
     }),
 });
 /**
  * Events error response schema
  */
-export const EventsErrorResponseSchema = t.Object({
-    success: t.Literal(false),
-    error: t.Union([
-        t.Object({
-            code: t.Literal("MISSING_ORG_ID"),
-            message: t.String(),
+export const EventsErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
+    error: Type.Union([
+        Type.Object({
+            code: Type.Literal("MISSING_ORG_ID"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("MISSING_PROJECT_ID"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("MISSING_PROJECT_ID"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("MISSING_ENVIRONMENT_SLUG"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("MISSING_ENVIRONMENT_SLUG"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("MISSING_DEVICE_ID"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("MISSING_DEVICE_ID"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("EVENTS_PROCESSING_FAILED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("EVENTS_PROCESSING_FAILED"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("INVALID_SESSION"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("INVALID_SESSION"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("INVALID_DEVICE"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("INVALID_DEVICE"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("BATCH_SIZE_EXCEEDED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("BATCH_SIZE_EXCEEDED"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("VALIDATION_ERROR"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("VALIDATION_ERROR"),
+            message: Type.String(),
         }),
     ]),
 });

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

@@ -1,5 +1,5 @@
+import { type Static } from "@sinclair/typebox";
 import { DevicePlatformEnum } from "@teardown/types";
-import { type Static } from "elysia";
 export { DevicePlatformEnum };
 /**
  * Application info schema
@@ -63,7 +63,7 @@ export declare const DeviceUpdateInfoSchema: import("@sinclair/typebox").TObject
     created_at: import("@sinclair/typebox").TString;
 }>;
 export type DeviceUpdateInfo = Static<typeof DeviceUpdateInfoSchema>;
-export declare enum NotificationPlatform {
+export declare enum NotificationPlatformEnum {
     APNS = "APNS",// Apple Push Notification Service
     FCM = "FCM",// Firebase Cloud Messaging
     EXPO = "EXPO"
@@ -75,7 +75,7 @@ export declare const PushNotificationInfoSchema: import("@sinclair/typebox").TOb
     enabled: import("@sinclair/typebox").TBoolean;
     granted: import("@sinclair/typebox").TBoolean;
     token: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
-    platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatform>;
+    platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatformEnum>;
 }>;
 export type PushNotificationInfo = Static<typeof PushNotificationInfoSchema>;
 export declare const NotificationsInfoSchema: import("@sinclair/typebox").TObject<{
@@ -83,7 +83,7 @@ export declare const NotificationsInfoSchema: import("@sinclair/typebox").TObjec
         enabled: import("@sinclair/typebox").TBoolean;
         granted: import("@sinclair/typebox").TBoolean;
         token: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
-        platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatform>;
+        platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatformEnum>;
     }>;
 }>;
 export type NotificationsInfo = Static<typeof NotificationsInfoSchema>;
@@ -153,7 +153,7 @@ export declare const DeviceInfoSchema: import("@sinclair/typebox").TObject<{
             enabled: import("@sinclair/typebox").TBoolean;
             granted: import("@sinclair/typebox").TBoolean;
             token: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
-            platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatform>;
+            platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatformEnum>;
         }>;
     }>;
 }>;
@@ -236,7 +236,7 @@ export declare const IdentifyRequestSchema: import("@sinclair/typebox").TObject<
                 enabled: import("@sinclair/typebox").TBoolean;
                 granted: import("@sinclair/typebox").TBoolean;
                 token: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
-                platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatform>;
+                platform: import("@sinclair/typebox").TEnum<typeof NotificationPlatformEnum>;
             }>;
         }>;
     }>;