@locusai/shared 0.1.7 → 0.2.2

package/src/models/organization.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { BaseEntitySchema } from "../common";
+
+export const OrganizationSchema = BaseEntitySchema.extend({
+  name: z.string().min(1, "Name is required").max(100),
+  slug: z
+    .string()
+    .min(1, "Slug is required")
+    .regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens"),
+  avatarUrl: z
+    .string()
+    .url("Invalid avatar URL")
+    .nullable()
+    .optional()
+    .or(z.literal("")),
+});
+
+export type Organization = z.infer<typeof OrganizationSchema>;
+
+export const CreateOrganizationSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100),
+  slug: z
+    .string()
+    .min(1, "Slug is required")
+    .regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens"),
+  avatarUrl: z.string().url("Invalid avatar URL").optional().or(z.literal("")),
+});
+
+export type CreateOrganization = z.infer<typeof CreateOrganizationSchema>;
+
+export const UpdateOrganizationSchema = OrganizationSchema.partial().omit({
+  id: true,
+  slug: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type UpdateOrganization = z.infer<typeof UpdateOrganizationSchema>;
+
+export const AddMemberSchema = z.object({
+  userId: z.string().uuid("Invalid User ID"),
+  role: z.enum(["ADMIN", "MEMBER"]).default("MEMBER"),
+});
+
+export type AddMember = z.infer<typeof AddMemberSchema>;
+
+export const MembershipWithUserSchema = z.object({
+  id: z.string().uuid(),
+  userId: z.string().uuid(),
+  orgId: z.string().uuid(),
+  role: z.string(),
+  createdAt: z.number(),
+  user: z.object({
+    id: z.string().uuid(),
+    email: z.string().email(),
+    name: z.string(),
+    avatarUrl: z.string().url().nullable().optional(),
+  }),
+});
+
+export type MembershipWithUser = z.infer<typeof MembershipWithUserSchema>;
+
+// ============================================================================
+// Parameter & Query Schemas
+// ============================================================================
+
+export const OrgIdParamSchema = z.object({
+  orgId: z.string().uuid("Invalid Organization ID"),
+});
+
+export type OrgIdParam = z.infer<typeof OrgIdParamSchema>;
+
+export const MembershipIdParamSchema = z.object({
+  id: z.string().uuid("Invalid Membership ID"),
+});
+
+export type MembershipIdParam = z.infer<typeof MembershipIdParamSchema>;
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+export const OrganizationResponseSchema = z.object({
+  organization: OrganizationSchema,
+});
+
+export type OrganizationResponse = z.infer<typeof OrganizationResponseSchema>;
+
+export const OrganizationsResponseSchema = z.object({
+  organizations: z.array(OrganizationSchema),
+});
+
+export type OrganizationsResponse = z.infer<typeof OrganizationsResponseSchema>;
+
+export const MembersResponseSchema = z.object({
+  members: z.array(MembershipWithUserSchema),
+});
+
+export type MembersResponse = z.infer<typeof MembersResponseSchema>;
+
+export const MembershipResponseSchema = z.object({
+  membership: MembershipWithUserSchema,
+});
+
+export type MembershipResponse = z.infer<typeof MembershipResponseSchema>;

package/src/models/sprint.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { BaseEntitySchema } from "../common";
+import { SprintStatus } from "../enums";
+
+export const SprintSchema = BaseEntitySchema.extend({
+  workspaceId: z.string().uuid().nullable().optional(),
+  name: z.string().min(1, "Name is required").max(100),
+  status: z.nativeEnum(SprintStatus),
+  startDate: z.union([z.date(), z.number()]).nullable().optional(),
+  endDate: z.union([z.date(), z.number()]).nullable().optional(),
+  mindmap: z.string().nullable().optional(),
+  mindmapUpdatedAt: z.union([z.date(), z.number()]).nullable().optional(),
+});
+
+export type Sprint = z.infer<typeof SprintSchema>;
+
+export const CreateSprintSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100),
+  startDate: z.union([z.coerce.date(), z.number()]).optional(),
+  endDate: z.union([z.coerce.date(), z.number()]).optional(),
+});
+
+export type CreateSprint = z.infer<typeof CreateSprintSchema>;
+
+export const UpdateSprintSchema = SprintSchema.partial()
+  .omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+  })
+  .extend({
+    name: z.string().min(1).max(100).optional(),
+    startDate: z.union([z.coerce.date(), z.number()]).optional().nullable(),
+    endDate: z.union([z.coerce.date(), z.number()]).optional().nullable(),
+    mindmapUpdatedAt: z
+      .union([z.coerce.date(), z.number()])
+      .optional()
+      .nullable(),
+  });
+
+export type UpdateSprint = z.infer<typeof UpdateSprintSchema>;
+
+// ============================================================================
+// Parameter & Query Schemas
+// ============================================================================
+
+export const SprintIdParamSchema = z.object({
+  id: z.string().uuid("Invalid Sprint ID"),
+});
+
+export type SprintIdParam = z.infer<typeof SprintIdParamSchema>;
+
+export const SprintQuerySchema = z.object({});
+
+export type SprintQuery = z.infer<typeof SprintQuerySchema>;
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+export const SprintResponseSchema = z.object({
+  sprint: SprintSchema,
+});
+
+export type SprintResponse = z.infer<typeof SprintResponseSchema>;
+
+export const SprintsResponseSchema = z.object({
+  sprints: z.array(SprintSchema),
+});
+
+export type SprintsResponse = z.infer<typeof SprintsResponseSchema>;

package/src/models/task.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { BaseEntitySchema } from "../common";
+import { AssigneeRole, TaskPriority, TaskStatus } from "../enums";
+import { CommentSchema, EventSchema } from "./activity";
+import { DocSchema } from "./doc";
+
+export const AcceptanceItemSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  done: z.boolean(),
+});
+
+export type AcceptanceItem = z.infer<typeof AcceptanceItemSchema>;
+
+export const TaskSchema = BaseEntitySchema.extend({
+  workspaceId: z.string().uuid().nullable().optional(),
+  title: z.string().min(1, "Title is required").max(200),
+  description: z.string().default(""),
+  status: z.nativeEnum(TaskStatus).default(TaskStatus.BACKLOG),
+  priority: z.nativeEnum(TaskPriority).default(TaskPriority.MEDIUM),
+  labels: z.array(z.string()).default([]),
+  assigneeRole: z.nativeEnum(AssigneeRole).nullable().optional(),
+  /** Agent ID or user identifier - not necessarily a UUID */
+  assignedTo: z.string().nullable().optional(),
+  sprintId: z.string().uuid().nullable().optional(),
+  parentId: z.string().uuid().nullable().optional(),
+  dueDate: z.union([z.date(), z.number()]).nullable().optional(),
+  acceptanceChecklist: z.array(AcceptanceItemSchema).default([]),
+  comments: z.array(CommentSchema).default([]),
+  activityLog: z.array(EventSchema).default([]),
+  docs: z.array(DocSchema).default([]),
+});
+
+export type Task = z.infer<typeof TaskSchema>;
+
+export const CreateTaskSchema = z.object({
+  title: z.string().min(1, "Title is required").max(200),
+  description: z.string().optional().default(""),
+  status: z.nativeEnum(TaskStatus).optional().default(TaskStatus.BACKLOG),
+  priority: z.nativeEnum(TaskPriority).optional().default(TaskPriority.MEDIUM),
+  labels: z.array(z.string()).optional().default([]),
+  assigneeRole: z.nativeEnum(AssigneeRole).optional(),
+  assignedTo: z.string().nullable().optional(),
+  dueDate: z.union([z.date(), z.number()]).nullable().optional(),
+  parentId: z.string().uuid().nullable().optional(),
+  sprintId: z.string().uuid().nullable().optional(),
+  acceptanceChecklist: z.array(AcceptanceItemSchema).optional(),
+  docIds: z.array(z.string().uuid()).optional(),
+});
+
+export type CreateTask = z.infer<typeof CreateTaskSchema>;
+
+export const UpdateTaskSchema = TaskSchema.partial()
+  .omit({
+    id: true,
+    workspaceId: true,
+    createdAt: true,
+    updatedAt: true,
+  })
+  .extend({
+    title: z.string().min(1).max(200).optional(),
+    acceptanceChecklist: z.array(AcceptanceItemSchema).optional(),
+    docIds: z.array(z.string().uuid()).optional(),
+  });
+
+export type UpdateTask = z.infer<typeof UpdateTaskSchema>;
+
+export const AddCommentSchema = z.object({
+  author: z.string().min(1, "Author is required"),
+  text: z.string().min(1, "Comment text is required"),
+});
+
+export type AddComment = z.infer<typeof AddCommentSchema>;
+
+export const DispatchTaskSchema = z.object({
+  workerId: z.string().optional(),
+  sprintId: z.string().uuid().optional().nullable(),
+});
+
+export type DispatchTask = z.infer<typeof DispatchTaskSchema>;
+
+// ============================================================================
+// Parameter & Query Schemas
+// ============================================================================
+
+export const TaskIdParamSchema = z.object({
+  id: z.string().uuid("Invalid Task ID"),
+});
+
+export type TaskIdParam = z.infer<typeof TaskIdParamSchema>;
+
+export const TaskQuerySchema = z.object({});
+
+export type TaskQuery = z.infer<typeof TaskQuerySchema>;
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+export const TaskResponseSchema = z.object({
+  task: TaskSchema,
+});
+
+export type TaskResponse = z.infer<typeof TaskResponseSchema>;
+
+export const TasksResponseSchema = z.object({
+  tasks: z.array(TaskSchema),
+});
+
+export type TasksResponse = z.infer<typeof TasksResponseSchema>;

package/src/models/user.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { BaseEntitySchema } from "../common";
+import { UserRole } from "../enums";
+
+export const UserSchema = BaseEntitySchema.extend({
+  email: z.string().email(),
+  name: z.string().min(1),
+  avatarUrl: z.string().url().nullable().optional(),
+  role: z.nativeEnum(UserRole),
+  orgId: z.string().uuid().optional().nullable(),
+  workspaceId: z.string().uuid().optional().nullable(),
+  companyName: z.string().optional(),
+  userRole: z.string().optional(),
+  teamSize: z.string().optional(),
+  onboardingCompleted: z.boolean().default(false),
+  emailVerified: z.boolean().default(false),
+});
+
+export type User = z.infer<typeof UserSchema>;
+
+export const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+});
+
+export type CreateUser = z.infer<typeof CreateUserSchema>;
+
+export const UpdateUserSchema = UserSchema.partial().omit({
+  id: true,
+  email: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type UpdateUser = z.infer<typeof UpdateUserSchema>;

package/src/models/workspace.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { BaseEntitySchema } from "../common";
+
+export const WorkspaceSchema = BaseEntitySchema.extend({
+  orgId: z.string().uuid(),
+  name: z.string().min(1, "Name is required").max(100),
+  slug: z
+    .string()
+    .min(1, "Slug is required")
+    .regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens"),
+});
+
+export type Workspace = z.infer<typeof WorkspaceSchema>;
+
+export const CreateWorkspaceSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100),
+  slug: z
+    .string()
+    .min(1, "Slug is required")
+    .regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens")
+    .optional(),
+});
+
+export type CreateWorkspace = z.infer<typeof CreateWorkspaceSchema>;
+
+export const UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
+  id: true,
+  orgId: true,
+  slug: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type UpdateWorkspace = z.infer<typeof UpdateWorkspaceSchema>;
+
+export const AddWorkspaceMemberSchema = z.object({
+  userId: z.string().uuid("Invalid User ID"),
+  role: z.string().optional(),
+});
+
+export type AddWorkspaceMember = z.infer<typeof AddWorkspaceMemberSchema>;
+
+// ============================================================================
+// Parameter & Query Schemas
+// ============================================================================
+
+export const WorkspaceIdParamSchema = z.object({
+  workspaceId: z.string().uuid("Invalid Workspace ID"),
+});
+
+export type WorkspaceIdParam = z.infer<typeof WorkspaceIdParamSchema>;
+
+export const WorkspaceAndUserParamSchema = z.object({
+  workspaceId: z.string().uuid("Invalid Workspace ID"),
+  userId: z.string().uuid("Invalid User ID"),
+});
+
+export type WorkspaceAndUserParam = z.infer<typeof WorkspaceAndUserParamSchema>;
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+export const WorkspaceResponseSchema = z.object({
+  workspace: WorkspaceSchema,
+});
+
+export type WorkspaceResponse = z.infer<typeof WorkspaceResponseSchema>;
+
+export const WorkspacesResponseSchema = z.object({
+  workspaces: z.array(WorkspaceSchema),
+});
+
+export type WorkspacesResponse = z.infer<typeof WorkspacesResponseSchema>;
+
+export const WorkspaceStatsSchema = z.object({
+  workspaceName: z.string(),
+  taskCounts: z.record(z.string(), z.number()),
+  memberCount: z.number(),
+});
+
+export type WorkspaceStats = z.infer<typeof WorkspaceStatsSchema>;
+
+export const WorkspaceStatsResponseSchema = z.object({
+  stats: WorkspaceStatsSchema,
+});
+
+export type WorkspaceStatsResponse = z.infer<
+  typeof WorkspaceStatsResponseSchema
+>;