@teardown/schemas 0.1.21 → 0.1.23

package/src/modules/devices/schemas.ts

@@ -0,0 +1,196 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { DevicePlatformEnum } from "@teardown/types";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Device platform enum matching database
+ */
+
+/**
+ * Device platform
+ */
+export const DevicePlatformSchema = Type.Enum(DevicePlatformEnum, { error: "platform is required" });
+export type DevicePlatform = Static<typeof DevicePlatformSchema>;
+
+/**
+ * Parse and validate a DevicePlatformEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated DevicePlatformEnum value or null
+ * @throws Error if the value is not a valid DevicePlatformEnum and not null
+ */
+export function parseDevicePlatformEnum(value: unknown): DevicePlatformEnum | null {
+	if (value === null || value === undefined) {
+		return null;
+	}
+	switch (value) {
+		case DevicePlatformEnum.IOS:
+			return DevicePlatformEnum.IOS;
+		case DevicePlatformEnum.ANDROID:
+			return DevicePlatformEnum.ANDROID;
+		case DevicePlatformEnum.WEB:
+			return DevicePlatformEnum.WEB;
+		case DevicePlatformEnum.WINDOWS:
+			return DevicePlatformEnum.WINDOWS;
+		case DevicePlatformEnum.MACOS:
+			return DevicePlatformEnum.MACOS;
+		case DevicePlatformEnum.LINUX:
+			return DevicePlatformEnum.LINUX;
+		case DevicePlatformEnum.PHONE:
+			return DevicePlatformEnum.PHONE;
+		case DevicePlatformEnum.TABLET:
+			return DevicePlatformEnum.TABLET;
+		case DevicePlatformEnum.DESKTOP:
+			return DevicePlatformEnum.DESKTOP;
+		case DevicePlatformEnum.CONSOLE:
+			return DevicePlatformEnum.CONSOLE;
+		case DevicePlatformEnum.TV:
+			return DevicePlatformEnum.TV;
+		case DevicePlatformEnum.WEARABLE:
+			return DevicePlatformEnum.WEARABLE;
+		case DevicePlatformEnum.GAME_CONSOLE:
+			return DevicePlatformEnum.GAME_CONSOLE;
+		case DevicePlatformEnum.VR:
+			return DevicePlatformEnum.VR;
+		case DevicePlatformEnum.UNKNOWN:
+			return DevicePlatformEnum.UNKNOWN;
+		case DevicePlatformEnum.OTHER:
+			return DevicePlatformEnum.OTHER;
+		default:
+			throw new Error(
+				`Invalid DevicePlatformEnum value: ${value}. Expected one of: ${Object.values(DevicePlatformEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Base device schema
+ * Represents devices table structure
+ */
+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(),
+});
+export type Device = Static<typeof DeviceSchema>;
+
+/**
+ * Device params schema
+ */
+export const DeviceParamsSchema = Type.Object({
+	device_id: Type.String({ format: "uuid" }),
+});
+export type DeviceParams = Static<typeof DeviceParamsSchema>;
+
+/**
+ * Search devices query schema
+ * Supports pagination, search, and sorting
+ */
+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: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
+});
+export type SearchDevicesQuery = Static<typeof SearchDevicesQuerySchema>;
+
+/**
+ * Search devices query schema without project_id (injected from headers)
+ */
+export const SearchDevicesQueryParamsSchema = Type.Omit(SearchDevicesQuerySchema, ["project_id"]);
+export type SearchDevicesQueryParams = Static<typeof SearchDevicesQueryParamsSchema>;
+
+/**
+ * Devices by IDs request schema
+ */
+export const DevicesByIdsSchema = Type.Object({
+	device_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type DevicesByIds = Static<typeof DevicesByIdsSchema>;
+
+/**
+ * Paginated devices response schema
+ */
+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 }),
+	}),
+});
+export type DevicesResponse = Static<typeof DevicesResponseSchema>;
+
+/**
+ * Single device response schema
+ */
+export const DeviceResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: DeviceSchema,
+});
+export type DeviceResponse = Static<typeof DeviceResponseSchema>;
+
+/**
+ * Device error response schema
+ * Discriminated union by error code
+ */
+export const DeviceErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("DEVICE_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 DeviceError = Static<typeof DeviceErrorSchema>;
+
+/**
+ * Device error response wrapper
+ */
+export const DeviceErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: DeviceErrorSchema,
+});
+export type DeviceErrorResponse = Static<typeof DeviceErrorResponseSchema>;
+
+/**
+ * Device request response schema
+ */
+export const DeviceRequestResponseSchema = Type.Union([DeviceResponseSchema, DeviceErrorResponseSchema]);
+export type DeviceRequestResponse = Static<typeof DeviceRequestResponseSchema>;
+export type _CheckDeviceRow = AssertTrue<AssertSchemaCompatibleWithRow<Device, "devices">>;

package/src/modules/environment/schemas.ts

@@ -0,0 +1,81 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { EnvironmentTypeEnum } from "@teardown/types";
+import type {
+	AssertSchemaCompatibleWithInsert,
+	AssertSchemaCompatibleWithRow,
+	AssertSchemaCompatibleWithUpdate,
+	AssertTrue,
+} from "../../common";
+
+/**
+ * Environment type enum (re-exported for backward compatibility)
+ * @deprecated Use EnvironmentTypeEnum from @teardown/types instead
+ */
+export { EnvironmentTypeEnum as EnvironmentType };
+
+/**
+ * Environment schema
+ * Represents an environment within a project
+ */
+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
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated EnvironmentTypeEnum value
+ * @throws Error if the value is not a valid EnvironmentTypeEnum
+ */
+export function parseEnvironmentTypeEnum(value: unknown): EnvironmentTypeEnum {
+	switch (value) {
+		case EnvironmentTypeEnum.DEVELOPMENT:
+			return EnvironmentTypeEnum.DEVELOPMENT;
+		case EnvironmentTypeEnum.STAGING:
+			return EnvironmentTypeEnum.STAGING;
+		case EnvironmentTypeEnum.PRODUCTION:
+			return EnvironmentTypeEnum.PRODUCTION;
+		default:
+			throw new Error(
+				`Invalid EnvironmentTypeEnum value: ${value}. Expected one of: ${Object.values(EnvironmentTypeEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Create environment schema
+ * Used for creating new environments
+ */
+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 = Type.Object({
+	name: Type.String({ minLength: 1 }),
+	type: Type.Enum(EnvironmentTypeEnum),
+});
+
+/**
+ * TypeScript types inferred from schemas
+ */
+export type Environment = Static<typeof EnvironmentSchema>;
+export type CreateEnvironment = Static<typeof CreateEnvironmentSchema>;
+export type UpdateEnvironment = Static<typeof UpdateEnvironmentSchema>;
+
+export type _CheckEnvironmentRow = AssertTrue<AssertSchemaCompatibleWithRow<Environment, "environments">>;
+export type _CheckCreateEnvironment = AssertTrue<AssertSchemaCompatibleWithInsert<CreateEnvironment, "environments">>;
+export type _CheckUpdateEnvironment = AssertTrue<AssertSchemaCompatibleWithUpdate<UpdateEnvironment, "environments">>;

package/src/modules/events/index.ts

@@ -0,0 +1,2 @@
+export * from "./schemas";
+

package/src/modules/events/schemas.ts

@@ -0,0 +1,129 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Event type enum
+ */
+export const EventTypeEnum = ["action", "screen_view", "custom"] as const;
+export type EventType = (typeof EventTypeEnum)[number];
+
+/**
+ * Single event schema
+ */
+export const EventSchema = Type.Object({
+	/**
+	 * Name of the event (required)
+	 */
+	event_name: Type.String({ minLength: 1, error: "event_name is required" }),
+	/**
+	 * Type of event
+	 */
+	event_type: Type.Union([Type.Literal("action"), Type.Literal("screen_view"), Type.Literal("custom")], { default: "custom" }),
+	/**
+	 * Custom properties for the event (optional)
+	 */
+	properties: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+	/**
+	 * Client-side timestamp (optional, defaults to server time)
+	 */
+	timestamp: Type.Optional(Type.String()),
+	/**
+	 * Session ID (optional, can come from header)
+	 */
+	session_id: Type.Optional(Type.String({ format: "uuid" })),
+	/**
+	 * Device ID (optional, can come from header)
+	 */
+	device_id: Type.Optional(Type.String()),
+});
+export type Event = Static<typeof EventSchema>;
+
+/**
+ * Batch events request schema
+ * Accepts 1-100 events per request
+ */
+export const EventsRequestSchema = Type.Object({
+	/**
+	 * Array of events to ingest (1-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: Type.Optional(Type.String({ format: "uuid" })),
+	/**
+	 * Device ID (optional, applies to all events if not specified per-event)
+	 */
+	device_id: Type.Optional(Type.String()),
+});
+export type EventsRequest = Static<typeof EventsRequestSchema>;
+
+/**
+ * Events response schema
+ */
+export const EventsResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Object({
+		/**
+		 * IDs of created events
+		 */
+		event_ids: Type.Array(Type.String()),
+		/**
+		 * Number of successfully processed events
+		 */
+		processed_count: Type.Number(),
+		/**
+		 * Number of failed events
+		 */
+		failed_count: Type.Number(),
+	}),
+});
+export type EventsResponse = Static<typeof EventsResponseSchema>;
+
+/**
+ * Events error response schema
+ */
+export const EventsErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: Type.Union([
+		Type.Object({
+			code: Type.Literal("MISSING_ORG_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_PROJECT_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_ENVIRONMENT_SLUG"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_DEVICE_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("EVENTS_PROCESSING_FAILED"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("INVALID_SESSION"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("INVALID_DEVICE"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("BATCH_SIZE_EXCEEDED"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("VALIDATION_ERROR"),
+			message: Type.String(),
+		}),
+	]),
+});
+export type EventsErrorResponse = Static<typeof EventsErrorResponseSchema>;
+
+export type _CheckEventRow = AssertTrue<AssertSchemaCompatibleWithRow<Event, "events">>;

package/src/modules/identify/schemas.ts

@@ -0,0 +1,257 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { DevicePlatformEnum } from "@teardown/types";
+import { EmailSchema } from "../../common";
+
+export { DevicePlatformEnum };
+
+/**
+ * Application info schema
+ */
+export const ApplicationInfoSchema = Type.Object({
+	version: Type.String({ error: "version is required" }),
+	build_number: Type.String({ error: "build_number is required" }),
+});
+export type ApplicationInfo = Static<typeof ApplicationInfoSchema>;
+
+/**
+ * OS info schema
+ */
+export const OSInfoSchema = Type.Object({
+	/**
+	 * Device platform
+	 */
+	platform: Type.Enum(DevicePlatformEnum, { error: "platform is required" }),
+	/**
+	 * OS name
+	 */
+	name: Type.String({ error: "name is required" }),
+	/**
+	 * OS version
+	 */
+	version: Type.String({ error: "version is required" }),
+});
+export type OSInfo = Static<typeof OSInfoSchema>;
+
+/**
+ * Hardware info schema
+ */
+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 type HardwareInfo = Static<typeof HardwareInfoSchema>;
+
+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" }),
+	}),
+	Type.Object({
+		is_emergency_launch: Type.Literal(false),
+		reason: Type.Optional(Type.Never()),
+	}),
+]);
+export type EmergencyLaunch = Static<typeof EmergencyLaunchSchema>;
+
+/**
+ * Update info schema
+ */
+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: Type.Boolean({ error: "is_embedded_launch is required" }),
+	created_at: Type.String(),
+});
+export type DeviceUpdateInfo = Static<typeof DeviceUpdateInfoSchema>;
+
+export enum NotificationPlatformEnum {
+	APNS = "APNS", // Apple Push Notification Service
+	FCM = "FCM", // Firebase Cloud Messaging
+	EXPO = "EXPO", // Expo Push Notifications
+}
+
+/**
+ * Push notification info schema
+ */
+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 type PushNotificationInfo = Static<typeof PushNotificationInfoSchema>;
+
+export const NotificationsInfoSchema = Type.Object({
+	push: PushNotificationInfoSchema,
+});
+export type NotificationsInfo = Static<typeof NotificationsInfoSchema>;
+
+/**
+ * Device info schema
+ */
+export const DeviceInfoSchema = Type.Object({
+	/**
+	 * Timestamp of collection on device (optional, generated server-side if not provided)
+	 */
+	timestamp: Type.Optional(Type.Date({ error: "timestamp is required" })),
+	/**
+	 * Application info, required
+	 */
+	application: ApplicationInfoSchema,
+	/**
+	 * Update info (optional) - not all builds will have an update
+	 */
+	update: Type.Union([DeviceUpdateInfoSchema, Type.Null()]),
+	/**
+	 * Hardware info, required
+	 */
+	hardware: HardwareInfoSchema,
+	/**
+	 * OS info, required
+	 */
+	os: OSInfoSchema,
+	/**
+	 * Notifications info, required
+	 */
+	notifications: NotificationsInfoSchema,
+});
+export type DeviceInfo = Static<typeof DeviceInfoSchema>;
+
+/**
+ * Persona info schema (optional fields)
+ * Matches personas table structure
+ */
+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" })),
+});
+export type PersonaInfo = Static<typeof PersonaInfoSchema>;
+
+/**
+ * Identify request schema
+ * Ties a device to a persona with optional persona data
+ */
+export const IdentifyRequestSchema = Type.Object({
+	device: DeviceInfoSchema,
+	persona: Type.Optional(PersonaInfoSchema),
+});
+export type IdentifyRequest = Static<typeof IdentifyRequestSchema>;
+
+export enum IdentifyVersionStatusEnum {
+	/**
+	 * A new version is available
+	 */
+	UPDATE_AVAILABLE = "UPDATE_AVAILABLE",
+	/**
+	 * An update is required
+	 */
+	UPDATE_REQUIRED = "UPDATE_REQUIRED",
+	/**
+	 * The current version is valid & up to date
+	 */
+	UP_TO_DATE = "UP_TO_DATE",
+	/**
+	 * The version or build has been disabled
+	 */
+	DISABLED = "DISABLED",
+}
+
+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 type UpdateInfo = Static<typeof UpdateInfoSchema>;
+
+export const UpToDateInfoSchema = Type.Object({
+	status: Type.Literal(IdentifyVersionStatusEnum.UP_TO_DATE),
+	update: Type.Null(),
+});
+export type UpToDateInfo = Static<typeof UpToDateInfoSchema>;
+
+export const UpdateRequiredInfoSchema = Type.Object({
+	status: Type.Literal(IdentifyVersionStatusEnum.UPDATE_REQUIRED),
+	update: UpdateInfoSchema,
+});
+export type UpdateRequiredInfo = Static<typeof UpdateRequiredInfoSchema>;
+
+export const UpdateAvailableInfoSchema = Type.Object({
+	status: Type.Literal(IdentifyVersionStatusEnum.UPDATE_AVAILABLE),
+	update: UpdateInfoSchema,
+});
+export type UpdateAvailableInfo = Static<typeof UpdateAvailableInfoSchema>;
+
+export const VersionInfoSchema = Type.Object({
+	/**
+	 * The status of the version
+	 */
+	status: Type.Enum(IdentifyVersionStatusEnum, { error: "status is required" }),
+	update: Type.Optional(Type.Union([UpdateAvailableInfoSchema, Type.Null()])),
+});
+export type VersionInfo = Static<typeof VersionInfoSchema>;
+
+/**
+ * Identify response schema
+ */
+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 type IdentifyResponse = Static<typeof IdentifyResponseSchema>;
+
+export const IdentifyErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: Type.Union([
+		Type.Object({
+			code: Type.Literal("MISSING_ORG_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_PROJECT_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_ENVIRONMENT_SLUG"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("MISSING_DEVICE_ID"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("IDENTIFY_FAILED"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("NO_SESSION_ID_GENERATED"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("NO_DEVICE_ID_GENERATED"),
+			message: Type.String(),
+		}),
+		Type.Object({
+			code: Type.Literal("NO_PERSONA_ID_GENERATED"),
+			message: Type.String(),
+		}),
+	]),
+});
+export type IdentifyErrorResponse = Static<typeof IdentifyErrorResponseSchema>;
+
+export const ValidationErrorSchema = Type.Object({
+	success: Type.Literal(false),
+	error: Type.Literal("VALIDATION"),
+	message: Type.String(),
+});