@teardown/schemas 0.1.0 → 0.1.2

package/dist/common/primitives.d.ts

@@ -1,4 +1,4 @@
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 export declare const UUIDSchema: import("@sinclair/typebox").TString;
 export declare const SlugSchema: import("@sinclair/typebox").TString;
 export declare const URLSchema: import("@sinclair/typebox").TString;

package/dist/common/primitives.js

@@ -1,9 +1,8 @@
 import { Type } from "@sinclair/typebox";
-import { t } from "elysia";
-export const UUIDSchema = t.String({ format: "uuid", error: "Invalid UUID" });
-export const SlugSchema = t.String({ pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$", error: "Invalid slug" });
-export const URLSchema = t.String({ format: "uri", error: "Invalid URL" });
-export const TimestampSchema = t.String({ format: "date-time", error: "Invalid timestamp" });
-export const EmailSchema = Type.Transform(Type.Optional(Type.Union([Type.String({ format: "email", error: "Invalid email address" }), Type.Literal(""), t.Undefined()])))
+export const UUIDSchema = Type.String({ format: "uuid", error: "Invalid UUID" });
+export const SlugSchema = Type.String({ pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$", error: "Invalid slug" });
+export const URLSchema = Type.String({ format: "uri", error: "Invalid URL" });
+export const TimestampSchema = Type.String({ format: "date-time", error: "Invalid timestamp" });
+export const EmailSchema = Type.Transform(Type.Optional(Type.Union([Type.String({ format: "email", error: "Invalid email address" }), Type.Literal(""), Type.Undefined()])))
     .Decode((value) => (value === "" ? undefined : value))
     .Encode((value) => value ?? "");

package/dist/common/responses.d.ts

@@ -1,4 +1,4 @@
-import { type Static, type TSchema } from "elysia";
+import { type Static, type TSchema } from "@sinclair/typebox";
 export declare const SuccessResponseSchema: <T extends TSchema>(dataSchema: T) => import("@sinclair/typebox").TObject<{
     success: import("@sinclair/typebox").TLiteral<true>;
     data: T;

package/dist/common/responses.js

@@ -1,13 +1,13 @@
-import { t } from "elysia";
-export const SuccessResponseSchema = (dataSchema) => t.Object({
-    success: t.Literal(true),
+import { Type } from "@sinclair/typebox";
+export const SuccessResponseSchema = (dataSchema) => Type.Object({
+    success: Type.Literal(true),
     data: dataSchema,
 });
-export const ErrorResponseSchema = t.Object({
-    success: t.Literal(false),
-    error: t.Object({
-        message: t.String(),
-        code: t.Optional(t.String()),
+export const ErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
+    error: Type.Object({
+        message: Type.String(),
+        code: Type.Optional(Type.String()),
     }),
 });
-export const RequestResponseSchema = (successSchema) => t.Union([SuccessResponseSchema(successSchema), ErrorResponseSchema]);
+export const RequestResponseSchema = (successSchema) => Type.Union([SuccessResponseSchema(successSchema), ErrorResponseSchema]);

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

@@ -1,4 +1,4 @@
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 /**
  * Version adoption schema
  */

package/dist/modules/analytics/schemas.js

@@ -1,136 +1,136 @@
-import { t } from "elysia";
+import { Type } from "@sinclair/typebox";
 /**
  * Version adoption schema
  */
-export const VersionAdoptionPointSchema = t.Object({
-    date: t.String(), // YYYY-MM-DD
-    versions: t.Record(t.String(), t.Number()), // version -> count
+export const VersionAdoptionPointSchema = Type.Object({
+    date: Type.String(), // YYYY-MM-DD
+    versions: Type.Record(Type.String(), Type.Number()), // version -> count
 });
-export const VersionAdoptionResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Array(VersionAdoptionPointSchema),
+export const VersionAdoptionResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Array(VersionAdoptionPointSchema),
 });
 /**
  * Active sessions trend schema
  */
-export const ActiveSessionsPointSchema = t.Object({
-    date: t.String(), // YYYY-MM-DD
-    count: t.Integer({ minimum: 0 }),
+export const ActiveSessionsPointSchema = Type.Object({
+    date: Type.String(), // YYYY-MM-DD
+    count: Type.Integer({ minimum: 0 }),
 });
-export const ActiveSessionsTrendResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Array(ActiveSessionsPointSchema),
+export const ActiveSessionsTrendResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Array(ActiveSessionsPointSchema),
 });
 /**
  * Active users schema (with platform breakdown)
  */
-export const ActiveUsersSchema = t.Object({
-    total: t.Integer({ minimum: 0 }),
-    ios: t.Integer({ minimum: 0 }),
-    android: t.Integer({ minimum: 0 }),
-    trend: t.Number(), // percentage change vs previous period
-});
-export const ActiveUsersResponseSchema = t.Object({
-    success: t.Literal(true),
+export const ActiveUsersSchema = Type.Object({
+    total: Type.Integer({ minimum: 0 }),
+    ios: Type.Integer({ minimum: 0 }),
+    android: Type.Integer({ minimum: 0 }),
+    trend: Type.Number(), // percentage change vs previous period
+});
+export const ActiveUsersResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: ActiveUsersSchema,
 });
 /**
  * Active users query params schema
  */
-export const ActiveUsersQuerySchema = t.Object({
-    start_date: t.String({ format: "date-time" }),
-    end_date: t.String({ format: "date-time" }),
+export const ActiveUsersQuerySchema = Type.Object({
+    start_date: Type.String({ format: "date-time" }),
+    end_date: Type.String({ format: "date-time" }),
 });
 /**
  * Build adoption schema (with platform breakdown)
  */
-export const BuildStatsSchema = t.Object({
-    total: t.Integer({ minimum: 0 }),
-    ios: t.Integer({ minimum: 0 }),
-    android: t.Integer({ minimum: 0 }),
+export const BuildStatsSchema = Type.Object({
+    total: Type.Integer({ minimum: 0 }),
+    ios: Type.Integer({ minimum: 0 }),
+    android: Type.Integer({ minimum: 0 }),
 });
-export const BuildAdoptionPointSchema = t.Object({
-    date: t.String(), // YYYY-MM-DD
-    builds: t.Record(t.String(), BuildStatsSchema), // build_number -> stats
+export const BuildAdoptionPointSchema = Type.Object({
+    date: Type.String(), // YYYY-MM-DD
+    builds: Type.Record(Type.String(), BuildStatsSchema), // build_number -> stats
 });
-export const BuildAdoptionResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Array(BuildAdoptionPointSchema),
+export const BuildAdoptionResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Array(BuildAdoptionPointSchema),
 });
 /**
  * Date range query params schema (shared)
  */
-export const DateRangeQuerySchema = t.Object({
-    start_date: t.String({ format: "date-time" }),
-    end_date: t.String({ format: "date-time" }),
+export const DateRangeQuerySchema = Type.Object({
+    start_date: Type.String({ format: "date-time" }),
+    end_date: Type.String({ format: "date-time" }),
 });
 /**
  * Active versions/builds query params schema (with optional search)
  */
-export const ActiveVersionsQuerySchema = t.Object({
-    start_date: t.String({ format: "date-time" }),
-    end_date: t.String({ format: "date-time" }),
-    search: t.Optional(t.String()),
+export const ActiveVersionsQuerySchema = Type.Object({
+    start_date: Type.String({ format: "date-time" }),
+    end_date: Type.String({ format: "date-time" }),
+    search: Type.Optional(Type.String()),
 });
 /**
  * Active versions & builds analytics schema
  * Aggregated session counts by version and build for a date range
  */
-export const ActiveBuildStatsSchema = t.Object({
-    build_id: t.String(),
-    build_number: t.Integer({ minimum: 0 }),
-    platform: t.Union([t.Literal("IOS"), t.Literal("ANDROID")]),
-    session_count: t.Integer({ minimum: 0 }),
-    device_count: t.Integer({ minimum: 0 }),
-});
-export const ActiveVersionStatsSchema = t.Object({
-    version_id: t.String(),
-    version_name: t.String(),
-    session_count: t.Integer({ minimum: 0 }),
-    device_count: t.Integer({ minimum: 0 }),
-    ios_count: t.Integer({ minimum: 0 }),
-    android_count: t.Integer({ minimum: 0 }),
-    builds: t.Array(ActiveBuildStatsSchema),
-});
-export const ActiveVersionsBuildsSchema = t.Object({
-    versions: t.Array(ActiveVersionStatsSchema),
-});
-export const ActiveVersionsBuildsResponseSchema = t.Object({
-    success: t.Literal(true),
+export const ActiveBuildStatsSchema = Type.Object({
+    build_id: Type.String(),
+    build_number: Type.Integer({ minimum: 0 }),
+    platform: Type.Union([Type.Literal("IOS"), Type.Literal("ANDROID")]),
+    session_count: Type.Integer({ minimum: 0 }),
+    device_count: Type.Integer({ minimum: 0 }),
+});
+export const ActiveVersionStatsSchema = Type.Object({
+    version_id: Type.String(),
+    version_name: Type.String(),
+    session_count: Type.Integer({ minimum: 0 }),
+    device_count: Type.Integer({ minimum: 0 }),
+    ios_count: Type.Integer({ minimum: 0 }),
+    android_count: Type.Integer({ minimum: 0 }),
+    builds: Type.Array(ActiveBuildStatsSchema),
+});
+export const ActiveVersionsBuildsSchema = Type.Object({
+    versions: Type.Array(ActiveVersionStatsSchema),
+});
+export const ActiveVersionsBuildsResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: ActiveVersionsBuildsSchema,
 });
 /**
  * Session with user/device data for build sessions endpoint
  */
-export const SessionDeviceSchema = t.Object({
-    id: t.String(),
-    device_name: t.Union([t.String(), t.Null()]),
-    device_brand: t.Union([t.String(), t.Null()]),
-});
-export const SessionUserSchema = t.Object({
-    id: t.String(),
-    user_id: t.Union([t.String(), t.Null()]),
-    email: t.Union([t.String(), t.Null()]),
-    name: t.Union([t.String(), t.Null()]),
-});
-export const SessionWithUserSchema = t.Object({
-    id: t.String(),
-    started_at: t.String(),
-    os_version: t.Union([t.String(), t.Null()]),
+export const SessionDeviceSchema = Type.Object({
+    id: Type.String(),
+    device_name: Type.Union([Type.String(), Type.Null()]),
+    device_brand: Type.Union([Type.String(), Type.Null()]),
+});
+export const SessionUserSchema = Type.Object({
+    id: Type.String(),
+    user_id: Type.Union([Type.String(), Type.Null()]),
+    email: Type.Union([Type.String(), Type.Null()]),
+    name: Type.Union([Type.String(), Type.Null()]),
+});
+export const SessionWithUserSchema = Type.Object({
+    id: Type.String(),
+    started_at: Type.String(),
+    os_version: Type.Union([Type.String(), Type.Null()]),
     device: SessionDeviceSchema,
-    user: t.Union([SessionUserSchema, t.Null()]),
-});
-export const BuildSessionsQuerySchema = t.Object({
-    start_date: t.String({ format: "date-time" }),
-    end_date: t.String({ format: "date-time" }),
-    cursor: t.Optional(t.String()),
-    limit: t.Optional(t.String({ default: "20" })),
-    search: t.Optional(t.String()),
-});
-export const BuildSessionsResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Object({
-        sessions: t.Array(SessionWithUserSchema),
-        next_cursor: t.Union([t.String(), t.Null()]),
+    user: Type.Union([SessionUserSchema, Type.Null()]),
+});
+export const BuildSessionsQuerySchema = Type.Object({
+    start_date: Type.String({ format: "date-time" }),
+    end_date: Type.String({ format: "date-time" }),
+    cursor: Type.Optional(Type.String()),
+    limit: Type.Optional(Type.String({ default: "20" })),
+    search: Type.Optional(Type.String()),
+});
+export const BuildSessionsResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Object({
+        sessions: Type.Array(SessionWithUserSchema),
+        next_cursor: Type.Union([Type.String(), Type.Null()]),
     }),
 });

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

@@ -1,5 +1,5 @@
 import { VersionBuildStatusEnum } from "@teardown/types";
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
 /**
  * Build status enum matching database (reuses VersionBuildStatusEnum)

package/dist/modules/builds/schemas.js

@@ -1,137 +1,137 @@
 import { VersionBuildStatusEnum } from "@teardown/types";
-import { t } from "elysia";
+import { Type } from "@sinclair/typebox";
 import { DevicePlatformSchema } from "../devices/schemas";
 /**
  * Build status enum matching database (reuses VersionBuildStatusEnum)
  */
-export const BuildStatusSchema = t.Enum(VersionBuildStatusEnum);
+export const BuildStatusSchema = Type.Enum(VersionBuildStatusEnum);
 /**
  * Base build schema
  * Represents version_builds table structure
  */
-export const BuildSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    version_id: t.String({ format: "uuid" }),
-    build_number: t.Integer({ minimum: 0 }),
-    name: t.Union([t.String(), t.Null()]),
-    summary: t.Union([t.String(), t.Null()]),
-    commit_sha: t.Union([t.String(), t.Null()]),
+export const BuildSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    version_id: Type.String({ format: "uuid" }),
+    build_number: Type.Integer({ minimum: 0 }),
+    name: Type.Union([Type.String(), Type.Null()]),
+    summary: Type.Union([Type.String(), Type.Null()]),
+    commit_sha: Type.Union([Type.String(), Type.Null()]),
     platform: DevicePlatformSchema,
     status: BuildStatusSchema,
-    fingerprint: t.Union([t.String(), t.Null()]),
-    created_at: t.String(),
-    updated_at: t.String(),
+    fingerprint: Type.Union([Type.String(), Type.Null()]),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Build params schema
  */
-export const BuildParamsSchema = t.Object({
-    build_id: t.String({ format: "uuid" }),
+export const BuildParamsSchema = Type.Object({
+    build_id: Type.String({ format: "uuid" }),
 });
 /**
  * Search builds query schema
  * Supports pagination, search, and sorting
  */
-export const SearchBuildsQuerySchema = 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("build_number"),
-        t.Literal("platform"),
-        t.Literal("name"),
+export const SearchBuildsQuerySchema = 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("build_number"),
+        Type.Literal("platform"),
+        Type.Literal("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 builds query schema without project_id (injected from headers)
  */
-export const SearchBuildsQueryParamsSchema = t.Omit(SearchBuildsQuerySchema, ["project_id"]);
+export const SearchBuildsQueryParamsSchema = Type.Omit(SearchBuildsQuerySchema, ["project_id"]);
 /**
  * Builds by IDs request schema
  */
-export const BuildsByIdsSchema = t.Object({
-    build_ids: t.Array(t.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+export const BuildsByIdsSchema = Type.Object({
+    build_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
 });
 /**
  * Paginated builds response schema
  */
-export const BuildsResponseSchema = t.Object({
-    builds: t.Array(BuildSchema),
-    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 BuildsResponseSchema = Type.Object({
+    builds: Type.Array(BuildSchema),
+    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 build response schema
  */
-export const BuildResponseSchema = t.Object({
-    success: t.Literal(true),
+export const BuildResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: BuildSchema,
 });
 /**
  * Build error response schema
  * Discriminated union by error code
  */
-export const BuildErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("BUILD_NOT_FOUND"),
-        message: t.String(),
+export const BuildErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("BUILD_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(),
     }),
 ]);
 /**
  * Build error response wrapper
  */
-export const BuildErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const BuildErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: BuildErrorSchema,
 });
 /**
  * Build request response schema
  */
-export const BuildRequestResponseSchema = t.Union([BuildResponseSchema, BuildErrorResponseSchema]);
+export const BuildRequestResponseSchema = Type.Union([BuildResponseSchema, BuildErrorResponseSchema]);
 /**
  * Update build status request body schema
  */
-export const UpdateBuildStatusBodySchema = t.Object({
+export const UpdateBuildStatusBodySchema = Type.Object({
     status: BuildStatusSchema,
 });
 /**
  * Add UPDATE_FAILED error code for update operations
  */
-export const BuildErrorSchemaWithUpdate = t.Union([
+export const BuildErrorSchemaWithUpdate = Type.Union([
     BuildErrorSchema,
-    t.Object({
-        code: t.Literal("UPDATE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("UPDATE_FAILED"),
+        message: Type.String(),
     }),
 ]);
 /**
  * Build error response wrapper with update error
  */
-export const BuildErrorResponseWithUpdateSchema = t.Object({
-    success: t.Literal(false),
+export const BuildErrorResponseWithUpdateSchema = Type.Object({
+    success: Type.Literal(false),
     error: BuildErrorSchemaWithUpdate,
 });

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

@@ -1,5 +1,5 @@
+import { type Static } from "@sinclair/typebox";
 import { DevicePlatformEnum } from "@teardown/types";
-import { type Static } from "elysia";
 import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
 /**
  * Device platform enum matching database