@teardown/schemas 0.1.40 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/schemas",
-	"version": "0.1.40",
+	"version": "0.1.43",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
@@ -48,10 +48,10 @@
 			"import": "./src/modules/orgs/index.ts",
 			"default": "./src/modules/orgs/index.ts"
 		},
-		"./personas": {
-			"types": "./src/modules/personas/index.ts",
-			"import": "./src/modules/personas/index.ts",
-			"default": "./src/modules/personas/index.ts"
+		"./project-users": {
+			"types": "./src/modules/project-users/index.ts",
+			"import": "./src/modules/project-users/index.ts",
+			"default": "./src/modules/project-users/index.ts"
 		},
 		"./projects": {
 			"types": "./src/modules/projects/index.ts",
@@ -93,14 +93,14 @@
 	},
 	"dependencies": {
 		"@sinclair/typebox": "^0.34.41",
-		"@teardown/types": "0.1.40"
+		"@teardown/types": "0.1.43"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.3.7",
-		"@teardown/tsconfig": "0.1.40",
-		"typescript": "^5.9.3"
+		"@biomejs/biome": "2.3.8",
+		"@teardown/tsconfig": "0.1.43",
+		"typescript": "5.9.3"
 	},
 	"peerDependencies": {
-		"typescript": "^5.9.3"
+		"typescript": "5.9.3"
 	}
 }

package/src/index.ts

@@ -10,7 +10,7 @@ export * from "./modules/events";
 export * from "./modules/identify";
 export * from "./modules/me";
 export * from "./modules/orgs";
-export * from "./modules/personas";
+export * from "./modules/project-users";
 export * from "./modules/projects";
 export * from "./modules/sessions";
 export * from "./modules/versions";

package/src/modules/builds/schemas.ts

@@ -18,7 +18,7 @@ export const BuildSchema = Type.Object({
 	version_id: Type.String({ format: "uuid" }),
 	build_number: Type.Integer({ minimum: 0 }),
 	name: Type.Union([Type.String(), Type.Null()]),
-	summary: Type.Union([Type.String(), Type.Null()]),
+	notes: Type.Union([Type.String({ maxLength: 500 }), Type.Null()]),
 	commit_sha: Type.Union([Type.String(), Type.Null()]),
 	platform: DevicePlatformSchema,
 	status: BuildStatusSchema,
@@ -142,12 +142,14 @@ export type BuildRequestResponse = Static<typeof BuildRequestResponseSchema>;
 export type _CheckBuildRow = AssertTrue<AssertSchemaCompatibleWithRow<Build, "version_builds">>;
 
 /**
- * Update build status request body schema
+ * Update build request body schema
+ * Supports updating status and/or notes
  */
-export const UpdateBuildStatusBodySchema = Type.Object({
-	status: BuildStatusSchema,
+export const UpdateBuildBodySchema = Type.Object({
+	status: Type.Optional(BuildStatusSchema),
+	notes: Type.Optional(Type.Union([Type.String({ maxLength: 500 }), Type.Null()])),
 });
-export type UpdateBuildStatusBody = Static<typeof UpdateBuildStatusBodySchema>;
+export type UpdateBuildBody = Static<typeof UpdateBuildBodySchema>;
 
 /**
  * Add UPDATE_FAILED error code for update operations

package/src/modules/devices/schemas.ts

@@ -69,7 +69,7 @@ export function parseDevicePlatformEnum(value: unknown): DevicePlatformEnum | nu
  */
 export const DeviceSchema = Type.Object({
 	id: Type.String({ format: "uuid" }),
-	persona_id: Type.String({ format: "uuid" }),
+	user_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()]),

package/src/modules/identify/schemas.ts

@@ -114,31 +114,32 @@ export const DeviceInfoSchema = Type.Object({
 	 * Update info (optional) - not all builds will have an update
 	 */
 	update: Type.Union([DeviceUpdateInfoSchema, Type.Null()]),
-	/**
-	 * Notifications info (optional)
-	 */
-	notifications: Type.Union([NotificationsInfoSchema, Type.Null()]),
 });
 export type DeviceInfo = Static<typeof DeviceInfoSchema>;
 
 /**
- * Persona info schema (optional fields)
- * Matches personas table structure
+ * User info schema (optional fields)
+ * Matches project_users table structure
  */
-export const PersonaInfoSchema = Type.Object({
+export const UserInfoSchema = 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>;
+export type UserInfo = Static<typeof UserInfoSchema>;
+
+/** @deprecated Use UserInfoSchema instead */
+export const PersonaInfoSchema = UserInfoSchema;
+/** @deprecated Use UserInfo instead */
+export type PersonaInfo = UserInfo;
 
 /**
  * Identify request schema
- * Ties a device to a persona with optional persona data
+ * Ties a device to a user with optional user data
  */
 export const IdentifyRequestSchema = Type.Object({
 	device: DeviceInfoSchema,
-	persona: Type.Optional(PersonaInfoSchema),
+	persona: Type.Optional(UserInfoSchema),
 });
 export type IdentifyRequest = Static<typeof IdentifyRequestSchema>;
 
@@ -214,7 +215,7 @@ export const IdentifyResponseSchema = Type.Object({
 	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" }),
+		user_id: Type.String({ error: "user_id is required" }),
 		token: Type.String({ error: "token is required" }), // JWT token for session authentication
 		version_info: VersionInfoSchema,
 	}),
@@ -253,7 +254,7 @@ export const IdentifyErrorResponseSchema = Type.Object({
 			message: Type.String(),
 		}),
 		Type.Object({
-			code: Type.Literal("NO_PERSONA_ID_GENERATED"),
+			code: Type.Literal("NO_USER_ID_GENERATED"),
 			message: Type.String(),
 		}),
 	]),

package/src/modules/index.ts

@@ -6,7 +6,7 @@ export * from "./events/schemas";
 export * from "./identify/schemas";
 export * from "./me/schemas";
 export * from "./orgs/schemas";
-export * from "./personas/schemas";
+export * from "./project-users/schemas";
 export * from "./projects/schemas";
 export * from "./sessions/schemas";
 export * from "./versions/schemas";

package/src/modules/orgs/schemas.ts

@@ -1,5 +1,5 @@
 import { type Static, Type } from "@sinclair/typebox";
-import { OrgRoleTypeEnum, OrgTypeEnum } from "@teardown/types";
+import { OrgInvitationStatusEnum, OrgRoleTypeEnum, OrgTypeEnum } from "@teardown/types";
 import {
 	type AssertSchemaCompatibleWithInsert,
 	type AssertSchemaCompatibleWithRow,
@@ -158,6 +158,83 @@ export const AddOrgRoleSchema = Type.Object({
 });
 export type AddOrgRole = Static<typeof AddOrgRoleSchema>;
 
+/**
+ * Org invitation schema
+ * Represents org_invitations table structure
+ */
+export const OrgInvitationSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	org_id: Type.String({ format: "uuid" }),
+	email: Type.String({ format: "email" }),
+	role: Type.Enum(OrgRoleTypeEnum),
+	status: Type.Enum(OrgInvitationStatusEnum),
+	invited_by: Type.String({ format: "uuid" }),
+	expires_at: Type.String(),
+	created_at: Type.String(),
+	updated_at: Type.String(),
+});
+export type OrgInvitation = Static<typeof OrgInvitationSchema>;
+
+/**
+ * Parse and validate an OrgInvitationStatusEnum value
+ */
+export function parseOrgInvitationStatusEnum(value: unknown): OrgInvitationStatusEnum {
+	switch (value) {
+		case OrgInvitationStatusEnum.PENDING:
+			return OrgInvitationStatusEnum.PENDING;
+		case OrgInvitationStatusEnum.ACCEPTED:
+			return OrgInvitationStatusEnum.ACCEPTED;
+		case OrgInvitationStatusEnum.CANCELLED:
+			return OrgInvitationStatusEnum.CANCELLED;
+		case OrgInvitationStatusEnum.EXPIRED:
+			return OrgInvitationStatusEnum.EXPIRED;
+		default:
+			throw new Error(
+				`Invalid OrgInvitationStatusEnum value: ${value}. Expected one of: ${Object.values(OrgInvitationStatusEnum).join(", ")}`
+			);
+	}
+}
+
+/**
+ * Create org invitation request schema
+ */
+export const CreateOrgInvitationSchema = Type.Object({
+	email: Type.String({ format: "email" }),
+	role: Type.Enum(OrgRoleTypeEnum),
+});
+export type CreateOrgInvitation = Static<typeof CreateOrgInvitationSchema>;
+
+/**
+ * Org member with user info schema
+ * Used for displaying members in the UI
+ */
+export const OrgMemberSchema = Type.Object({
+	id: Type.String({ format: "uuid" }),
+	user_id: Type.String({ format: "uuid" }),
+	role: Type.Enum(OrgRoleTypeEnum),
+	email: Type.Union([Type.String(), Type.Null()]),
+	name: Type.Union([Type.String(), Type.Null()]),
+	avatar_url: Type.Union([Type.String(), Type.Null()]),
+	created_at: Type.String(),
+});
+export type OrgMember = Static<typeof OrgMemberSchema>;
+
+/**
+ * Update member role request schema
+ */
+export const UpdateOrgMemberRoleSchema = Type.Object({
+	role: Type.Enum(OrgRoleTypeEnum),
+});
+export type UpdateOrgMemberRole = Static<typeof UpdateOrgMemberRoleSchema>;
+
+/**
+ * Transfer ownership request schema
+ */
+export const TransferOwnershipSchema = Type.Object({
+	new_owner_user_id: Type.String({ format: "uuid" }),
+});
+export type TransferOwnership = Static<typeof TransferOwnershipSchema>;
+
 /**
  * Single org response schema
  */
@@ -238,6 +315,42 @@ export const OrgErrorSchema = Type.Union([
 		code: Type.Literal("ROLE_CREATION_FAILED"),
 		message: Type.String(),
 	}),
+	Type.Object({
+		code: Type.Literal("INVITATION_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("INVITATION_ALREADY_EXISTS"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("ALREADY_MEMBER"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CANNOT_REMOVE_OWNER"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CANNOT_INVITE_AS_OWNER"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("MEMBER_NOT_FOUND"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("NOT_OWNER"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CANNOT_LEAVE_AS_OWNER"),
+		message: Type.String(),
+	}),
+	Type.Object({
+		code: Type.Literal("CANNOT_CHANGE_OWNER_ROLE"),
+		message: Type.String(),
+	}),
 ]);
 export type OrgError = Static<typeof OrgErrorSchema>;
 

package/src/modules/project-users/schemas.ts

@@ -0,0 +1,123 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { AssertSchemaCompatibleWithRow, AssertTrue } from "../../common";
+
+/**
+ * Base project user schema
+ * Represents project_users table structure
+ */
+export const ProjectUserSchema = 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 ProjectUser = Static<typeof ProjectUserSchema>;
+
+/**
+ * Project user params schema
+ */
+export const ProjectUserParamsSchema = Type.Object({
+	user_id: Type.String({ format: "uuid" }),
+});
+export type ProjectUserParams = Static<typeof ProjectUserParamsSchema>;
+
+/**
+ * Search project users query schema
+ * Supports pagination, search, and sorting
+ */
+export const SearchProjectUsersQuerySchema = 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 SearchProjectUsersQuery = Static<typeof SearchProjectUsersQuerySchema>;
+
+/**
+ * Search project users query schema without project_id (injected from headers)
+ */
+export const SearchProjectUsersQueryParamsSchema = Type.Omit(SearchProjectUsersQuerySchema, ["project_id"]);
+export type SearchProjectUsersQueryParams = Static<typeof SearchProjectUsersQueryParamsSchema>;
+
+/**
+ * Project users by IDs request schema
+ */
+export const ProjectUsersByIdsSchema = Type.Object({
+	user_ids: Type.Array(Type.String({ format: "uuid" }), { minItems: 1, maxItems: 100 }),
+});
+export type ProjectUsersByIds = Static<typeof ProjectUsersByIdsSchema>;
+
+/**
+ * Paginated project users response schema
+ */
+export const ProjectUsersResponseSchema = Type.Object({
+	users: Type.Array(ProjectUserSchema),
+	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 ProjectUsersResponse = Static<typeof ProjectUsersResponseSchema>;
+
+/**
+ * Single project user response schema
+ */
+export const ProjectUserResponseSchema = Type.Object({
+	success: Type.Literal(true),
+	data: ProjectUserSchema,
+});
+export type ProjectUserResponse = Static<typeof ProjectUserResponseSchema>;
+
+/**
+ * Project user error response schema
+ * Discriminated union by error code
+ */
+export const ProjectUserErrorSchema = Type.Union([
+	Type.Object({
+		code: Type.Literal("USER_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 ProjectUserError = Static<typeof ProjectUserErrorSchema>;
+
+/**
+ * Project user error response wrapper
+ */
+export const ProjectUserErrorResponseSchema = Type.Object({
+	success: Type.Literal(false),
+	error: ProjectUserErrorSchema,
+});
+export type ProjectUserErrorResponse = Static<typeof ProjectUserErrorResponseSchema>;
+
+/**
+ * Project user request response schema
+ */
+export const ProjectUserRequestResponseSchema = Type.Union([ProjectUserResponseSchema, ProjectUserErrorResponseSchema]);
+export type ProjectUserRequestResponse = Static<typeof ProjectUserRequestResponseSchema>;
+
+export type _CheckProjectUserRow = AssertTrue<AssertSchemaCompatibleWithRow<ProjectUser, "project_users">>;

package/src/modules/versions/schemas.ts

@@ -43,6 +43,7 @@ export const VersionSchema = Type.Object({
 	major: Type.Number(), // Matches type number, not integer constraint (db type numeric)
 	minor: Type.Number(),
 	patch: Type.Number(),
+	notes: Type.Union([Type.String({ maxLength: 500 }), Type.Null()]),
 	status: VersionBuildStatusSchema, // SUPPORTED, UPDATE_AVAILABLE, UPDATE_RECOMMENDED, UPDATE_REQUIRED - controls if version is active
 	created_at: Type.String(),
 	updated_at: Type.String(),
@@ -164,12 +165,14 @@ export type VersionRequestResponse = Static<typeof VersionRequestResponseSchema>
 export type _CheckVersionRow = AssertTrue<AssertSchemaCompatibleWithRow<Version, "project_versions">>;
 
 /**
- * Update version status request body schema
+ * Update version request body schema
+ * Supports updating status and/or notes
  */
-export const UpdateVersionStatusBodySchema = Type.Object({
-	status: VersionBuildStatusSchema,
+export const UpdateVersionBodySchema = Type.Object({
+	status: Type.Optional(VersionBuildStatusSchema),
+	notes: Type.Optional(Type.Union([Type.String({ maxLength: 500 }), Type.Null()])),
 });
-export type UpdateVersionStatusBody = Static<typeof UpdateVersionStatusBodySchema>;
+export type UpdateVersionBody = Static<typeof UpdateVersionBodySchema>;
 
 /**
  * Add UPDATE_FAILED error code for update operations

package/src/modules/personas/schemas.ts

@@ -1,123 +0,0 @@
-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">>;