@zyacreatives/shared 2.2.64 → 2.2.66

package/src/schemas/user.ts

@@ -52,9 +52,9 @@ export const UserEntitySchema = z
       .openapi({
         example: "DONE",
       }),
-    createdAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
-    version: z.int(),
-    updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    createdAt: z.coerce.date().openapi({ example: "2026-03-11T09:00:00.000Z" }),
+    version: z.int().openapi({ example: 1 }),
+    updatedAt: z.coerce.date().openapi({ example: "2026-03-11T09:00:00.000Z" }),
   })
   .openapi("BaseUserEntity");
 
@@ -68,13 +68,18 @@ export const MinimalUserSchema = UserEntitySchema.pick({
 }).openapi("MinimalUser");
 
 export const UserStatsEntitySchema = z.object({
-  followerCount: z.int(),
-  followingCount: z.int(),
-  followingIds: z.array(z.string()),
+  followerCount: z.int().openapi({ example: 1540 }),
+  followingCount: z.int().openapi({ example: 234 }),
+  followingIds: z
+    .array(z.cuid2())
+    .openapi({ example: ["cksd0v6q0000s9a5y8z7p3x9", "clm1a2b3c0000abc"] }),
 });
 
 export const UserProfileEntitySchema = UserEntitySchema.extend({
-  profileType: z.enum(["creative", "brand", "investor"]).optional(),
+  profileType: z
+    .enum(["creative", "brand", "investor"])
+    .optional()
+    .openapi({ example: "creative" }),
   brand: BrandEntitySchema,
   creative: CreativeEntitySchema,
   investor: InvestorEntitySchema,
@@ -82,78 +87,88 @@ export const UserProfileEntitySchema = UserEntitySchema.extend({
 
 export const UserWithProjectsEntitySchema = z
   .object({
-    userId: z.cuid2(),
-    projects: z.array(ProjectEntitySchema.omit({ overview: true })),
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    projects: z
+      .array(ProjectEntitySchema.omit({ overview: true }))
+      .openapi({ example: [] }),
   })
   .openapi("UserWithProjectsEntity");
 
 export const UserWithProjectLikesEntitySchema = z.object({
-  userId: z.cuid2(),
-  projectLikes: z.array(
-    LikeEntitySchema.extend({
-      project: ProjectEntitySchema.pick({
-        id: true,
-        title: true,
-        description: true,
-        tags: true,
-        startDate: true,
-        endDate: true,
-        imagePlaceholderUrl: true,
+  userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+  projectLikes: z
+    .array(
+      LikeEntitySchema.extend({
+        project: ProjectEntitySchema.pick({
+          id: true,
+          title: true,
+          description: true,
+          tags: true,
+          startDate: true,
+          endDate: true,
+          imagePlaceholderUrl: true,
+        }),
       }),
-    }),
-  ),
+    )
+    .openapi({ example: [] }),
 });
 
 export const UserWithPostLikesEntitySchema = z.object({
-  userId: z.cuid2(),
-  postLikes: z.array(
-    LikeEntitySchema.extend({
-      post: PostEntitySchema.pick({
-        id: true,
-        parentId: true,
-        title: true,
-        content: true,
-        tags: true,
-        createdAt: true,
-        updatedAt: true,
+  userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+  postLikes: z
+    .array(
+      LikeEntitySchema.extend({
+        post: PostEntitySchema.pick({
+          id: true,
+          parentId: true,
+          title: true, // Note: Make sure 'title' exists on PostEntitySchema in your post.ts!
+          content: true,
+          tags: true,
+          createdAt: true,
+          updatedAt: true, // Note: Make sure 'updatedAt' exists on PostEntitySchema as well!
+        }),
       }),
-    }),
-  ),
+    )
+    .openapi({ example: [] }),
 });
 
 export const UserWithPostBookmarksEntitySchema = z.object({
-  userId: z.cuid2(),
-  postBookmarks: z.array(
-    BookmarkEntitySchema.extend({
-      post: PostEntitySchema.pick({
-        id: true,
-        parentId: true,
-        title: true,
-        content: true,
-        tags: true,
-        createdAt: true,
-        updatedAt: true,
-      }),
-    }),
-  ),
-});
-
-export const UserWithProjectBookmarksEntitySchema = z
-  .object({
-    userId: z.cuid2(),
-    projectBookmarks: z.array(
+  userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+  postBookmarks: z
+    .array(
       BookmarkEntitySchema.extend({
-        project: ProjectEntitySchema.pick({
+        post: PostEntitySchema.pick({
           id: true,
+          parentId: true,
           title: true,
-          description: true,
+          content: true,
           tags: true,
-          startDate: true,
-          endDate: true,
-          imagePlaceholderUrl: true,
+          createdAt: true,
+          updatedAt: true,
         }),
       }),
-    ),
+    )
+    .openapi({ example: [] }),
+});
+
+export const UserWithProjectBookmarksEntitySchema = z
+  .object({
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    projectBookmarks: z
+      .array(
+        BookmarkEntitySchema.extend({
+          project: ProjectEntitySchema.pick({
+            id: true,
+            title: true,
+            description: true,
+            tags: true,
+            startDate: true,
+            endDate: true,
+            imagePlaceholderUrl: true,
+          }),
+        }),
+      )
+      .openapi({ example: [] }),
   })
   .openapi("UserWithProjectBookmarksEntity");
 
@@ -166,116 +181,159 @@ export const GetUserFollowersInputSchema = z.object({
   searchQuery: z.string().optional().openapi({ example: "design systems" }),
   offset: z.number().int().nonnegative().optional().openapi({ example: 20 }),
 });
+
 export const UserWithFollowingEntitySchema = MinimalUserSchema.extend({
   following: z
     .array(
       MinimalUserSchema.extend({
-        isFollowing: z.boolean().optional(),
-        followsYou: z.boolean().optional(),
+        isFollowing: z.boolean().optional().openapi({ example: true }),
+        followsYou: z.boolean().optional().openapi({ example: false }),
       }),
     )
-    .openapi({ description: "List of users this user is following." }),
+    .openapi({
+      description: "List of users this user is following.",
+      example: [],
+    }),
 }).openapi("UserWithFollowingEntity");
 
 export const UserWithFollowersEntitySchema = MinimalUserSchema.extend({
   followers: z
     .array(
       MinimalUserSchema.extend({
-        isFollowing: z.boolean().optional(),
-        followsYou: z.boolean().optional(),
+        isFollowing: z.boolean().optional().openapi({ example: false }),
+        followsYou: z.boolean().optional().openapi({ example: true }),
       }),
     )
-    .openapi({ description: "List of users who follow this user." }),
+    .openapi({
+      description: "List of users who follow this user.",
+      example: [],
+    }),
 }).openapi("UserWithFollowersEntity");
 
 export const GetUserFollowersOutputSchema = z.object({
-  nextCursor: z.string(),
-  followers: z.array(
-    MinimalUserSchema.extend({
-      isFollowing: z.boolean().optional(),
-      followsYou: z.boolean().optional(),
-    }),
-  ),
+  nextCursor: z.string().openapi({ example: "cksd0v6q0000nxtcur" }),
+  followers: z
+    .array(
+      MinimalUserSchema.extend({
+        isFollowing: z.boolean().optional().openapi({ example: false }),
+        followsYou: z.boolean().optional().openapi({ example: true }),
+      }),
+    )
+    .openapi({ example: [] }),
 });
 
 export const GetUserFollowingOutputSchema = z.object({
-  nextCursor: z.string(),
-  following: z.array(
-    MinimalUserSchema.extend({
-      isFollowing: z.boolean().optional(),
-      followsYou: z.boolean().optional(),
-    }),
-  ),
+  nextCursor: z.string().openapi({ example: "cksd0v6q0000nxtcur" }),
+  following: z
+    .array(
+      MinimalUserSchema.extend({
+        isFollowing: z.boolean().optional().openapi({ example: true }),
+        followsYou: z.boolean().optional().openapi({ example: false }),
+      }),
+    )
+    .openapi({ example: [] }),
 });
 
 export const UserWithPostsEntitySchema = z
   .object({
-    userId: z.cuid2(),
-    posts: z.array(PostWithFilesEntitySchema),
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    posts: z.array(PostWithFilesEntitySchema).openapi({ example: [] }),
   })
   .openapi("UserWithPostsEntity");
 
 export const GetAuthenticatedUserOutputSchema = UserEntitySchema;
-
 export const GetAuthenticatedUserProfileOutputSchema = UserProfileEntitySchema;
-
 export const GetAuthenticatedUserWithProjectsOutputSchema =
   UserWithProjectsEntitySchema;
-
 export const GetAuthenticatedUserWithProjectBookmarksOutputSchema =
   UserWithProjectBookmarksEntitySchema;
-
 export const GetAuthenticatedUserWithUserFollowingOutputSchema =
   UserWithFollowingEntitySchema;
-
 export const GetAuthenticatedUserWithUserFollowersOutputSchema =
   UserWithFollowersEntitySchema;
-
 export const GetAuthenticatedUserWithProjectLikesOutputSchema =
   UserWithProjectLikesEntitySchema;
 
 export const GetUserActivityInputSchema = z.object({
-  activityType: z.enum(
-    Object.values(ACTIVITY_TYPES) as [ActivityType, ...ActivityType[]],
-  ),
+  activityType: z
+    .enum(Object.values(ACTIVITY_TYPES) as [ActivityType, ...ActivityType[]])
+    .openapi({ example: "LIKE" }),
 });
 
-export const GetUserActivityOutputSchema = z.array(
-  z.object({
-    parentId: z.string(),
-    parentType: z.enum(
-      Object.values(ACTIVITY_PARENT_TYPES) as [
-        ActivityParentType,
-        ...ActivityParentType[],
-      ],
-    ),
-  }),
-);
+export const GetUserActivityOutputSchema = z
+  .array(
+    z.object({
+      parentId: z.cuid2().openapi({ example: "ckj1a2b3c0000prt" }),
+      parentType: z
+        .enum(
+          Object.values(ACTIVITY_PARENT_TYPES) as [
+            ActivityParentType,
+            ...ActivityParentType[],
+          ],
+        )
+        .openapi({ example: "POST" }),
+    }),
+  )
+  .openapi({ example: [] });
 
 export const SearchUsersInputSchema = z.object({
   query: z.string().default("").openapi({
     example: "john",
     description: "Search by name, email, username, or discipline",
   }),
-  role: z.enum(Object.values(ROLES) as [Role, ...Role[]]).optional(),
+  role: z
+    .enum(Object.values(ROLES) as [Role, ...Role[]])
+    .optional()
+    .openapi({ example: "CREATIVE" }),
   limit: z.coerce.number().min(1).max(100).default(20).openapi({ example: 20 }),
   cursor: z.string().optional().openapi({
-    example: 0,
+    example: "cksd0v6q0000cursor",
     description: "The offset/cursor for pagination",
   }),
 });
 
 export const SearchUsersOutputSchema = z.object({
-  users: z.array(
-    MinimalUserSchema.extend({
-      isFollowing: z.boolean().optional(),
-      followsYou: z.boolean().optional(),
-      noOfFollowers: z.number().int().nonnegative().optional(),
-      disciplines: z.array(z.string()).optional(),
-    }),
-  ),
+  users: z
+    .array(
+      MinimalUserSchema.extend({
+        isFollowing: z.boolean().optional().openapi({ example: false }),
+        followsYou: z.boolean().optional().openapi({ example: true }),
+        noOfFollowers: z
+          .number()
+          .int()
+          .nonnegative()
+          .optional()
+          .openapi({ example: 1200 }),
+        disciplines: z
+          .array(z.string())
+          .optional()
+          .openapi({ example: ["UI/UX", "Frontend"] }),
+      }),
+    )
+    .openapi({ example: [] }),
   nextCursor: z.string().optional().openapi({
-    example: "abc123",
+    example: "abc123nxt",
     description: "The next cursor for pagination",
   }),
 });
+
+
+export const UserSearchDocumentSchema = z.object({
+  id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+  email: z.email().openapi({ example: "user@example.com" }),
+  username: z.string().nullable().openapi({ example: "johndoe" }),
+  name: z.string().nullable().openapi({ example: "John Doe" }),
+  image: z.string().nullable().openapi({ example: "https://example.com/avatar.png" }),
+  role: z
+    .enum(Object.values(ROLES) as [Role, ...Role[]])
+    .openapi({ example: "CREATIVE" }),
+  bio: z.string().nullable().openapi({ example: "Passionate designer and developer based in Lagos." }),
+  location: z.string().nullable().openapi({ example: "Lagos, Nigeria" }),
+  disciplines: z.array(z.string()).nullable().openapi({ example: ["Design Systems", "Web Development"] }),
+  updatedAt: z.string().nullable().openapi({ example: "2026-03-11T09:00:00.000Z" }),
+  createdAt: z.string().nullable().openapi({ example: "2026-03-11T09:00:00.000Z" }),
+}).openapi({
+  title: "User Search Document",
+  description: "Flattened schema used for indexing users in search engines.",
+});
+

package/src/types/job.ts

@@ -16,6 +16,7 @@ import {
   GetJobsOutputSchema,
   GetJobsInputSchema,
   GetCreatedJobsOutputSchema,
+  JobSearchDocumentSchema,
 } from "../schemas/job";
 
 export type BaseJobEntity = z.infer<typeof BaseJobEntitySchema>;
@@ -63,9 +64,14 @@ export type JobWithRoleDetailsEntity = z.infer<
 >;
 
 export type GetJobsInput = z.infer<typeof GetJobsInputSchema>;
+
 export type GetJobsOutput = z.infer<typeof GetJobsOutputSchema>;
+
 export type GetCreatedJobsOutput = z.infer<typeof GetCreatedJobsOutputSchema>;
+
 export type NormalizedJobEntity =
   | JobEntity
   | JobWithGigDetailsEntity
   | JobWithRoleDetailsEntity;
+
+export type JobSearchDocument = z.infer<typeof JobSearchDocumentSchema>;

package/src/types/post.ts

@@ -15,6 +15,7 @@ import {
   PostEntitySchema,
   PostFileEntitySchema,
   PostIdSchema,
+  PostSearchDocumentSchema,
   PostWithBookmarksEntitySchema,
   PostWithCommentsEntitySchema,
   PostWithFilesEntitySchema,
@@ -61,3 +62,5 @@ export type GetPostWithBookmarksOutput = z.infer<
 export type ReportPostInput = z.infer<typeof ReportPostInputSchema>;
 
 export type PostAnalyticsOutput = z.infer<typeof PostAnalyticsOutputSchema>;
+
+export type PostSearchDocument = z.infer<typeof PostSearchDocumentSchema>;

package/src/types/user.ts

@@ -26,6 +26,7 @@ import {
     SearchUsersOutputSchema,
     UserWithPostBookmarksEntitySchema,
     UserWithPostLikesEntitySchema,
+    UserSearchDocumentSchema,
 } from "../schemas/user";
 
 import { z } from "@hono/zod-openapi";
@@ -94,3 +95,4 @@ export type UserStatsEntity = z.infer<typeof UserStatsEntitySchema>;
 
 export type SearchUsersInput = z.infer<typeof SearchUsersInputSchema>;
 export type SearchUsersOutput = z.infer<typeof SearchUsersOutputSchema>;
+export type UserSearchDocument = z.infer<typeof UserSearchDocumentSchema>;