@zyacreatives/shared 2.5.54 → 2.5.56

package/src/schemas/project.ts

@@ -1,4 +1,5 @@
 import { z } from "@hono/zod-openapi";
+
 import {
   CLIENT_TYPES,
   PROJECT_STATUS,
@@ -6,50 +7,86 @@ import {
   VENTURE_STAGES,
   WAGES_CURRENCY,
 } from "../constants";
+
 import { CommentEntitySchema } from "./comment";
 import { BookmarkEntitySchema } from "./bookmark";
-import { ViewEntitySchema } from "./view";
 import { MinimalUserSchema } from "./user";
 import { ActivitySchema } from "./activity";
 import { FileEntitySchema } from "./file";
 import { LikeEntitySchema } from "./like";
 
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const ProjectShape = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  overview: z.string().optional(),
+  url: z.url().optional(),
+
+  imagePlaceholderUrl: z.url(),
+
+  tags: z.array(z.string()).optional(),
+
+  projectCreatorType: z.enum(ROLES),
+
+  clientId: z.cuid2().optional(),
+  clientType: z.enum(CLIENT_TYPES).optional(),
+  clientName: z.string().optional(),
+
+  status: z.enum(PROJECT_STATUS),
+
+  isFeatured: z.boolean().optional(),
+
+  problemBeingSolved: z.string().max(600).optional(),
+  whoItsFor: z.string().max(600).optional(),
+
+  ventureStage: z.enum(VENTURE_STAGES).optional(),
+  capitalLookingToRaise: z.number(),
+  capitalLookingToRaiseCurrency: z.enum(WAGES_CURRENCY).optional(),
+
+  currentTraction: z.string().max(600),
+  isOpenToInvestment: z.boolean().default(false),
+
+  startDate: z.iso.datetime().optional(),
+  endDate: z.iso.datetime().optional(),
+});
+
+export type ProjectShapeType = z.infer<typeof ProjectShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
 export const ProjectEntitySchema = z
   .object({
     id: z.cuid2(),
     userId: z.cuid2(),
-    title: z.string(),
-    description: z.string().optional(),
-    overview: z.string().optional(),
-    url: z.url().optional(),
-    imagePlaceholderUrl: z.url(),
-    tags: z.array(z.string()).optional(),
-    projectCreatorType: z.enum(ROLES),
-    clientId: z.cuid2().optional(),
-    status: z.enum(PROJECT_STATUS),
-    clientType: z.enum(CLIENT_TYPES).optional(),
-    clientName: z.string().optional(),
-    isFeatured: z.boolean().optional(),
-    problemBeingSolved: z.string().max(600).optional(),
-    whoItsFor: z.string().max(600).optional(),
-    ventureStage: z.enum(VENTURE_STAGES).optional(),
-    capitalLookingToRaise: z.number(),
-    capitalLookingToRaiseCurrency: z.enum(WAGES_CURRENCY).optional(),
-    currentTraction: z.string().max(600),
-    isOpenToInvestment: z.boolean().default(false),
-    startDate: z.coerce.date().optional(),
-    endDate: z.coerce.date().optional(),
-    createdAt: z.coerce.date(),
-    updatedAt: z.coerce.date(),
-    version: z.number().int(),
+
+    ...ProjectShape.shape,
+
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    version: z.int(),
   })
-  .openapi("ProjectEntity");
+  .openapi("Project");
 
 export type ProjectEntity = z.infer<typeof ProjectEntitySchema>;
 
+/**
+ * --------------------------------
+ * DERIVED ENTITIES
+ * --------------------------------
+ */
+
 export const ProjectWithFilesEntitySchema = ProjectEntitySchema.extend({
   files: z.array(FileEntitySchema).optional(),
-}).openapi("ProjectWithFilesEntity");
+}).openapi("ProjectWithFiles");
 
 export type ProjectWithFilesEntity = z.infer<
   typeof ProjectWithFilesEntitySchema
@@ -74,7 +111,92 @@ export const ProjectSocialGraphEntitySchema = z
     noOfBookmarks: z.number().int().optional(),
     noOfViews: z.number().int().optional(),
   })
-  .openapi("ProjectSocialGraphEntity");
+  .openapi("ProjectSocialGraph");
+
+export type ProjectSocialGraphEntity = z.infer<
+  typeof ProjectSocialGraphEntitySchema
+>;
+
+export type PostSocialGraphEntity = z.infer<
+  typeof ProjectSocialGraphEntitySchema
+>;
+
+export const ProjectDetailsEntitySchema = ProjectEntitySchema.extend({
+  user: MinimalUserSchema,
+  files: z.array(FileEntitySchema).optional(),
+}).openapi("ProjectDetails");
+
+export type ProjectDetailsEntity = z.infer<typeof ProjectDetailsEntitySchema>;
+
+export const ProjectWithProjectCommentsEntitySchema =
+  MinimalProjectSchema.extend({
+    comments: z.array(CommentEntitySchema),
+  }).openapi("ProjectWithProjectComments");
+
+export type ProjectWithProjectCommentsEntity = z.infer<
+  typeof ProjectWithProjectCommentsEntitySchema
+>;
+
+export const ProjectWithLikesEntitySchema = MinimalProjectSchema.extend({
+  likes: z.array(
+    ActivitySchema.extend({
+      followsYou: z.boolean().optional(),
+      isFollowing: z.boolean().optional(),
+    }),
+  ),
+}).openapi("ProjectWithLikes");
+
+export type ProjectWithLikesEntity = z.infer<
+  typeof ProjectWithLikesEntitySchema
+>;
+
+export const ProjectWithProjectBookmarksEntitySchema =
+  MinimalProjectSchema.extend({
+    bookmarks: z.array(BookmarkEntitySchema),
+  }).openapi("ProjectWithProjectBookmarks");
+
+export type ProjectWithProjectBookmarksEntity = z.infer<
+  typeof ProjectWithProjectBookmarksEntitySchema
+>;
+
+/**
+ * --------------------------------
+ * INPUT HELPERS
+ * --------------------------------
+ */
+
+const coerceArray = (value: unknown) => {
+  if (typeof value === "string") return value === "" ? [] : value.split(",");
+  return value;
+};
+
+const coerceBoolean = (value: unknown) => {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+};
+
+const nullableStringToUndefined = (value: unknown) => {
+  if (value === "" || value === null || value === undefined) return undefined;
+  return value;
+};
+
+const urlInputSchema = z
+  .string()
+  .transform((value) => {
+    if (!value) return value;
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      return value;
+    }
+    return `https://${value}`;
+  })
+  .pipe(z.url().or(z.literal("")));
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
 
 export const CreateProjectInputSchema = z
   .object({
@@ -91,67 +213,81 @@ export type CreateProjectInput = z.infer<typeof CreateProjectInputSchema>;
 export const UpdateProjectInputSchema = z
   .object({
     id: z.cuid2(),
+
     title: z.string().optional(),
+
     description: z
       .string()
       .min(10, "Add a bit more detail to your description.")
       .optional(),
+
     overview: z.string().optional(),
-    url: z
-      .string()
-      .transform((val) => {
-        if (!val) return val;
-        if (val.startsWith("http://") || val.startsWith("https://")) return val;
-        return `https://${val}`;
-      })
-      .pipe(z.url("Check your link.").or(z.literal("")))
-      .optional(),
+
+    url: urlInputSchema.optional(),
+
     imagePlaceholderUrl: z.url().optional().or(z.literal("")),
+
     tags: z.array(z.string()).optional(),
+
     projectCreatorType: z.enum(ROLES).optional(),
-    clientId: z
-      .string()
-      .optional()
-      .transform((val) => (val === "" || val === undefined ? undefined : val))
-      .pipe(z.cuid2().optional()),
+
+    clientId: z.preprocess(nullableStringToUndefined, z.cuid2().optional()),
+
     clientType: z.enum(CLIENT_TYPES).optional(),
     clientName: z.string().optional(),
+
     isFeatured: z.boolean().optional(),
+
     status: z.enum(PROJECT_STATUS).optional(),
+
     problemBeingSolved: z
       .string()
       .min(20, "Describe the problem you're solving.")
       .max(600)
       .optional(),
+
     whoItsFor: z
       .string()
       .min(5, "Tell us who this is for.")
       .max(600)
       .optional(),
+
     ventureStage: z.enum(VENTURE_STAGES).optional(),
+
     capitalLookingToRaise: z.number().optional(),
     capitalLookingToRaiseCurrency: z.enum(WAGES_CURRENCY).optional(),
+
     currentTraction: z
       .string()
       .min(10, "Share your current traction.")
       .max(600)
       .optional(),
+
     isOpenToInvestment: z.boolean().default(false),
-    startDate: z.coerce.date().optional(),
-    endDate: z.coerce.date().optional(),
-    version: z.number().int().default(1),
+
+    startDate: z.iso.datetime().optional(),
+    endDate: z.iso.datetime().optional(),
+
+    version: z.int().default(1),
   })
   .superRefine(({ startDate, endDate }, ctx) => {
+    if (!startDate) return;
+
     const today = new Date();
     today.setHours(0, 0, 0, 0);
-    if (startDate && startDate > today) {
+
+    const parsedStartDate = new Date(startDate);
+    const parsedEndDate = endDate ? new Date(endDate) : undefined;
+
+    if (parsedStartDate > today) {
       ctx.addIssue({
         path: ["startDate"],
         code: "custom",
         message: "Start date cannot be in the future.",
       });
     }
-    if (startDate && endDate && startDate > endDate) {
+
+    if (parsedEndDate && parsedStartDate > parsedEndDate) {
       ctx.addIssue({
         path: ["endDate"],
         code: "custom",
@@ -167,182 +303,164 @@ export const CommentOnProjectInputSchema = CommentEntitySchema;
 
 export type CommentOnProjectInput = z.infer<typeof CommentOnProjectInputSchema>;
 
-export const ProjectDetailsEntitySchema = ProjectEntitySchema.extend({
-  user: MinimalUserSchema,
-  files: z.array(FileEntitySchema).optional(),
-}).openapi("ProjectDetailsEntity");
+export const SearchProjectsInputSchema = z
+  .object({
+    query: z.string().optional(),
 
-export type ProjectDetailsEntity = z.infer<typeof ProjectDetailsEntitySchema>;
+    limit: z.coerce.number().min(1).max(100).default(40),
+    cursor: z.string().optional(),
 
-export const GetProjectOutputSchema = ProjectDetailsEntitySchema.extend({
-  isLiked: z.boolean().optional(),
-  isBookmarked: z.boolean().optional(),
-}).openapi("GetProjectOutput");
+    tags: z.preprocess(coerceArray, z.array(z.string())).optional(),
 
-export type GetProjectOutput = z.infer<typeof GetProjectOutputSchema>;
+    isOpenToInvestment: z.preprocess(coerceBoolean, z.boolean()).optional(),
+
+    minCapital: z.coerce.number().optional(),
+    maxCapital: z.coerce.number().optional(),
+
+    ventureStages: z
+      .preprocess(coerceArray, z.array(z.enum(VENTURE_STAGES)))
+      .optional(),
+
+    projectCreatorTypes: z
+      .preprocess(coerceArray, z.array(z.enum(ROLES)))
+      .optional(),
+
+    clientTypes: z
+      .preprocess(coerceArray, z.array(z.enum(CLIENT_TYPES)))
+      .optional(),
+  })
+  .openapi("SearchProjectsInput");
+
+export type SearchProjectsInput = z.infer<typeof SearchProjectsInputSchema>;
+
+export const ProjectIdSchema = z.object({
+  projectId: z.cuid2(),
+});
+
+export type ProjectIdInput = z.infer<typeof ProjectIdSchema>;
+
+/**
+ * --------------------------------
+ * SEARCH DOCUMENT
+ * --------------------------------
+ */
 
 export const ProjectSearchDocumentSchema = z
   .object({
-    id: z.string(),
-    userId: z.string(),
+    id: z.cuid2(),
+    userId: z.cuid2(),
+
     title: z.string(),
     imagePlaceholderUrl: z.url(),
+
     projectCreatorType: z.enum(ROLES),
     isOpenToInvestment: z.boolean(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
+
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+
     description: z.string().optional(),
+
     capitalLookingToRaise: z.number().optional(),
     capitalLookingToRaiseCurrency: z.enum(WAGES_CURRENCY).optional(),
     ventureStage: z.enum(VENTURE_STAGES).optional(),
+
     url: z.url().optional(),
     tags: z.array(z.string()).optional(),
+
     creatorUsername: z.string(),
     creatorImageUrl: z.string(),
     creatorName: z.string(),
-    clientId: z.string().optional(),
+
+    clientId: z.cuid2().optional(),
     clientType: z.enum(CLIENT_TYPES).optional(),
     clientName: z.string().optional(),
+
     isFeatured: z.boolean().optional(),
-    startDate: z.number().optional(),
-    endDate: z.number().optional(),
+
+    startDate: z.iso.datetime().optional(),
+    endDate: z.iso.datetime().optional(),
+
     files: z.array(FileEntitySchema).optional(),
   })
   .openapi("ProjectSearchDocument");
 
 export type ProjectSearchDocument = z.infer<typeof ProjectSearchDocumentSchema>;
 
-const coerceArray = (val: unknown) => {
-  if (typeof val === "string") return val === "" ? [] : val.split(",");
-  return val;
-};
-
-const coerceBoolean = (val: unknown) => {
-  if (val === "true") return true;
-  if (val === "false") return false;
-  return val;
-};
-
-export const SearchProjectsInputSchema = z
-  .object({
-    query: z.string().optional(),
-
-    limit: z.coerce.number().optional().default(40),
-    cursor: z.string().optional().nullable(),
-
-    tags: z.preprocess(coerceArray, z.array(z.string())).optional(),
-
-    isOpenToInvestment: z.preprocess(coerceBoolean, z.boolean()).optional(),
-
-    minCapital: z.coerce.number().optional(),
-    maxCapital: z.coerce.number().optional(),
-
-    ventureStages: z
-      .preprocess(coerceArray, z.array(z.enum(VENTURE_STAGES)))
-      .optional(),
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
 
-    projectCreatorTypes: z
-      .preprocess(coerceArray, z.array(z.enum(ROLES)))
-      .optional(),
-
-    clientTypes: z
-      .preprocess(coerceArray, z.array(z.enum(CLIENT_TYPES)))
-      .optional(),
-  })
-  .openapi("SearchProjectsInput");
+export const GetProjectOutputSchema = ProjectDetailsEntitySchema.extend({
+  isLiked: z.boolean().optional(),
+  isBookmarked: z.boolean().optional(),
+}).openapi("GetProjectOutput");
 
-export type SearchProjectsInput = z.infer<typeof SearchProjectsInputSchema>;
+export type GetProjectOutput = z.infer<typeof GetProjectOutputSchema>;
 
 export const SearchProjectsOutputSchema = z
   .object({
     projects: z.array(ProjectSearchDocumentSchema),
-    nextCursor: z.string().optional().nullable(),
+    nextCursor: z.string().optional(),
   })
   .openapi("SearchProjectsOutput");
 
 export type SearchProjectsOutput = z.infer<typeof SearchProjectsOutputSchema>;
 
-export const ProjectWithProjectCommentsEntitySchema =
-  MinimalProjectSchema.extend({
-    comments: z.array(CommentEntitySchema),
-  }).openapi("ProjectWithProjectCommentsEntity");
-
-export type ProjectWithProjectCommentsEntity = z.infer<
-  typeof ProjectWithProjectCommentsEntitySchema
->;
-
 export const GetProjectWithCommentsOutputSchema =
   ProjectWithProjectCommentsEntitySchema.extend({
-    nextCursor: z.string().optional().nullable(),
+    nextCursor: z.string().optional(),
   }).openapi("GetProjectWithCommentsOutput");
 
 export type GetProjectWithCommentsOutput = z.infer<
   typeof GetProjectWithCommentsOutputSchema
 >;
 
-export const ProjectWithLikesEntitySchema = MinimalProjectSchema.extend({
-  likes: z.array(
-    ActivitySchema.extend({
-      followsYou: z.boolean().optional(),
-      isFollowing: z.boolean().optional(),
-    }),
-  ),
-}).openapi("ProjectWithLikesEntity");
-
-export type ProjectWithLikesEntity = z.infer<
-  typeof ProjectWithLikesEntitySchema
->;
-
 export const GetProjectWithLikesOutputSchema =
   ProjectWithLikesEntitySchema.extend({
-    nextCursor: z.string().optional().nullable(),
+    nextCursor: z.string().optional(),
   }).openapi("GetProjectWithLikesOutput");
 
 export type GetProjectWithLikesOutput = z.infer<
   typeof GetProjectWithLikesOutputSchema
 >;
 
-export const ProjectWithProjectViewsEntitySchema = MinimalProjectSchema.extend({
-  views: z.array(ViewEntitySchema),
-}).openapi("ProjectWithProjectViewsEntity");
-
-export type ProjectWithProjectViewsEntity = z.infer<
-  typeof ProjectWithProjectViewsEntitySchema
->;
-
-export const ProjectWithProjectBookmarksEntitySchema =
-  MinimalProjectSchema.extend({
-    bookmarks: z.array(BookmarkEntitySchema),
-  }).openapi("ProjectWithProjectBookmarksEntity");
-
-export type ProjectWithProjectBookmarksEntity = z.infer<
-  typeof ProjectWithProjectBookmarksEntitySchema
->;
-
 export const ProjectUpdateOutputEntitySchema = z.object({
   id: z.cuid2(),
 });
 
+export type ProjectUpdateOutputEntity = z.infer<
+  typeof ProjectUpdateOutputEntitySchema
+>;
+
 export const CreateProjectOutputSchema = ProjectEntitySchema;
+
 export type CreateProjectOutput = z.infer<typeof CreateProjectOutputSchema>;
 
 export const UpdateProjectOutputSchema = ProjectEntitySchema;
+
 export type UpdateProjectOutput = z.infer<typeof UpdateProjectOutputSchema>;
 
 export const DeleteProjectOutputSchema = ProjectEntitySchema;
+
 export type DeleteProjectOutput = z.infer<typeof DeleteProjectOutputSchema>;
 
 export const CommentOnProjectOutputSchema = CommentEntitySchema.omit({
   likesCount: true,
   isLiked: true,
 });
+
 export type CommentOnProjectOutput = z.infer<
   typeof CommentOnProjectOutputSchema
 >;
 
-export const ProjectIdSchema = z.object({ projectId: z.cuid2() });
-export type ProjectIdInput = z.infer<typeof ProjectIdSchema>;
+/**
+ * --------------------------------
+ * ALIASES
+ * --------------------------------
+ */
 
-export type ProjectViewEntity = z.infer<typeof ViewEntitySchema>;
 export type ProjectLikeEntity = z.infer<typeof LikeEntitySchema>;
 export type ProjectCommentEntity = z.infer<typeof CommentEntitySchema>;

package/src/schemas/user-strike.ts

@@ -18,4 +18,10 @@ export const UpsertUserStrikeInputSchema = z.object({
   parentType: z.enum(ACTIVITY_PARENT_TYPES).optional(),
 });
 
-export const UpsertUserStrikeOutputSchema = UserStrikeEntitySchema;
+export const UpsertUserStrikeOutputSchema = UserStrikeEntitySchema;
+
+export type UserStrikeEntity = z.infer<typeof UserStrikeEntitySchema>;
+export type UpsertUserStrikeInput = z.infer<typeof UpsertUserStrikeInputSchema>;
+export type UpsertUserStrikeOutput = z.infer<
+  typeof UpsertUserStrikeOutputSchema
+>;

package/src/schemas/user.ts

@@ -22,11 +22,7 @@ import { LikeEntitySchema } from "./like";
 import { BrandEntitySchema } from "./brand";
 import { CreativeEntitySchema } from "./creative";
 import { InvestorEntitySchema } from "./investor";
-import {
-  FeedPostEntitySchema,
-  PostEntitySchema,
-  PostWithFilesEntitySchema,
-} from "./post";
+import { PostEntitySchema, PostWithFilesEntitySchema } from "./post";
 import { JobSearchDocumentSchema } from "./job";
 import { ProductEntitySchema } from "./product";
 
@@ -226,7 +222,7 @@ export const UserWithJobBookmarksInputSchema = z.object({
 export type UserAuthStatusEntity = z.infer<typeof UserAuthStatusEntitySchema>;
 export type UserWithJobBookmarksInput = z.infer<
   typeof UserWithJobBookmarksEntitySchema
->; 
+>;
 
 /**
  * --------------------------------

package/src/schemas/username.ts

@@ -1,11 +1,13 @@
 import { z } from "@hono/zod-openapi";
 
-export const UsernameSchema = z.object({
+export const UsernameSchema = z.object({
   username: z
     .string()
     .min(3, { message: "Username must be at least 3 characters" })
     .max(32, { message: "Username must be at most 32 characters" })
     .regex(/^[a-zA-Z0-9_]+$/, {
       message: "Username may only contain letters, numbers, and underscores",
-    }),
-});
+    }),
+});
+
+export type UsernameInput = z.infer<typeof UsernameSchema>;

package/src/schemas/view.ts

@@ -1,50 +0,0 @@
-import { z } from "@hono/zod-openapi";
-import { ACTIVITY_PARENT_TYPES } from "../constants";
-
-export const ViewEntitySchema = z
-  .object({
-    id: z.cuid2().openapi({
-      description: "Unique identifier of the view record.",
-      title: "View ID",
-    }),
-    userId: z.cuid2().nullable().openapi({
-      description:
-        "Identifier of the user who viewed the entity, if authenticated.",
-      title: "User ID",
-    }),
-    ipAddress: z.string().nullable().openapi({
-      description: "IP address from which the entity was viewed.",
-      title: "IP Address",
-    }),
-    userAgent: z.string().nullable().openapi({
-      description:
-        "User agent string identifying the client device or browser.",
-      title: "User Agent",
-    }),
-    parentId: z.cuid2().openapi({
-      description: "Identifier of the parent entity being viewed.",
-      title: "Parent ID",
-    }),
-    parentType: z.enum(ACTIVITY_PARENT_TYPES).openapi({
-      description: "Type of the parent entity (e.g., project, post, etc.).",
-      title: "Parent Type",
-    }),
-    sessionId: z.string().nullable().openapi({
-      description:
-        "Session identifier associated with the view event, if available.",
-      title: "Session ID",
-    }),
-    viewedAt: z.coerce.date().optional().openapi({
-      description: "Exact timestamp when the view occurred.",
-      title: "Viewed At",
-    }),
-    viewDate: z.coerce.date().optional().openapi({
-      description:
-        "Calendar date corresponding to the view event, used for aggregation.",
-      title: "View Date",
-    }),
-  })
-  .openapi({
-    description: "Represents a record of a single view event for an entity.",
-    title: "View",
-  });

package/src/types/activity.ts

@@ -1,4 +0,0 @@
-import z from "zod";
-import { ActivitySchema } from "../schemas/activity";
-
-export type ActivityEntity = z.infer<typeof ActivitySchema>;

package/src/types/auth.ts

@@ -1,5 +0,0 @@
-import z from "zod";
-import { LoginSchema, RegisterSchema } from "../schemas/auth";
-
-export type RegisterInput = z.infer<typeof RegisterSchema>;
-export type LoginInput = z.infer<typeof LoginSchema>;