@teardown/schemas 0.1.0

package/dist/modules/devices/schemas.js

@@ -0,0 +1,165 @@
+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" });
+/**
+ * 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) {
+    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 = 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(),
+});
+/**
+ * Device params schema
+ */
+export const DeviceParamsSchema = t.Object({
+    device_id: t.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"),
+    ], { default: "created_at" }),
+    sort_order: t.Union([t.Literal("asc"), t.Literal("desc")], { default: "desc" }),
+});
+/**
+ * Search devices query schema without project_id (injected from headers)
+ */
+export const SearchDevicesQueryParamsSchema = t.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 }),
+});
+/**
+ * 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 }),
+    }),
+});
+/**
+ * Single device response schema
+ */
+export const DeviceResponseSchema = t.Object({
+    success: t.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(),
+    }),
+    t.Object({
+        code: t.Literal("PROJECT_NOT_FOUND"),
+        message: t.String(),
+    }),
+    t.Object({
+        code: t.Literal("FORBIDDEN"),
+        message: t.String(),
+    }),
+    t.Object({
+        code: t.Literal("FETCH_FAILED"),
+        message: t.String(),
+    }),
+    t.Object({
+        code: t.Literal("INVALID_PARAMS"),
+        message: t.String(),
+    }),
+]);
+/**
+ * Device error response wrapper
+ */
+export const DeviceErrorResponseSchema = t.Object({
+    success: t.Literal(false),
+    error: DeviceErrorSchema,
+});
+/**
+ * Device request response schema
+ */
+export const DeviceRequestResponseSchema = t.Union([DeviceResponseSchema, DeviceErrorResponseSchema]);

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

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

package/dist/modules/environment/index.js

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

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

@@ -0,0 +1,56 @@
+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)
+ * @deprecated Use EnvironmentTypeEnum from @teardown/types instead
+ */
+export { EnvironmentTypeEnum as EnvironmentType };
+/**
+ * Environment schema
+ * Represents an environment within a project
+ */
+export declare const EnvironmentSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    project_id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    slug: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TEnum<typeof EnvironmentTypeEnum>;
+    created_at: import("@sinclair/typebox").TString;
+    updated_at: import("@sinclair/typebox").TString;
+}>;
+/**
+ * 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 declare function parseEnvironmentTypeEnum(value: unknown): EnvironmentTypeEnum;
+/**
+ * Create environment schema
+ * Used for creating new environments
+ */
+export declare const CreateEnvironmentSchema: import("@sinclair/typebox").TObject<{
+    project_id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    slug: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TEnum<typeof EnvironmentTypeEnum>;
+}>;
+/**
+ * Update environment schema
+ * Used for updating existing environments
+ */
+export declare const UpdateEnvironmentSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TEnum<typeof 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/dist/modules/environment/schemas.js

@@ -0,0 +1,57 @@
+import { EnvironmentTypeEnum } from "@teardown/types";
+import { t } from "elysia";
+/**
+ * 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 = 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(),
+});
+/**
+ * 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) {
+    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 = t.Object({
+    project_id: t.String({ format: "uuid" }),
+    name: t.String({ minLength: 1 }),
+    slug: t.String({ minLength: 1 }),
+    type: t.Enum(EnvironmentTypeEnum),
+});
+/**
+ * Update environment schema
+ * Used for updating existing environments
+ */
+export const UpdateEnvironmentSchema = t.Object({
+    name: t.String({ minLength: 1 }),
+    type: t.Enum(EnvironmentTypeEnum),
+});

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

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

package/dist/modules/events/index.js

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

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

@@ -0,0 +1,138 @@
+import { type Static } from "elysia";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+/**
+ * Event type enum
+ */
+export declare const EventTypeEnum: readonly ["action", "screen_view", "custom"];
+export type EventType = (typeof EventTypeEnum)[number];
+/**
+ * Single event schema
+ */
+export declare const EventSchema: import("@sinclair/typebox").TObject<{
+    /**
+     * Name of the event (required)
+     */
+    event_name: import("@sinclair/typebox").TString;
+    /**
+     * Type of event
+     */
+    event_type: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"action">, import("@sinclair/typebox").TLiteral<"screen_view">, import("@sinclair/typebox").TLiteral<"custom">]>;
+    /**
+     * Custom properties for the event (optional)
+     */
+    properties: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    /**
+     * Client-side timestamp (optional, defaults to server time)
+     */
+    timestamp: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    /**
+     * Session ID (optional, can come from header)
+     */
+    session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    /**
+     * Device ID (optional, can come from header)
+     */
+    device_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type Event = Static<typeof EventSchema>;
+/**
+ * Batch events request schema
+ * Accepts 1-100 events per request
+ */
+export declare const EventsRequestSchema: import("@sinclair/typebox").TObject<{
+    /**
+     * Array of events to ingest (1-100)
+     */
+    events: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /**
+         * Name of the event (required)
+         */
+        event_name: import("@sinclair/typebox").TString;
+        /**
+         * Type of event
+         */
+        event_type: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"action">, import("@sinclair/typebox").TLiteral<"screen_view">, import("@sinclair/typebox").TLiteral<"custom">]>;
+        /**
+         * Custom properties for the event (optional)
+         */
+        properties: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+        /**
+         * Client-side timestamp (optional, defaults to server time)
+         */
+        timestamp: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        /**
+         * Session ID (optional, can come from header)
+         */
+        session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        /**
+         * Device ID (optional, can come from header)
+         */
+        device_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+    /**
+     * Session ID (optional, applies to all events if not specified per-event)
+     */
+    session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    /**
+     * Device ID (optional, applies to all events if not specified per-event)
+     */
+    device_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type EventsRequest = Static<typeof EventsRequestSchema>;
+/**
+ * Events response schema
+ */
+export declare const EventsResponseSchema: import("@sinclair/typebox").TObject<{
+    success: import("@sinclair/typebox").TLiteral<true>;
+    data: import("@sinclair/typebox").TObject<{
+        /**
+         * IDs of created events
+         */
+        event_ids: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        /**
+         * Number of successfully processed events
+         */
+        processed_count: import("@sinclair/typebox").TNumber;
+        /**
+         * Number of failed events
+         */
+        failed_count: import("@sinclair/typebox").TNumber;
+    }>;
+}>;
+export type EventsResponse = Static<typeof EventsResponseSchema>;
+/**
+ * Events error response schema
+ */
+export declare const EventsErrorResponseSchema: import("@sinclair/typebox").TObject<{
+    success: import("@sinclair/typebox").TLiteral<false>;
+    error: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"MISSING_ORG_ID">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"MISSING_PROJECT_ID">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"MISSING_ENVIRONMENT_SLUG">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"MISSING_DEVICE_ID">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"EVENTS_PROCESSING_FAILED">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"INVALID_SESSION">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"INVALID_DEVICE">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"BATCH_SIZE_EXCEEDED">;
+        message: import("@sinclair/typebox").TString;
+    }>, import("@sinclair/typebox").TObject<{
+        code: import("@sinclair/typebox").TLiteral<"VALIDATION_ERROR">;
+        message: import("@sinclair/typebox").TString;
+    }>]>;
+}>;
+export type EventsErrorResponse = Static<typeof EventsErrorResponseSchema>;
+export type _CheckEventRow = AssertTrue<AssertSchemaCompatibleWithRow<Event, "events">>;

package/dist/modules/events/schemas.js

@@ -0,0 +1,116 @@
+import { t } from "elysia";
+/**
+ * Event type enum
+ */
+export const EventTypeEnum = ["action", "screen_view", "custom"];
+/**
+ * Single event schema
+ */
+export const EventSchema = t.Object({
+    /**
+     * Name of the event (required)
+     */
+    event_name: t.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" }),
+    /**
+     * Custom properties for the event (optional)
+     */
+    properties: t.Optional(t.Record(t.String(), t.Unknown())),
+    /**
+     * Client-side timestamp (optional, defaults to server time)
+     */
+    timestamp: t.Optional(t.String()),
+    /**
+     * Session ID (optional, can come from header)
+     */
+    session_id: t.Optional(t.String({ format: "uuid" })),
+    /**
+     * Device ID (optional, can come from header)
+     */
+    device_id: t.Optional(t.String()),
+});
+/**
+ * Batch events request schema
+ * Accepts 1-100 events per request
+ */
+export const EventsRequestSchema = t.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" }),
+    /**
+     * Session ID (optional, applies to all events if not specified per-event)
+     */
+    session_id: t.Optional(t.String({ format: "uuid" })),
+    /**
+     * Device ID (optional, applies to all events if not specified per-event)
+     */
+    device_id: t.Optional(t.String()),
+});
+/**
+ * Events response schema
+ */
+export const EventsResponseSchema = t.Object({
+    success: t.Literal(true),
+    data: t.Object({
+        /**
+         * IDs of created events
+         */
+        event_ids: t.Array(t.String()),
+        /**
+         * Number of successfully processed events
+         */
+        processed_count: t.Number(),
+        /**
+         * Number of failed events
+         */
+        failed_count: t.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(),
+        }),
+        t.Object({
+            code: t.Literal("MISSING_PROJECT_ID"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("MISSING_ENVIRONMENT_SLUG"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("MISSING_DEVICE_ID"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("EVENTS_PROCESSING_FAILED"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("INVALID_SESSION"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("INVALID_DEVICE"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("BATCH_SIZE_EXCEEDED"),
+            message: t.String(),
+        }),
+        t.Object({
+            code: t.Literal("VALIDATION_ERROR"),
+            message: t.String(),
+        }),
+    ]),
+});

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

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

package/dist/modules/identify/index.js

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