@teardown/schemas 0.1.0 → 0.1.2

package/dist/modules/orgs/schemas.js

@@ -1,8 +1,8 @@
+import { Type } from "@sinclair/typebox";
 import { OrgRoleTypeEnum, OrgTypeEnum } from "@teardown/types";
-import { t } from "elysia";
 import { SlugSchema, } from "../../common";
-export const OrgHeadersSchema = t.Object({
-    "td-org-id": t.String(),
+export const OrgHeadersSchema = Type.Object({
+    "td-org-id": Type.String(),
 });
 /**
  * Helper to check if role is admin or owner
@@ -58,79 +58,79 @@ export function parseOrgTypeEnum(value) {
             throw new Error(`Invalid OrgTypeEnum value: ${value}. Expected one of: ${Object.values(OrgTypeEnum).join(", ")}`);
     }
 }
-export const OrgSlugOrIdParamsSchema = t.Object({
-    org_id_or_slug: t.String(),
+export const OrgSlugOrIdParamsSchema = Type.Object({
+    org_id_or_slug: Type.String(),
 });
-export const OrgIdParamsSchema = t.Object({
-    org_id: t.String(),
+export const OrgIdParamsSchema = Type.Object({
+    org_id: Type.String(),
 });
-export const OrgSlugParamsSchema = t.Object({
+export const OrgSlugParamsSchema = Type.Object({
 // org_slug: SlugSchema,
 });
 /**
  * Base org schema
  * Represents organisation table structure
  */
-export const OrgSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    name: t.String({ minLength: 1 }),
+export const OrgSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    name: Type.String({ minLength: 1 }),
     slug: SlugSchema,
-    type: t.Enum(OrgTypeEnum),
-    created_at: t.String(),
-    updated_at: t.String(),
+    type: Type.Enum(OrgTypeEnum),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Org role schema
  * Represents organisation_role table structure
  */
-export const OrgRoleSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    org_id: t.String({ format: "uuid" }),
-    user_id: t.String({ format: "uuid" }),
-    role: t.Enum(OrgRoleTypeEnum),
-    created_at: t.String(),
-    updated_at: t.String(),
+export const OrgRoleSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    org_id: Type.String({ format: "uuid" }),
+    user_id: Type.String({ format: "uuid" }),
+    role: Type.Enum(OrgRoleTypeEnum),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Extended org role with org name
  * Used for user's org list
  */
-export const OrgRoleWithOrgSchema = t.Composite([
+export const OrgRoleWithOrgSchema = Type.Composite([
     OrgRoleSchema,
-    t.Object({
-        org_id: t.String({ format: "uuid" }),
-        org_name: t.String(),
+    Type.Object({
+        org_id: Type.String({ format: "uuid" }),
+        org_name: Type.String(),
         org_slug: SlugSchema,
     }),
 ]);
 /**
  * Create org request schema
  */
-export const CreateOrgSchema = t.Object({
-    name: t.String({ minLength: 1, maxLength: 255 }),
+export const CreateOrgSchema = Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 255 }),
     slug: SlugSchema,
-    type: t.Enum(OrgTypeEnum),
+    type: Type.Enum(OrgTypeEnum),
 });
 /**
  * Update org request schema
  */
-export const UpdateOrgSchema = t.Object({
-    name: t.Optional(t.String({ minLength: 1, maxLength: 255 })),
+export const UpdateOrgSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
 });
 /**
  * Add org role request schema
  */
-export const AddOrgRoleSchema = t.Object({
-    org_id: t.String({ format: "uuid" }),
-    user_id: t.String({ format: "uuid" }),
-    role: t.Enum(OrgRoleTypeEnum),
+export const AddOrgRoleSchema = Type.Object({
+    org_id: Type.String({ format: "uuid" }),
+    user_id: Type.String({ format: "uuid" }),
+    role: Type.Enum(OrgRoleTypeEnum),
 });
 /**
  * Single org response schema
  */
-export const OrgResponseSchema = t.Object({
-    success: t.Literal(true),
-    data: t.Object({
+export const OrgResponseSchema = Type.Object({
+    success: Type.Literal(true),
+    data: Type.Object({
         org: OrgRoleWithOrgSchema,
     }),
 });
@@ -138,77 +138,77 @@ export const OrgResponseSchema = t.Object({
  * Org error response schema
  * Discriminated union by error code
  */
-export const OrgErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("UNKNOWN_ERROR"),
-        message: t.String(),
+export const OrgErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("UNKNOWN_ERROR"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("VALIDATION_ERROR"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("VALIDATION_ERROR"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("ORG_ID_MISMATCH"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ORG_ID_MISMATCH"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("ORG_NOT_FOUND"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ORG_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("ORG_ROLE_NOT_FOUND"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ORG_ROLE_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("USER_NOT_IN_ORG"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("USER_NOT_IN_ORG"),
+        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("UNAUTHORIZED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("UNAUTHORIZED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("INVALID_ROLE"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("INVALID_ROLE"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("ORG_ID_REQUIRED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ORG_ID_REQUIRED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("SLUG_ALREADY_EXISTS"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("SLUG_ALREADY_EXISTS"),
+        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("CREATE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("CREATE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("UPDATE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("UPDATE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("DELETE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("DELETE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("ROLE_CREATION_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ROLE_CREATION_FAILED"),
+        message: Type.String(),
     }),
 ]);
 /**
  * Org error response wrapper
  */
-export const OrgErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const OrgErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: OrgErrorSchema,
 });
-export const OrgRequestResponseSchema = t.Union([OrgResponseSchema, OrgErrorResponseSchema]);
+export const OrgRequestResponseSchema = Type.Union([OrgResponseSchema, OrgErrorResponseSchema]);

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

@@ -1,4 +1,4 @@
-import { type Static } from "elysia";
+import { type Static } from "@sinclair/typebox";
 import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
 /**
  * Base persona schema

package/dist/modules/personas/schemas.js

@@ -1,100 +1,100 @@
-import { t } from "elysia";
+import { Type } from "@sinclair/typebox";
 /**
  * Base persona schema
  * Represents personas table structure
  */
-export const PersonaSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    environment_id: t.String({ format: "uuid" }),
-    user_id: t.Union([t.String(), t.Null()]),
-    name: t.Union([t.String(), t.Null()]),
-    email: t.Union([t.String({ format: "email" }), t.Null()]),
-    created_at: t.String(),
-    updated_at: t.String(),
+export const PersonaSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    environment_id: Type.String({ format: "uuid" }),
+    user_id: Type.Union([Type.String(), Type.Null()]),
+    name: Type.Union([Type.String(), Type.Null()]),
+    email: Type.Union([Type.String({ format: "email" }), Type.Null()]),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
 /**
  * Persona params schema
  */
-export const PersonaParamsSchema = t.Object({
-    persona_id: t.String({ format: "uuid" }),
+export const PersonaParamsSchema = Type.Object({
+    persona_id: Type.String({ format: "uuid" }),
 });
 /**
  * Search personas query schema
  * Supports pagination, search, and sorting
  */
-export const SearchPersonasQuerySchema = 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("name"), t.Literal("email")], {
+export const SearchPersonasQuerySchema = 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("email")], {
         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 personas query schema without project_id (injected from headers)
  */
-export const SearchPersonasQueryParamsSchema = t.Omit(SearchPersonasQuerySchema, ["project_id"]);
+export const SearchPersonasQueryParamsSchema = Type.Omit(SearchPersonasQuerySchema, ["project_id"]);
 /**
  * Personas by IDs request schema
  */
-export const PersonasByIdsSchema = t.Object({
-    persona_ids: t.Array(t.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+export const PersonasByIdsSchema = Type.Object({
+    persona_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
 });
 /**
  * Paginated personas response schema
  */
-export const PersonasResponseSchema = t.Object({
-    personas: t.Array(PersonaSchema),
-    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 PersonasResponseSchema = Type.Object({
+    personas: Type.Array(PersonaSchema),
+    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 persona response schema
  */
-export const PersonaResponseSchema = t.Object({
-    success: t.Literal(true),
+export const PersonaResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: PersonaSchema,
 });
 /**
  * Persona error response schema
  * Discriminated union by error code
  */
-export const PersonaErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("PERSONA_NOT_FOUND"),
-        message: t.String(),
+export const PersonaErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("PERSONA_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(),
     }),
 ]);
 /**
  * Persona error response wrapper
  */
-export const PersonaErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const PersonaErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: PersonaErrorSchema,
 });
 /**
  * Persona request response schema
  */
-export const PersonaRequestResponseSchema = t.Union([PersonaResponseSchema, PersonaErrorResponseSchema]);
+export const PersonaRequestResponseSchema = Type.Union([PersonaResponseSchema, PersonaErrorResponseSchema]);

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

@@ -1,5 +1,5 @@
+import { type Static } from "@sinclair/typebox";
 import { ProjectStatusEnum, ProjectTypeEnum } from "@teardown/types";
-import { type Static } from "elysia";
 import { type AssertSchemaCompatibleWithInsert, type AssertSchemaCompatibleWithRow, type AssertSchemaCompatibleWithUpdate, type AssertTrue } from "../../common";
 /**
  * Parse and validate a ProjectTypeEnum value

package/dist/modules/projects/schemas.js

@@ -1,5 +1,5 @@
+import { Type } from "@sinclair/typebox";
 import { ProjectStatusEnum, ProjectTypeEnum } from "@teardown/types";
-import { t } from "elysia";
 import { SlugSchema, } from "../../common";
 /**
  * Parse and validate a ProjectTypeEnum value
@@ -43,103 +43,103 @@ export function parseProjectStatusEnum(value) {
  * Base project schema
  * Represents projects table structure
  */
-export const ProjectSchema = t.Object({
-    id: t.String({ format: "uuid" }),
-    org_id: t.String({ format: "uuid" }),
-    name: t.String({ minLength: 1 }),
+export const ProjectSchema = Type.Object({
+    id: Type.String({ format: "uuid" }),
+    org_id: Type.String({ format: "uuid" }),
+    name: Type.String({ minLength: 1 }),
     slug: SlugSchema,
-    type: t.Enum(ProjectTypeEnum),
-    status: t.Enum(ProjectStatusEnum),
-    created_at: t.String(),
-    updated_at: t.String(),
+    type: Type.Enum(ProjectTypeEnum),
+    status: Type.Enum(ProjectStatusEnum),
+    created_at: Type.String(),
+    updated_at: Type.String(),
 });
-export const ProjectParamsSchema = t.Object({
-    project_id_or_slug: t.String(),
+export const ProjectParamsSchema = Type.Object({
+    project_id_or_slug: Type.String(),
 });
 /**
  * Create project request schema
  */
-export const CreateProjectSchema = t.Object({
-    name: t.String({ minLength: 1, maxLength: 255 }),
+export const CreateProjectSchema = Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 255 }),
     slug: SlugSchema,
-    type: t.Enum(ProjectTypeEnum),
-    org_id: t.String(),
+    type: Type.Enum(ProjectTypeEnum),
+    org_id: Type.String(),
 });
 /**
  * Update project request schema
  */
-export const UpdateProjectSchema = t.Object({
-    name: t.Optional(t.String({ minLength: 1, maxLength: 255 })),
-    slug: t.Optional(SlugSchema),
+export const UpdateProjectSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+    slug: Type.Optional(SlugSchema),
 });
 /**
  * Single project response schema
  */
-export const ProjectResponseSchema = t.Object({
-    success: t.Literal(true),
+export const ProjectResponseSchema = Type.Object({
+    success: Type.Literal(true),
     data: ProjectSchema,
 });
 /**
  * Multiple projects response schema
  */
-export const ProjectsResponseSchema = t.Object({
-    projects: t.Array(ProjectSchema),
+export const ProjectsResponseSchema = Type.Object({
+    projects: Type.Array(ProjectSchema),
 });
 /**
  * Project error response schema
  * Discriminated union by error code
  */
-export const ProjectErrorSchema = t.Union([
-    t.Object({
-        code: t.Literal("PROJECT_NOT_FOUND"),
-        message: t.String(),
+export const ProjectErrorSchema = Type.Union([
+    Type.Object({
+        code: Type.Literal("PROJECT_NOT_FOUND"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("PROJECT_NOT_IN_ORG"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("PROJECT_NOT_IN_ORG"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("INVALID_SLUG"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("INVALID_SLUG"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("SLUG_ALREADY_EXISTS"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("SLUG_ALREADY_EXISTS"),
+        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("CREATE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("CREATE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("UPDATE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("UPDATE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("DELETE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("DELETE_FAILED"),
+        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("ARCHIVE_FAILED"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("ARCHIVE_FAILED"),
+        message: Type.String(),
     }),
-    t.Object({
-        code: t.Literal("INVALID_REQUEST"),
-        message: t.String(),
+    Type.Object({
+        code: Type.Literal("INVALID_REQUEST"),
+        message: Type.String(),
     }),
 ]);
 /**
  * Project error response wrapper
  */
-export const ProjectErrorResponseSchema = t.Object({
-    success: t.Literal(false),
+export const ProjectErrorResponseSchema = Type.Object({
+    success: Type.Literal(false),
     error: ProjectErrorSchema,
 });
-export const ProjectRequestResponseSchema = t.Union([ProjectResponseSchema, ProjectErrorResponseSchema]);
+export const ProjectRequestResponseSchema = Type.Union([ProjectResponseSchema, ProjectErrorResponseSchema]);