@zyacreatives/shared 2.5.52 → 2.5.55

package/dist/types/username.d.ts

@@ -1,3 +1 @@
-import { z } from "@hono/zod-openapi";
-import { UsernameSchema } from "../schemas";
-export type UsernameInput = z.infer<typeof UsernameSchema>;
+export type { UsernameInput } from "../schemas/username";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zyacreatives/shared",
-  "version": "2.5.52",
+  "version": "2.5.55",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,5 +1,4 @@
-export * from "./types/index";
-export * from "./constants";
-export * from "./schemas/index";
-export * from "./utils/slugify";
-export * from "./utils/generate-file-url"
+export * from "./constants";
+export * from "./schemas/index";
+export * from "./utils/slugify";
+export * from "./utils/generate-file-url"

package/src/schemas/activity.ts

@@ -1,7 +1,7 @@
 import z from "zod";
 import { ACTIVITY_TYPES } from "../constants";
 
-export const ActivitySchema = z.object({
+export const ActivitySchema = z.object({
   id: z.cuid2().openapi({
     description: "Unique identifier for the bookmarked entity.",
     title: "Entity ID",
@@ -12,6 +12,7 @@ export const ActivitySchema = z.object({
   actorUsername: z.string(),
   actorImageUrl: z.url().optional(),
   followsYou: z.boolean().optional(),
-  isFollowing: z.boolean().optional(),
-});
-
+  isFollowing: z.boolean().optional(),
+});
+
+export type ActivityEntity = z.infer<typeof ActivitySchema>;

package/src/schemas/auth.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 
-export const RegisterSchema = z.object({
+export const RegisterSchema = z.object({
   firstName: z.string().max(255, { message: "First name is too long" }),
   lastName: z.string().max(255, { message: "Last name is too long" }),
   email: z
@@ -13,13 +13,15 @@ export const RegisterSchema = z.object({
     .regex(/^[a-zA-Z0-9_]+$/, {
       error: "Username can only contain letters, numbers, and underscores",
     }),
-  password: z
-    .string()
-    .min(8, { message: "Password must be at least 8 characters" })
-    .max(100, { message: "Password must be at most 100 characters" }),
-});
-
-export const LoginSchema = z.object({
+  password: z
+    .string()
+    .min(8, { message: "Password must be at least 8 characters" })
+    .max(100, { message: "Password must be at most 100 characters" }),
+});
+
+export type RegisterInput = z.infer<typeof RegisterSchema>;
+
+export const LoginSchema = z.object({
   identifier: z
     .string()
     .trim()
@@ -39,5 +41,7 @@ export const LoginSchema = z.object({
     .string()
     .min(8, { message: "Password must be at least 8 characters" })
     .max(100, { message: "Password must be at most 100 characters" }),
-  rememberMe: z.boolean(),
-});
+  rememberMe: z.boolean(),
+});
+
+export type LoginInput = z.infer<typeof LoginSchema>;

package/src/schemas/bookmark.ts

@@ -1,38 +1,57 @@
 import { z } from "@hono/zod-openapi";
+
 import { ACTIVITY_PARENT_TYPES } from "../constants";
 
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const BookmarkShape = z.object({
+  parentId: z.cuid2(),
+  parentType: z.enum(ACTIVITY_PARENT_TYPES),
+});
+
+export type BookmarkShapeType = z.infer<typeof BookmarkShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
 export const BookmarkEntitySchema = z
   .object({
-    id: z.cuid2().openapi({
-      description: "Unique identifier for the bookmark.",
-      title: "Bookmark ID",
-    }),
-    createdAt: z.coerce.date().optional().openapi({
-      description: "Timestamp when the bookmark was created.",
-      title: "Created At",
-    }),
-    userId: z.cuid2().openapi({
-      description: "Identifier of the user who created the bookmark.",
-      title: "User ID",
-    }),
-    parentId: z.cuid2().openapi({
-      description: "Identifier of the parent entity that was bookmarked.",
-      title: "Parent ID",
-    }),
-    parentType: z.enum(ACTIVITY_PARENT_TYPES).openapi({
-      description: "Type of the parent entity this statistic belongs to.",
-      title: "Parent Type",
-    }),
+    id: z.cuid2(),
+    userId: z.cuid2(),
+    ...BookmarkShape.shape,
+    createdAt: z.iso.datetime(),
   })
-  .openapi({
-    title: "Bookmark",
-    description: "Represents a user bookmark on a specific parent entity.",
-  });
+  .openapi("Bookmark");
 
-export const BookmarkInputSchema = z.object({
-  parentId: z.string(),
-  parentType: z.enum(ACTIVITY_PARENT_TYPES),
-  userId: z.string(),
-});
+export type BookmarkEntity = z.infer<typeof BookmarkEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
+
+export const CreateBookmarkInputSchema = BookmarkShape.extend({});
+
+export type CreateBookmarkInput = z.infer<typeof CreateBookmarkInputSchema>;
+
+export const DeleteBookmarkInputSchema = BookmarkShape.extend({});
+
+export type DeleteBookmarkInput = z.infer<typeof DeleteBookmarkInputSchema>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
 
 export const BookmarkOutputSchema = BookmarkEntitySchema;
+
+export type BookmarkOutput = z.infer<typeof BookmarkOutputSchema>;

package/src/schemas/chat.ts

@@ -1,19 +1,48 @@
 import { z } from "@hono/zod-openapi";
+
 import { MESSAGE_REQUEST_STATUS } from "../constants";
 
-export const BaseChatEntitySchema = z.object({
-  id: z.cuid2(),
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const ChatShape = z.object({
   senderId: z.cuid2(),
   receiverId: z.cuid2(),
   isMessageRequest: z.boolean().default(true),
   messageRequestStatus: z.enum(MESSAGE_REQUEST_STATUS).default("PENDING"),
-  acceptedAt: z.coerce.date().nullable(),
-  declinedAt: z.coerce.date().nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date().nullable(),
-  deletedAt: z.coerce.date().nullable(),
 });
 
+export type ChatShapeType = z.infer<typeof ChatShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
+export const BaseChatEntitySchema = z
+  .object({
+    id: z.cuid2(),
+    ...ChatShape.shape,
+    acceptedAt: z.iso.datetime().nullable(),
+    declinedAt: z.iso.datetime().nullable(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime().nullable(),
+    deletedAt: z.iso.datetime().nullable(),
+  })
+  .openapi("BaseChat");
+
+export type BaseChatEntity = z.infer<typeof BaseChatEntitySchema>;
+
+/**
+ * --------------------------------
+ * DERIVED ENTITIES
+ * --------------------------------
+ */
+
 export const ChatEntitySchema = BaseChatEntitySchema.extend({
   senderName: z.string(),
   senderUsername: z.string(),
@@ -24,35 +53,67 @@ export const ChatEntitySchema = BaseChatEntitySchema.extend({
   receiverImgUrl: z.string().nullable(),
 
   lastMessageSent: z.string().nullable(),
-  lastMessageAt: z.coerce.date().nullable(),
+  lastMessageAt: z.iso.datetime().nullable(),
   isUnread: z.boolean().default(false),
   isOnline: z.boolean().default(false),
-});
+}).openapi("Chat");
+
+export type ChatEntity = z.infer<typeof ChatEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
 
 export const CreateChatInputSchema = z.object({
-  senderId: z.cuid2(),
   receiverId: z.cuid2(),
 });
 
-export const CreateChatOutputSchema = BaseChatEntitySchema;
+export type CreateChatInput = z.infer<typeof CreateChatInputSchema>;
 
-export const ChatIdSchema = z.object({
+export const ChatIdInputSchema = z.object({
   chatId: z.cuid2(),
 });
 
+export type ChatIdInput = z.infer<typeof ChatIdInputSchema>;
+
+export const AcceptMessageRequestInputSchema = ChatIdInputSchema.extend({});
+
+export type AcceptMessageRequestInput = z.infer<
+  typeof AcceptMessageRequestInputSchema
+>;
+
+export const DeclineMessageRequestInputSchema = ChatIdInputSchema.extend({});
+
+export type DeclineMessageRequestInput = z.infer<
+  typeof DeclineMessageRequestInputSchema
+>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
+
+export const CreateChatOutputSchema = BaseChatEntitySchema;
+
+export type CreateChatOutput = z.infer<typeof CreateChatOutputSchema>;
+
 export const GetChatsOutputSchema = z.array(ChatEntitySchema);
 
+export type GetChatsOutput = z.infer<typeof GetChatsOutputSchema>;
+
 export const GetChatsForUserOutputSchema = z.object({
   chats: z.array(ChatEntitySchema),
   nextCursor: z.string().nullable(),
 });
 
+export type GetChatsForUserOutput = z.infer<typeof GetChatsForUserOutputSchema>;
+
 export const GetMessageRequestsForUserOutputSchema =
   GetChatsForUserOutputSchema;
 
-export const AcceptMessageRequestInputSchema = z.object({
-  chatId: z.cuid2(),
-  userId: z.cuid2(),
-});
-
-export const DeclineMessageRequestInputSchema = AcceptMessageRequestInputSchema;
+export type GetMessageRequestsForUserOutput = z.infer<
+  typeof GetMessageRequestsForUserOutputSchema
+>;

package/src/schemas/comment.ts

@@ -1,62 +1,76 @@
-import z from "zod";
+import { z } from "@hono/zod-openapi";
+
 import { ACTIVITY_PARENT_TYPES } from "../constants";
 
-export const CommentEntitySchema = z.object({
-  id: z.cuid2().openapi({
-    description: "The unique CUID2 identifier for the comment.",
-    example: "tr4q2k7k0000c7625z2k8ggy",
-  }),
-  userId: z.cuid2().openapi({
-    description: "The CUID2 of the user who created the comment.",
-    example: "clq9p8f2z0000c762s7k4g1b",
-  }),
-  parentId: z.cuid2().openapi({
-    description:
-      "The CUID2 of the parent entity (e.g., a post or project) this comment belongs to.",
-    example: "clq9p8f2z0000c762s7k4g1b",
-  }),
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const CommentShape = z.object({
+  parentId: z.cuid2(),
+  parentType: z.enum(ACTIVITY_PARENT_TYPES),
+  content: z.string(),
   parentCommentId: z.cuid2().optional(),
-  parentType: z.enum(ACTIVITY_PARENT_TYPES).openapi({
-    description: "The type of the parent entity this comment is attached to.",
-    example: "POST", // Assuming 'POST' is a value in ACTIVITY_PARENT_TYPES
-  }),
-  content: z.string().openapi({
-    description: "The text content of the comment. May contain Markdown.",
-    example: "This is a great point! I hadn't considered that perspective.",
-  }),
-  commenterUsername: z.string().optional(),
-  commenterName: z.string().optional(),
-  commenterImageUrl: z.string().optional(),
-  replyToId: z.cuid2().optional().nullable().openapi({
-    description:
-      "The ID of the parent comment if this is a reply. Null for top-level comments.",
-    example: "tr4q2k7k0000c7625z2k8ggy", // Example of a parent comment's ID
-  }),
-  createdAt: z.coerce.date().optional().openapi({
-    description: "The date and time the comment was created.",
-    example: "2023-10-27T10:00:00.000Z",
-    format: "date-time",
-  }),
-  isLiked: z.boolean().default(false),
-  likesCount: z.int().default(0),
-  hasReplies: z.boolean().optional(),
-  updatedAt: z.coerce.date().optional().openapi({
-    description: "The date and time the comment was last updated.",
-    example: "2023-10-27T10:05:00.000Z",
-    format: "date-time",
-  }),
+  replyToId: z.cuid2().optional().nullable(),
 });
 
-export const CommentInputSchema = z
+export type CommentShapeType = z.infer<typeof CommentShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
+export const CommentEntitySchema = z
   .object({
-    content: z.string(),
-    parentCommentId: z.cuid2().optional(),
-    replyToId: z.cuid2().optional(),
+    id: z.cuid2(),
+    userId: z.cuid2(),
+    ...CommentShape.shape,
+
+    commenterUsername: z.string().optional(),
+    commenterName: z.string().optional(),
+    commenterImageUrl: z.string().optional(),
+
+    isLiked: z.boolean().default(false),
+    likesCount: z.int().default(0),
+    hasReplies: z.boolean().optional(),
+
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime().optional(),
   })
-  .openapi({ title: "Comment on Project" });
+  .openapi("Comment");
+
+export type CommentEntity = z.infer<typeof CommentEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
+
+export const CreateCommentInputSchema = z.object({
+  content: z.string(),
+  parentCommentId: z.cuid2().optional(),
+  replyToId: z.cuid2().optional().nullable(),
+});
+
+export type CreateCommentInput = z.infer<typeof CreateCommentInputSchema>;
 
 export const DeleteCommentInputSchema = z.object({
   commentId: z.cuid2(),
 });
 
+export type DeleteCommentInput = z.infer<typeof DeleteCommentInputSchema>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
+
 export const CommentOutputSchema = CommentEntitySchema;
+
+export type CommentOutput = z.infer<typeof CommentOutputSchema>;

package/src/schemas/common.ts

@@ -74,12 +74,17 @@ export const WorkExperienceSchema = z.object({
   description: z.string().default(""),
 });
 
-export const WebsiteUrlInputSchema = z
+export const WebsiteUrlInputSchema = z
   .string()
   .transform((val) => {
     if (!val) return val;
     if (val.startsWith("http://") || val.startsWith("https://")) return val;
     return `https://${val}`;
   })
-  .pipe(z.url("Invalid URL").or(z.literal("")))
-  .optional();
+  .pipe(z.url("Invalid URL").or(z.literal("")))
+  .optional();
+
+export type Cursor = {
+  id: string;
+  createdAt: string;
+};

package/src/schemas/creative.ts

@@ -23,10 +23,10 @@ const CreativeShape = z.object({
       z.object({
         companyName: z.string(),
         position: z.string(),
-        startDate: z.string().datetime().optional(),
-        endDate: z.string().datetime().optional(),
+        startDate: z.iso.datetime().optional(),
+        endDate: z.iso.datetime().optional(),
         currentlyWorking: z.boolean().default(false),
-        description: z.string().default(""),
+        description: z.string().optional(),
       }),
     )
     .default([]),

package/src/schemas/discipline.ts

@@ -1,88 +1,120 @@
 import { z } from "@hono/zod-openapi";
 
-export const BaseDisciplineEntitySchema = z.object({
-  slug: z.string().openapi({ example: "digital-art" }),
-  name: z.string().openapi({ example: "Digital Art" }),
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const DisciplineShape = z.object({
+  slug: z.string(),
+  name: z.string(),
 });
 
-export const TagEntitySchema = z.object({
-  id: z.int(),
+export type DisciplineShapeType = z.infer<typeof DisciplineShape>;
+
+const TagShape = z.object({
   name: z.string(),
   disciplineSlug: z.string().optional(),
 });
 
-export const DisciplineEntitySchema = BaseDisciplineEntitySchema.extend({
-  tags: z
-    .array(z.string().openapi({ example: "illustration" }))
-    .optional()
-    .openapi({ example: ["illustration", "concept-art"] }),
-}).openapi({ title: "DisciplineEntity" });
+export type TagShapeType = z.infer<typeof TagShape>;
 
-export const DisciplineUpdateOutputSchema = z
-  .object({
-    slug: z.string().openapi({ example: "digital-art" }),
-  })
-  .openapi({ title: "DisciplineUpdateOutput" });
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
 
-export const CreateDisciplinesInputSchema = z
-  .object({
-    disciplines: z
-      .array(
-        z.object({
-          name: z.string().max(128).openapi({ example: "Mathematics" }),
-          tags: z
-            .array(z.string().openapi({ example: "algebra" }))
-            .default([])
-            .openapi({ example: ["algebra", "geometry"] }),
-        })
-      )
-      .openapi({
-        description: "Array of disciplines to upsert.",
-        example: [
-          { name: "Mathematics", tags: ["algebra", "geometry"] },
-          { name: "Physics", tags: ["mechanics", "optics"] },
-        ],
-      }),
-  })
-  .openapi({ title: "CreateDisciplinesInput" });
+export const BaseDisciplineEntitySchema =
+  DisciplineShape.openapi("BaseDiscipline");
+
+export type BaseDisciplineEntity = z.infer<typeof BaseDisciplineEntitySchema>;
 
-export const CreateDisciplinesOutputSchema = z
+export const TagEntitySchema = z
   .object({
-    disciplines: z.array(z.string()),
+    id: z.int(),
+    ...TagShape.shape,
   })
-  .openapi({ title: "CreateDisciplinesOutput" });
+  .openapi("Tag");
 
-export const GetDisciplinesInputSchema = z
-  .object({
-    withTags: z
-      .union([z.literal("true"), z.literal("false")])
-      .optional()
-      .openapi({
-        description: "Whether to include tags in the response.",
-        example: "true",
-      }),
-    getDefault: z
-      .union([z.literal("true"), z.literal("false")])
-      .optional()
-      .openapi({
-        description:
-          "Fetch the default list of disciplines (non user-added disciplines).",
-      }),
-    slugs: z.string().optional().openapi({
-      description: "Comma-separated list of discipline slugs to filter by.",
-      example: "mathematics,physics",
+export type TagEntity = z.infer<typeof TagEntitySchema>;
+
+/**
+ * --------------------------------
+ * DERIVED ENTITIES
+ * --------------------------------
+ */
+
+export const DisciplineEntitySchema = BaseDisciplineEntitySchema.extend({
+  tags: z.array(z.string()).optional(),
+}).openapi("Discipline");
+
+export type DisciplineEntity = z.infer<typeof DisciplineEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
+
+export const CreateDisciplinesInputSchema = z.object({
+  disciplines: z.array(
+    z.object({
+      name: z.string().max(128),
+      tags: z.array(z.string()).default([]),
     }),
-  })
-  .openapi({ title: "GetDisciplinesInput" });
+  ),
+});
 
-export const GetDisciplinesOutputSchema = z
-  .object({
-    disciplines: z.array(DisciplineEntitySchema),
-  })
-  .openapi({ title: "GetDisciplinesOutput" });
+export type CreateDisciplinesInput = z.infer<
+  typeof CreateDisciplinesInputSchema
+>;
 
-export const SlugInputSchema = z
-  .object({
-    slug: z.string().max(128).openapi({ example: "mathematics" }),
-  })
-  .openapi({ title: "SlugInput" });
+export const GetDisciplinesInputSchema = z.object({
+  withTags: z
+    .enum(["true", "false"])
+    .optional()
+    .transform((value) => value === "true"),
+  getDefault: z
+    .enum(["true", "false"])
+    .optional()
+    .transform((value) => value === "true"),
+  slugs: z.string().optional(),
+});
+
+export type GetDisciplinesInput = z.infer<typeof GetDisciplinesInputSchema>;
+
+export const SlugInputSchema = z.object({
+  slug: z.string().max(128),
+});
+
+export type SlugInput = z.infer<typeof SlugInputSchema>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
+
+export const DisciplineUpdateOutputSchema = z.object({
+  slug: z.string(),
+});
+
+export type DisciplineUpdateOutput = z.infer<
+  typeof DisciplineUpdateOutputSchema
+>;
+
+export const CreateDisciplinesOutputSchema = z.object({
+  disciplines: z.array(z.string()),
+});
+
+export type CreateDisciplinesOutput = z.infer<
+  typeof CreateDisciplinesOutputSchema
+>;
+
+export const GetDisciplinesOutputSchema = z.object({
+  disciplines: z.array(DisciplineEntitySchema),
+});
+
+export type GetDisciplinesOutput = z.infer<typeof GetDisciplinesOutputSchema>;