@teardown/schemas 0.1.21 → 0.1.23

package/src/modules/me/schemas.ts

@@ -0,0 +1,87 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { OrgRoleWithOrgSchema } from "../orgs/schemas";
+
+/**
+ * User schema
+ * Represents Supabase Auth user structure
+ */
+export const UserSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	email: Type.Optional(Type.String({ format: "email" })),
+	app_metadata: Type.Record(Type.String(), Type.Unknown()),
+	user_metadata: Type.Record(Type.String(), Type.Unknown()),
+	created_at: Type.String(),
+
+	// id: string
+	// app_metadata: UserAppMetadata
+	// user_metadata: UserMetadata
+	// aud: string
+	// confirmation_sent_at?: string
+	// recovery_sent_at?: string
+	// email_change_sent_at?: string
+	// new_email?: string
+	// new_phone?: string
+	// invited_at?: string
+	// action_link?: string
+	// email?: string
+	// phone?: string
+	// created_at: string
+	// confirmed_at?: string
+	// email_confirmed_at?: string
+	// phone_confirmed_at?: string
+	// last_sign_in_at?: string
+	// role?: string
+	// updated_at?: string
+	// identities?: UserIdentity[]
+	// is_anonymous?: boolean
+	// is_sso_user?: boolean
+	// factors?: (Factor<FactorType, 'verified'> | Factor<FactorType, 'unverified'>)[]
+	// deleted_at?: string
+});
+export type User = Static<typeof UserSchema>;
+
+/**
+ * Me response schema
+ */
+export const MeResponseSchema = Type.Object({
+	user: UserSchema,
+});
+export type MeResponse = Static<typeof MeResponseSchema>;
+
+/**
+ * Me orgs response schema
+ * Reuses OrgRoleWithOrgSchema from orgs module
+ */
+export const MeOrgsResponseSchema = Type.Object({
+	orgs: Type.Array(OrgRoleWithOrgSchema),
+});
+export type MeOrgsResponse = Static<typeof MeOrgsResponseSchema>;
+
+/**
+ * Me error response schema
+ * Discriminated union by error code
+ */
+export const MeErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("UNAUTHORIZED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("USER_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+]);
+export type MeError = Static<typeof MeErrorSchema>;
+
+/**
+ * Me error response wrapper
+ */
+export const MeErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: MeErrorSchema,
+});
+export type MeErrorResponse = Static<typeof MeErrorResponseSchema>;

package/src/modules/orgs/schemas.ts

@@ -0,0 +1,260 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { OrgRoleTypeEnum, OrgTypeEnum } from "@teardown/types";
+import {
+	type AssertSchemaCompatibleWithInsert,
+	type AssertSchemaCompatibleWithRow,
+	type AssertSchemaCompatibleWithUpdate,
+	type AssertTrue,
+	SlugSchema,
+} from "../../common";
+
+export const OrgHeadersSchema = Type.Object({
+	"td-org-id": Type.String(),
+});
+export type OrgHeaders = Static<typeof OrgHeadersSchema>;
+
+/**
+ * Helper to check if role is admin or owner
+ */
+export function isAdminRole(role: string): boolean {
+	return role === OrgRoleTypeEnum.OWNER || role === OrgRoleTypeEnum.ADMIN;
+}
+
+/**
+ * Helper to check if role is owner
+ */
+export function isOwnerRole(role: string): boolean {
+	return role === OrgRoleTypeEnum.OWNER;
+}
+
+/**
+ * Parse and validate an OrgRoleTypeEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated OrgRoleTypeEnum value
+ * @throws Error if the value is not a valid OrgRoleTypeEnum
+ */
+export function parseOrgRoleTypeEnum(value: unknown): OrgRoleTypeEnum {
+	switch (value) {
+		case OrgRoleTypeEnum.OWNER:
+			return OrgRoleTypeEnum.OWNER;
+		case OrgRoleTypeEnum.ADMIN:
+			return OrgRoleTypeEnum.ADMIN;
+		case OrgRoleTypeEnum.ENGINEER:
+			return OrgRoleTypeEnum.ENGINEER;
+		default:
+			throw new Error(
+				`Invalid OrgRoleTypeEnum value: ${value}. Expected one of: ${Object.values(OrgRoleTypeEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Parse and validate an OrgTypeEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated OrgTypeEnum value
+ * @throws Error if the value is not a valid OrgTypeEnum
+ */
+export function parseOrgTypeEnum(value: unknown): OrgTypeEnum {
+	switch (value) {
+		case OrgTypeEnum.PERSONAL:
+			return OrgTypeEnum.PERSONAL;
+		case OrgTypeEnum.START_UP:
+			return OrgTypeEnum.START_UP;
+		case OrgTypeEnum.SCALE_UP:
+			return OrgTypeEnum.SCALE_UP;
+		case OrgTypeEnum.AGENCY:
+			return OrgTypeEnum.AGENCY;
+		case OrgTypeEnum.ENTERPRISE:
+			return OrgTypeEnum.ENTERPRISE;
+		default:
+			throw new Error(`Invalid OrgTypeEnum value: ${value}. Expected one of: ${Object.values(OrgTypeEnum).join(", ")}`);
+	}
+}
+
+export const OrgSlugOrIdParamsSchema = Type.Object({
+	org_id_or_slug: Type.String(),
+});
+export type OrgSlugOrIdParams = Static<typeof OrgSlugOrIdParamsSchema>;
+
+export const OrgIdParamsSchema = Type.Object({
+	org_id: Type.String(),
+});
+export type OrgIdParams = Static<typeof OrgIdParamsSchema>;
+
+export const OrgSlugParamsSchema = Type.Object({
+	// org_slug: SlugSchema,
+});
+export type OrgSlugParams = Static<typeof OrgSlugParamsSchema>;
+
+/**
+ * Base org schema
+ * Represents organisation table structure
+ */
+export const OrgSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	name: Type.String({ minLength: 1 }),
+	slug: SlugSchema,
+	type: Type.Enum(OrgTypeEnum),
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type Org = Static<typeof OrgSchema>;
+
+/**
+ * Org role schema
+ * Represents organisation_role table structure
+ */
+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(),
+});
+export type OrgRole = Static<typeof OrgRoleSchema>;
+
+/**
+ * Extended org role with org name
+ * Used for user's org list
+ */
+export const OrgRoleWithOrgSchema = Type.Composite([
+	OrgRoleSchema,
+	Type.Object({
+		org_id: Type.String({ format: "uuid" }),
+		org_name: Type.String(),
+		org_slug: SlugSchema,
+	}),
+]);
+export type OrgRoleWithOrg = Static<typeof OrgRoleWithOrgSchema>;
+
+/**
+ * Create org request schema
+ */
+export const CreateOrgSchema = Type.Object({
+	name: Type.String({ minLength: 1, maxLength: 255 }),
+	slug: SlugSchema,
+	type: Type.Enum(OrgTypeEnum),
+});
+export type CreateOrg = Static<typeof CreateOrgSchema>;
+
+/**
+ * Update org request schema
+ */
+export const UpdateOrgSchema = Type.Object({
+	name: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+});
+export type UpdateOrg = Static<typeof UpdateOrgSchema>;
+
+/**
+ * Add org role request schema
+ */
+export const AddOrgRoleSchema = Type.Object({
+	org_id: Type.String({ format: "uuid" }),
+	user_id: Type.String({ format: "uuid" }),
+	role: Type.Enum(OrgRoleTypeEnum),
+});
+export type AddOrgRole = Static<typeof AddOrgRoleSchema>;
+
+/**
+ * Single org response schema
+ */
+export const OrgResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: Type.Object({
+		org: OrgRoleWithOrgSchema,
+	}),
+});
+export type OrgResponse = Static<typeof OrgResponseSchema>;
+
+/**
+ * Org error response schema
+ * Discriminated union by error code
+ */
+export const OrgErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("UNKNOWN_ERROR"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("VALIDATION_ERROR"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ORG_ID_MISMATCH"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ORG_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ORG_ROLE_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("USER_NOT_IN_ORG"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FORBIDDEN"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("UNAUTHORIZED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_ROLE"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ORG_ID_REQUIRED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("SLUG_ALREADY_EXISTS"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CREATE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("UPDATE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("DELETE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ROLE_CREATION_FAILED"),
+		message: Type.String(),
+	}),
+]);
+export type OrgError = Static<typeof OrgErrorSchema>;
+
+/**
+ * Org error response wrapper
+ */
+export const OrgErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: OrgErrorSchema,
+});
+export type OrgErrorResponse = Static<typeof OrgErrorResponseSchema>;
+
+export const OrgRequestResponseSchema = Type.Union([OrgResponseSchema, OrgErrorResponseSchema]);
+export type OrgRequestResponse = Static<typeof OrgRequestResponseSchema>;
+
+export type _CheckOrgRow = AssertTrue<AssertSchemaCompatibleWithRow<Org, "orgs">>;
+export type _CheckCreateOrg = AssertTrue<AssertSchemaCompatibleWithInsert<CreateOrg, "orgs">>;
+export type _CheckUpdateOrg = AssertTrue<AssertSchemaCompatibleWithUpdate<UpdateOrg, "orgs">>;
+export type _CheckOrgRoleRow = AssertTrue<AssertSchemaCompatibleWithRow<OrgRole, "org_roles">>;
+export type _CheckAddOrgRole = AssertTrue<AssertSchemaCompatibleWithInsert<AddOrgRole, "org_roles">>;

package/src/modules/personas/schemas.ts

@@ -0,0 +1,123 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Base persona schema
+ * Represents personas table structure
+ */
+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(),
+});
+export type Persona = Static<typeof PersonaSchema>;
+
+/**
+ * Persona params schema
+ */
+export const PersonaParamsSchema = Type.Object({
+	persona_id: Type.String({ format: "uuid" }),
+});
+export type PersonaParams = Static<typeof PersonaParamsSchema>;
+
+/**
+ * Search personas query schema
+ * Supports pagination, search, and sorting
+ */
+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: Type.Union([Type.Literal("asc"), Type.Literal("desc")], { default: "desc" }),
+});
+export type SearchPersonasQuery = Static<typeof SearchPersonasQuerySchema>;
+
+/**
+ * Search personas query schema without project_id (injected from headers)
+ */
+export const SearchPersonasQueryParamsSchema = Type.Omit(SearchPersonasQuerySchema, ["project_id"]);
+export type SearchPersonasQueryParams = Static<typeof SearchPersonasQueryParamsSchema>;
+
+/**
+ * Personas by IDs request schema
+ */
+export const PersonasByIdsSchema = Type.Object({
+	persona_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type PersonasByIds = Static<typeof PersonasByIdsSchema>;
+
+/**
+ * Paginated personas response schema
+ */
+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 }),
+	}),
+});
+export type PersonasResponse = Static<typeof PersonasResponseSchema>;
+
+/**
+ * Single persona response schema
+ */
+export const PersonaResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: PersonaSchema,
+});
+export type PersonaResponse = Static<typeof PersonaResponseSchema>;
+
+/**
+ * Persona error response schema
+ * Discriminated union by error code
+ */
+export const PersonaErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("PERSONA_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 PersonaError = Static<typeof PersonaErrorSchema>;
+
+/**
+ * Persona error response wrapper
+ */
+export const PersonaErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: PersonaErrorSchema,
+});
+export type PersonaErrorResponse = Static<typeof PersonaErrorResponseSchema>;
+
+/**
+ * Persona request response schema
+ */
+export const PersonaRequestResponseSchema = Type.Union([PersonaResponseSchema, PersonaErrorResponseSchema]);
+export type PersonaRequestResponse = Static<typeof PersonaRequestResponseSchema>;
+
+export type _CheckPersonaRow = AssertTrue<AssertSchemaCompatibleWithRow<Persona, "personas">>;

package/src/modules/projects/schemas.ts

@@ -0,0 +1,179 @@
+import { type Static, Type } from "@sinclair/typebox";
+import { ProjectStatusEnum, ProjectTypeEnum } from "@teardown/types";
+import {
+	type AssertSchemaCompatibleWithInsert,
+	type AssertSchemaCompatibleWithRow,
+	type AssertSchemaCompatibleWithUpdate,
+	type AssertTrue,
+	SlugSchema,
+} from "../../common";
+
+/**
+ * Parse and validate a ProjectTypeEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated ProjectTypeEnum value
+ * @throws Error if the value is not a valid ProjectTypeEnum
+ */
+export function parseProjectTypeEnum(value: unknown): ProjectTypeEnum {
+	switch (value) {
+		case ProjectTypeEnum.REACT_NATIVE:
+			return ProjectTypeEnum.REACT_NATIVE;
+		case ProjectTypeEnum.EXPO:
+			return ProjectTypeEnum.EXPO;
+		default:
+			throw new Error(
+				`Invalid ProjectTypeEnum value: ${value}. Expected one of: ${Object.values(ProjectTypeEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Parse and validate a ProjectStatusEnum value
+ * Uses a switch statement to ensure type safety and runtime validation
+ * @param value - The value to parse
+ * @returns The validated ProjectStatusEnum value
+ * @throws Error if the value is not a valid ProjectStatusEnum
+ */
+export function parseProjectStatusEnum(value: unknown): ProjectStatusEnum {
+	switch (value) {
+		case ProjectStatusEnum.PENDING_SETUP:
+			return ProjectStatusEnum.PENDING_SETUP;
+		case ProjectStatusEnum.ACTIVE:
+			return ProjectStatusEnum.ACTIVE;
+		case ProjectStatusEnum.PAUSED:
+			return ProjectStatusEnum.PAUSED;
+		case ProjectStatusEnum.ARCHIVED:
+			return ProjectStatusEnum.ARCHIVED;
+		default:
+			throw new Error(
+				`Invalid ProjectStatusEnum value: ${value}. Expected one of: ${Object.values(ProjectStatusEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Base project schema
+ * Represents projects table structure
+ */
+export const ProjectSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	org_id: Type.String({ format: "uuid" }),
+	name: Type.String({ minLength: 1 }),
+	slug: SlugSchema,
+	type: Type.Enum(ProjectTypeEnum),
+	status: Type.Enum(ProjectStatusEnum),
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type Project = Static<typeof ProjectSchema>;
+
+export const ProjectParamsSchema = Type.Object({
+	project_id_or_slug: Type.String(),
+});
+export type ProjectParams = Static<typeof ProjectParamsSchema>;
+
+/**
+ * Create project request schema
+ */
+export const CreateProjectSchema = Type.Object({
+	name: Type.String({ minLength: 1, maxLength: 255 }),
+	slug: SlugSchema,
+	type: Type.Enum(ProjectTypeEnum),
+	org_id: Type.String(),
+});
+export type CreateProject = Static<typeof CreateProjectSchema>;
+
+/**
+ * Update project request schema
+ */
+export const UpdateProjectSchema = Type.Object({
+	name: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+	slug: Type.Optional(SlugSchema),
+});
+export type UpdateProject = Static<typeof UpdateProjectSchema>;
+
+/**
+ * Single project response schema
+ */
+export const ProjectResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: ProjectSchema,
+});
+export type ProjectResponse = Static<typeof ProjectResponseSchema>;
+
+/**
+ * Multiple projects response schema
+ */
+export const ProjectsResponseSchema = Type.Object({
+	projects: Type.Array(ProjectSchema),
+});
+export type ProjectsResponse = Static<typeof ProjectsResponseSchema>;
+
+/**
+ * Project error response schema
+ * Discriminated union by error code
+ */
+export const ProjectErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("PROJECT_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("PROJECT_NOT_IN_ORG"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_SLUG"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("SLUG_ALREADY_EXISTS"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FORBIDDEN"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CREATE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("UPDATE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("DELETE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("FETCH_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ARCHIVE_FAILED"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVALID_REQUEST"),
+		message: Type.String(),
+	}),
+]);
+export type ProjectError = Static<typeof ProjectErrorSchema>;
+
+/**
+ * Project error response wrapper
+ */
+export const ProjectErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: ProjectErrorSchema,
+});
+export type ProjectErrorResponse = Static<typeof ProjectErrorResponseSchema>;
+
+export const ProjectRequestResponseSchema = Type.Union([ProjectResponseSchema, ProjectErrorResponseSchema]);
+export type ProjectRequestResponse = Static<typeof ProjectRequestResponseSchema>;
+
+export type _CheckProjectRow = AssertTrue<AssertSchemaCompatibleWithRow<Project, "projects">>;
+export type _CheckCreateProject = AssertTrue<AssertSchemaCompatibleWithInsert<CreateProject, "projects">>;
+export type _CheckUpdateProject = AssertTrue<AssertSchemaCompatibleWithUpdate<UpdateProject, "projects">>;