@teardown/schemas 0.1.0 → 0.1.2

package/dist/modules/identify/schemas.js

@@ -1,87 +1,87 @@
+import { Type } from "@sinclair/typebox";
 import { DevicePlatformEnum } from "@teardown/types";
-import { t } from "elysia";
 import { EmailSchema } from "../../common";
 export { DevicePlatformEnum };
 /**
  * Application info schema
  */
-export const ApplicationInfoSchema = t.Object({
-    version: t.String({ error: "version is required" }),
-    build_number: t.String({ error: "build_number is required" }),
+export const ApplicationInfoSchema = Type.Object({
+    version: Type.String({ error: "version is required" }),
+    build_number: Type.String({ error: "build_number is required" }),
 });
 /**
  * OS info schema
  */
-export const OSInfoSchema = t.Object({
+export const OSInfoSchema = Type.Object({
     /**
      * Device platform
      */
-    platform: t.Enum(DevicePlatformEnum, { error: "platform is required" }),
+    platform: Type.Enum(DevicePlatformEnum, { error: "platform is required" }),
     /**
      * OS name
      */
-    name: t.String({ error: "name is required" }),
+    name: Type.String({ error: "name is required" }),
     /**
      * OS version
      */
-    version: t.String({ error: "version is required" }),
+    version: Type.String({ error: "version is required" }),
 });
 /**
  * Hardware info schema
  */
-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" }),
+export const HardwareInfoSchema = Type.Object({
+    device_name: Type.String({ error: "device_name is required" }),
+    device_type: Type.String({ error: "device_type is required" }),
+    device_brand: Type.String({ error: "device_brand is required" }),
+});
+export const EmergencyLaunchSchema = Type.Union([
+    Type.Object({
+        is_emergency_launch: Type.Literal(true),
+        reason: Type.String({ error: "reason is required when is_emergency_launch is true" }),
     }),
-    t.Object({
-        is_emergency_launch: t.Literal(false),
-        reason: t.Optional(t.Never()),
+    Type.Object({
+        is_emergency_launch: Type.Literal(false),
+        reason: Type.Optional(Type.Never()),
     }),
 ]);
 /**
  * Update info schema
  */
-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" }),
+export const DeviceUpdateInfoSchema = Type.Object({
+    is_enabled: Type.Boolean(),
+    update_id: Type.String({ error: "update_id is required" }),
+    update_channel: Type.String({ error: "update_channel is required" }),
+    runtime_version: Type.String({ error: "runtime_version is required" }),
     emergency_launch: EmergencyLaunchSchema,
-    is_embedded_launch: t.Boolean({ error: "is_embedded_launch is required" }),
-    created_at: t.String(),
-});
-export var NotificationPlatform;
-(function (NotificationPlatform) {
-    NotificationPlatform["APNS"] = "APNS";
-    NotificationPlatform["FCM"] = "FCM";
-    NotificationPlatform["EXPO"] = "EXPO";
-})(NotificationPlatform || (NotificationPlatform = {}));
+    is_embedded_launch: Type.Boolean({ error: "is_embedded_launch is required" }),
+    created_at: Type.String(),
+});
+export var NotificationPlatformEnum;
+(function (NotificationPlatformEnum) {
+    NotificationPlatformEnum["APNS"] = "APNS";
+    NotificationPlatformEnum["FCM"] = "FCM";
+    NotificationPlatformEnum["EXPO"] = "EXPO";
+})(NotificationPlatformEnum || (NotificationPlatformEnum = {}));
 /**
  * Push notification info schema
  */
-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 PushNotificationInfoSchema = Type.Object({
+    enabled: Type.Boolean({ error: "enabled is required" }),
+    granted: Type.Boolean({ error: "granted is required" }),
+    token: Type.Union([Type.String({ error: "token is required" }), Type.Null()]),
+    platform: Type.Enum(NotificationPlatformEnum, { error: "platform is required" }),
 });
-export const NotificationsInfoSchema = t.Object({
+export const NotificationsInfoSchema = Type.Object({
     push: PushNotificationInfoSchema,
 });
 /**
  * Device info schema
  */
-export const DeviceInfoSchema = t.Object({
+export const DeviceInfoSchema = Type.Object({
     /**
      * Timestamp of collection on device (optional, generated server-side if not provided)
      */
-    timestamp: t.Optional(t.Date({ error: "timestamp is required" })),
+    timestamp: Type.Optional(Type.Date({ error: "timestamp is required" })),
     /**
      * Application info, required
      */
@@ -89,7 +89,7 @@ export const DeviceInfoSchema = t.Object({
     /**
      * Update info (optional) - not all builds will have an update
      */
-    update: t.Union([DeviceUpdateInfoSchema, t.Null()]),
+    update: Type.Union([DeviceUpdateInfoSchema, Type.Null()]),
     /**
      * Hardware info, required
      */
@@ -107,18 +107,18 @@ export const DeviceInfoSchema = t.Object({
  * Persona info schema (optional fields)
  * Matches personas table structure
  */
-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" })),
+export const PersonaInfoSchema = Type.Object({
+    user_id: Type.Optional(Type.String({ error: "user_id is required" })),
+    email: Type.Optional(EmailSchema),
+    name: Type.Optional(Type.String({ error: "name is required" })),
 });
 /**
  * Identify request schema
  * Ties a device to a persona with optional persona data
  */
-export const IdentifyRequestSchema = t.Object({
+export const IdentifyRequestSchema = Type.Object({
     device: DeviceInfoSchema,
-    persona: t.Optional(PersonaInfoSchema),
+    persona: Type.Optional(PersonaInfoSchema),
 });
 export var IdentifyVersionStatusEnum;
 (function (IdentifyVersionStatusEnum) {
@@ -139,83 +139,83 @@ export var IdentifyVersionStatusEnum;
      */
     IdentifyVersionStatusEnum["DISABLED"] = "DISABLED";
 })(IdentifyVersionStatusEnum || (IdentifyVersionStatusEnum = {}));
-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),
+export const UpdateInfoSchema = Type.Object({
+    version: Type.String({ error: "version is required" }),
+    build: Type.String({ error: "build is required" }),
+    update_id: Type.String({ error: "update_id is required" }),
+    effective_date: Type.Date({ error: "effective_date is required" }),
+});
+export const UpToDateInfoSchema = Type.Object({
+    status: Type.Literal(IdentifyVersionStatusEnum.UP_TO_DATE),
+    update: Type.Null(),
+});
+export const UpdateRequiredInfoSchema = Type.Object({
+    status: Type.Literal(IdentifyVersionStatusEnum.UPDATE_REQUIRED),
     update: UpdateInfoSchema,
 });
-export const UpdateAvailableInfoSchema = t.Object({
-    status: t.Literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
+export const UpdateAvailableInfoSchema = Type.Object({
+    status: Type.Literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
     update: UpdateInfoSchema,
 });
-export const VersionInfoSchema = t.Object({
+export const VersionInfoSchema = Type.Object({
     /**
      * The status of the version
      */
-    status: t.Enum(IdentifyVersionStatusEnum, { error: "status is required" }),
-    update: t.Optional(t.Union([UpdateAvailableInfoSchema, t.Null()])),
+    status: Type.Enum(IdentifyVersionStatusEnum, { error: "status is required" }),
+    update: Type.Optional(Type.Union([UpdateAvailableInfoSchema, Type.Null()])),
 });
 /**
  * Identify response schema
  */
-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
+export const IdentifyResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Object({
+        session_id: Type.String({ error: "session_id is required" }),
+        device_id: Type.String({ error: "device_id is required" }),
+        persona_id: Type.String({ error: "persona_id is required" }),
+        token: Type.String({ error: "token is required" }), // JWT token for session authentication
         version_info: VersionInfoSchema,
     }),
 });
-export const IdentifyErrorResponseSchema = t.Object({
-    success: t.Literal(false),
-    error: t.Union([
-        t.Object({
-            code: t.Literal("MISSING_ORG_ID"),
-            message: t.String(),
+export const IdentifyErrorResponseSchema = 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("IDENTIFY_FAILED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("IDENTIFY_FAILED"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("NO_SESSION_ID_GENERATED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("NO_SESSION_ID_GENERATED"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("NO_DEVICE_ID_GENERATED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("NO_DEVICE_ID_GENERATED"),
+            message: Type.String(),
         }),
-        t.Object({
-            code: t.Literal("NO_PERSONA_ID_GENERATED"),
-            message: t.String(),
+        Type.Object({
+            code: Type.Literal("NO_PERSONA_ID_GENERATED"),
+            message: Type.String(),
         }),
     ]),
 });
-export const ValidationErrorSchema = t.Object({
-    success: t.Literal(false),
-    error: t.Literal("VALIDATION"),
-    message: t.String(),
+export const ValidationErrorSchema = Type.Object({
+    success: Type.Literal(false),
+    error: Type.Literal("VALIDATION"),
+    message: Type.String(),
 });

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

@@ -1,4 +1,4 @@
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 /**
  * User schema
  * Represents Supabase Auth user structure
@@ -31,10 +31,10 @@ export type MeResponse = Static<typeof MeResponseSchema>;
 export declare const MeOrgsResponseSchema: import("@sinclair/typebox").TObject<{
     orgs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
         id: import("@sinclair/typebox").TString;
-        org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
         user_id: import("@sinclair/typebox").TString;
         created_at: import("@sinclair/typebox").TString;
         updated_at: import("@sinclair/typebox").TString;
+        org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
         role: import("@sinclair/typebox").TEnum<typeof import("@teardown/types").OrgRoleTypeEnum>;
         org_name: import("@sinclair/typebox").TString;
         org_slug: import("@sinclair/typebox").TString;

package/dist/modules/me/schemas.js

@@ -1,15 +1,15 @@
-import { t } from "elysia";
+import { Type } from "@sinclair/typebox";
 import { OrgRoleWithOrgSchema } from "../orgs/schemas";
 /**
  * User schema
  * Represents Supabase Auth user structure
  */
-export const UserSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    email: t.Optional(t.String({ format: "email" })),
-    app_metadata: t.Record(t.String(), t.Unknown()),
-    user_metadata: t.Record(t.String(), t.Unknown()),
-    created_at: t.String(),
+export const UserSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    email: Type.Optional(Type.String({ format: "email" })),
+    app_metadata: Type.Record(Type.String(), Type.Unknown()),
+    user_metadata: Type.Record(Type.String(), Type.Unknown()),
+    created_at: Type.String(),
     // id: string
     // app_metadata: UserAppMetadata
     // user_metadata: UserMetadata
@@ -39,38 +39,38 @@ export const UserSchema = t.Object({
 /**
  * Me response schema
  */
-export const MeResponseSchema = t.Object({
+export const MeResponseSchema = Type.Object({
     user: UserSchema,
 });
 /**
  * Me orgs response schema
  * Reuses OrgRoleWithOrgSchema from orgs module
  */
-export const MeOrgsResponseSchema = t.Object({
-    orgs: t.Array(OrgRoleWithOrgSchema),
+export const MeOrgsResponseSchema = Type.Object({
+    orgs: Type.Array(OrgRoleWithOrgSchema),
 });
 /**
  * Me error response schema
  * Discriminated union by error code
  */
-export const MeErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("UNAUTHORIZED"),
-        message: t.String(),
+export const MeErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("UNAUTHORIZED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("USER_NOT_FOUND"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("USER_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("FETCH_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("FETCH_FAILED"),
+        message: Type.String(),
     }),
 ]);
 /**
  * Me error response wrapper
  */
-export const MeErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const MeErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: MeErrorSchema,
 });

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

@@ -1,5 +1,5 @@
+import { type Static } from "@sinclair/typebox";
 import { OrgRoleTypeEnum, OrgTypeEnum } from "@teardown/types";
-import { type Static } from "elysia";
 import { type AssertSchemaCompatibleWithInsert, type AssertSchemaCompatibleWithRow, type AssertSchemaCompatibleWithUpdate, type AssertTrue } from "../../common";
 export declare const OrgHeadersSchema: import("@sinclair/typebox").TObject<{
     "td-org-id": import("@sinclair/typebox").TString;
@@ -71,10 +71,10 @@ export type OrgRole = Static<typeof OrgRoleSchema>;
  */
 export declare const OrgRoleWithOrgSchema: import("@sinclair/typebox").TObject<{
     id: import("@sinclair/typebox").TString;
-    org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
     user_id: import("@sinclair/typebox").TString;
     created_at: import("@sinclair/typebox").TString;
     updated_at: import("@sinclair/typebox").TString;
+    org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
     role: import("@sinclair/typebox").TEnum<typeof OrgRoleTypeEnum>;
     org_name: import("@sinclair/typebox").TString;
     org_slug: import("@sinclair/typebox").TString;
@@ -113,10 +113,10 @@ export declare const OrgResponseSchema: import("@sinclair/typebox").TObject<{
     data: import("@sinclair/typebox").TObject<{
         org: import("@sinclair/typebox").TObject<{
             id: import("@sinclair/typebox").TString;
-            org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
             user_id: import("@sinclair/typebox").TString;
             created_at: import("@sinclair/typebox").TString;
             updated_at: import("@sinclair/typebox").TString;
+            org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
             role: import("@sinclair/typebox").TEnum<typeof OrgRoleTypeEnum>;
             org_name: import("@sinclair/typebox").TString;
             org_slug: import("@sinclair/typebox").TString;
@@ -239,10 +239,10 @@ export declare const OrgRequestResponseSchema: import("@sinclair/typebox").TUnio
     data: import("@sinclair/typebox").TObject<{
         org: import("@sinclair/typebox").TObject<{
             id: import("@sinclair/typebox").TString;
-            org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
             user_id: import("@sinclair/typebox").TString;
             created_at: import("@sinclair/typebox").TString;
             updated_at: import("@sinclair/typebox").TString;
+            org_id: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString]>;
             role: import("@sinclair/typebox").TEnum<typeof OrgRoleTypeEnum>;
             org_name: import("@sinclair/typebox").TString;
             org_slug: import("@sinclair/typebox").TString;