@teardown/schemas 0.1.21 → 0.1.23

package/src/modules/sessions/schemas.ts

@@ -0,0 +1,158 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Base session schema
+ * Represents device_sessions table structure
+ */
+export const SessionSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	device_id: Type.String({ format: "uuid" }),
+	token: Type.Union([Type.String(), Type.Null()]),
+	version: Type.Union([Type.String(), Type.Null()]),
+	version_id: Type.Union([Type.String({ format: "uuid" }), Type.Null()]),
+	version_build_id: Type.Union([Type.String({ format: "uuid" }), Type.Null()]),
+	os_version: Type.Union([Type.String(), Type.Null()]),
+	ota_updates_enabled: Type.Union([Type.Boolean(), Type.Null()]),
+	is_emergency_launch: Type.Union([Type.Boolean(), Type.Null()]),
+	emergency_launch_reason: Type.Union([Type.String(), Type.Null()]),
+	is_embedded_launch: Type.Union([Type.Boolean(), Type.Null()]),
+	ota_update_id: Type.Union([Type.String({ format: "uuid" }), Type.Null()]),
+	ota_update_runtime_version: Type.Union([Type.String(), Type.Null()]),
+	ota_update_created_at: Type.Union([Type.String(), Type.Null()]),
+	metadata: Type.Union([Type.Record(Type.String(), Type.Unknown()), Type.Null()]),
+	started_at: Type.String(),
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type Session = Static<typeof SessionSchema>;
+
+/**
+ * Session with device info for joined queries
+ */
+export const SessionWithDeviceSchema = Type.Composite([
+	SessionSchema,
+	Type.Object({
+		device: Type.Optional(
+			Type.Object({
+				device_id: Type.String(),
+				device_name: Type.Union([Type.String(), Type.Null()]),
+				platform: Type.Union([Type.String(), Type.Null()]),
+			})
+		),
+	}),
+]);
+export type SessionWithDevice = Static<typeof SessionWithDeviceSchema>;
+
+/**
+ * Session params schema
+ */
+export const SessionParamsSchema = Type.Object({
+	session_id: Type.String({ format: "uuid" }),
+});
+export type SessionParams = Static<typeof SessionParamsSchema>;
+
+/**
+ * Search sessions query schema
+ * Supports pagination, search, and sorting
+ */
+export const SearchSessionsQuerySchema = 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("started_at"),
+			Type.Literal("created_at"),
+			Type.Literal("updated_at"),
+			Type.Literal("version"),
+			Type.Literal("os_version"),
+		],
+		{ default: "started_at" }
+	),
+	sort_order: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
+});
+export type SearchSessionsQuery = Static<typeof SearchSessionsQuerySchema>;
+
+/**
+ * Search sessions query schema without project_id (injected from headers)
+ */
+export const SearchSessionsQueryParamsSchema = Type.Omit(SearchSessionsQuerySchema, ["project_id"]);
+export type SearchSessionsQueryParams = Static<typeof SearchSessionsQueryParamsSchema>;
+
+/**
+ * Sessions by IDs request schema
+ */
+export const SessionsByIdsSchema = Type.Object({
+	session_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type SessionsByIds = Static<typeof SessionsByIdsSchema>;
+
+/**
+ * Paginated sessions response schema
+ */
+export const SessionsResponseSchema = Type.Object({
+	sessions: Type.Array(SessionWithDeviceSchema),
+	pagination: Type.Object({
+		page: Type.Integer({ minimum: 1 }),
+		limit: Type.Integer({ minimum: 1 }),
+		total: Type.Integer({ minimum: 0 }),
+		total_pages: Type.Integer({ minimum: 0 }),
+	}),
+});
+export type SessionsResponse = Static<typeof SessionsResponseSchema>;
+
+/**
+ * Single session response schema
+ */
+export const SessionResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: SessionWithDeviceSchema,
+});
+export type SessionResponse = Static<typeof SessionResponseSchema>;
+
+/**
+ * Session error response schema
+ * Discriminated union by error code
+ */
+export const SessionErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("SESSION_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("PROJECT_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FORBIDDEN"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_PARAMS"),
+		message: Type.String(),
+	}),
+]);
+export type SessionError = Static<typeof SessionErrorSchema>;
+
+/**
+ * Session error response wrapper
+ */
+export const SessionErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: SessionErrorSchema,
+});
+export type SessionErrorResponse = Static<typeof SessionErrorResponseSchema>;
+
+/**
+ * Session request response schema
+ */
+export const SessionRequestResponseSchema = Type.Union([SessionResponseSchema, SessionErrorResponseSchema]);
+export type SessionRequestResponse = Static<typeof SessionRequestResponseSchema>;
+
+export type _CheckSessionRow = AssertTrue<AssertSchemaCompatibleWithRow<Session, "device_sessions">>;

package/src/modules/versions/schemas.ts

@@ -0,0 +1,192 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { VersionBuildStatusEnum } from "@teardown/types";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Version status enum matching database
+ */
+export const VersionBuildStatusSchema = Type.Enum(VersionBuildStatusEnum);
+export type VersionBuildStatus = Static<typeof VersionBuildStatusSchema>;
+
+/**
+ * Parse and validate a VersionBuildStatusEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated VersionBuildStatusEnum value
+ * @throws Error if the value is not a valid VersionBuildStatusEnum
+ */
+export function parseVersionStatusEnum(value: unknown): VersionBuildStatusEnum {
+	switch (value) {
+		case VersionBuildStatusEnum.SUPPORTED:
+			return VersionBuildStatusEnum.SUPPORTED;
+		case VersionBuildStatusEnum.UPDATE_AVAILABLE:
+			return VersionBuildStatusEnum.UPDATE_AVAILABLE;
+		case VersionBuildStatusEnum.UPDATE_RECOMMENDED:
+		case VersionBuildStatusEnum.UPDATE_REQUIRED:
+			return VersionBuildStatusEnum.UPDATE_REQUIRED;
+		default:
+			throw new Error(
+				`Invalid VersionBuildStatusEnum value: ${value}. Expected one of: ${Object.values(VersionBuildStatusEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Base version schema
+ * Represents project_versions table structure
+ */
+export const VersionSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	project_id: Type.String({ format: "uuid" }),
+	name: Type.String(),
+	major: Type.Number(), // Matches type number, not integer constraint (db type numeric)
+	minor: Type.Number(),
+	patch: Type.Number(),
+	status: VersionBuildStatusSchema, // SUPPORTED, UPDATE_AVAILABLE, UPDATE_RECOMMENDED, UPDATE_REQUIRED - controls if version is active
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type Version = Static<typeof VersionSchema>;
+
+/**
+ * Version params schema
+ */
+export const VersionParamsSchema = Type.Object({
+	version_id: Type.String({ format: "uuid" }),
+});
+export type VersionParams = Static<typeof VersionParamsSchema>;
+
+/**
+ * Search versions query schema
+ * Supports pagination, search, and sorting
+ */
+export const SearchVersionsQuerySchema = 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("name"),
+			Type.Literal("major"),
+			Type.Literal("minor"),
+			Type.Literal("patch"),
+		],
+		{ default: "created_at" }
+	),
+	sort_order: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
+});
+export type SearchVersionsQuery = Static<typeof SearchVersionsQuerySchema>;
+
+/**
+ * Search versions query schema without project_id (injected from headers)
+ */
+export const SearchVersionsQueryParamsSchema = Type.Omit(SearchVersionsQuerySchema, ["project_id"]);
+export type SearchVersionsQueryParams = Static<typeof SearchVersionsQueryParamsSchema>;
+
+/**
+ * Versions by IDs request schema
+ */
+export const VersionsByIdsSchema = Type.Object({
+	version_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type VersionsByIds = Static<typeof VersionsByIdsSchema>;
+
+/**
+ * Paginated versions response schema
+ */
+export const VersionsResponseSchema = Type.Object({
+	versions: Type.Array(VersionSchema),
+	pagination: Type.Object({
+		page: Type.Integer({ minimum: 1 }),
+		limit: Type.Integer({ minimum: 1 }),
+		total: Type.Integer({ minimum: 0 }),
+		total_pages: Type.Integer({ minimum: 0 }),
+	}),
+});
+export type VersionsResponse = Static<typeof VersionsResponseSchema>;
+
+/**
+ * Single version response schema
+ */
+export const VersionResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: VersionSchema,
+});
+export type VersionResponse = Static<typeof VersionResponseSchema>;
+
+/**
+ * Version error response schema
+ * Discriminated union by error code
+ */
+export const VersionErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("VERSION_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("PROJECT_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FORBIDDEN"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_PARAMS"),
+		message: Type.String(),
+	}),
+]);
+export type VersionError = Static<typeof VersionErrorSchema>;
+
+/**
+ * Version error response wrapper
+ */
+export const VersionErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: VersionErrorSchema,
+});
+export type VersionErrorResponse = Static<typeof VersionErrorResponseSchema>;
+
+/**
+ * Version request response schema
+ */
+export const VersionRequestResponseSchema = Type.Union([VersionResponseSchema, VersionErrorResponseSchema]);
+export type VersionRequestResponse = Static<typeof VersionRequestResponseSchema>;
+
+export type _CheckVersionRow = AssertTrue<AssertSchemaCompatibleWithRow<Version, "project_versions">>;
+
+/**
+ * Update version status request body schema
+ */
+export const UpdateVersionStatusBodySchema = Type.Object({
+	status: VersionBuildStatusSchema,
+});
+export type UpdateVersionStatusBody = Static<typeof UpdateVersionStatusBodySchema>;
+
+/**
+ * Add UPDATE_FAILED error code for update operations
+ */
+export const VersionErrorSchemaWithUpdate = Type.Union([
+	VersionErrorSchema,
+	Type.Object({
+		code: Type.Literal("UPDATE_FAILED"),
+		message: Type.String(),
+	}),
+]);
+export type VersionErrorWithUpdate = Static<typeof VersionErrorSchemaWithUpdate>;
+
+/**
+ * Version error response wrapper with update error
+ */
+export const VersionErrorResponseWithUpdateSchema = Type.Object({
+	success: Type.Literal(false),
+	error: VersionErrorSchemaWithUpdate,
+});
+export type VersionErrorResponseWithUpdate = Static<typeof VersionErrorResponseWithUpdateSchema>;

package/dist/common/index.js

@@ -1,3 +0,0 @@
-export * from "./primitives";
-export * from "./responses";
-export * from "./type-checks";

package/dist/common/primitives.d.ts

@@ -1,11 +0,0 @@
-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;
-export declare const TimestampSchema: import("@sinclair/typebox").TString;
-export type UUID = Static<typeof UUIDSchema>;
-export type Slug = Static<typeof SlugSchema>;
-export type URL = Static<typeof URLSchema>;
-export type Timestamp = Static<typeof TimestampSchema>;
-export declare const EmailSchema: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TLiteral<"">, import("@sinclair/typebox").TUndefined]>>, string | undefined>;
-export type Email = Static<typeof EmailSchema>;

package/dist/common/primitives.js

@@ -1,8 +0,0 @@
-import { Type } from "@sinclair/typebox";
-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,27 +0,0 @@
-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;
-}>;
-export declare const ErrorResponseSchema: import("@sinclair/typebox").TObject<{
-    success: import("@sinclair/typebox").TLiteral<false>;
-    error: import("@sinclair/typebox").TObject<{
-        message: import("@sinclair/typebox").TString;
-        code: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-}>;
-export type SuccessResponse<T> = {
-    success: true;
-    data: T;
-};
-export type ErrorResponse = Static<typeof ErrorResponseSchema>;
-export declare const RequestResponseSchema: <Success extends TSchema>(successSchema: Success) => import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
-    success: import("@sinclair/typebox").TLiteral<true>;
-    data: Success;
-}>, import("@sinclair/typebox").TObject<{
-    success: import("@sinclair/typebox").TLiteral<false>;
-    error: import("@sinclair/typebox").TObject<{
-        message: import("@sinclair/typebox").TString;
-        code: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-}>]>;

package/dist/common/responses.js

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

package/dist/common/type-checks.js

@@ -1 +0,0 @@
-export {};

package/dist/index.d.ts

@@ -1,13 +0,0 @@
-export * from "./common";
-export * from "./modules/analytics";
-export * from "./modules/builds";
-export * from "./modules/devices";
-export * from "./modules/environment";
-export * from "./modules/events";
-export * from "./modules/identify";
-export * from "./modules/me";
-export * from "./modules/orgs";
-export * from "./modules/personas";
-export * from "./modules/projects";
-export * from "./modules/sessions";
-export * from "./modules/versions";