@zyacreatives/shared 1.3.8 → 1.3.9

package/src/schemas/project.ts

@@ -1,6 +1,6 @@
 import { z } from "@hono/zod-openapi";
 import { CLIENT_TYPES, ROLES } from "../constants";
-import { CreateFileInputSchema } from "./file";
+import { CreateFileInputSchema, FileEntitySchema } from "./file";
 export const ProjectEntitySchema = z
   .object({
     description: z.string().optional().openapi({
@@ -91,118 +91,6 @@ export const ProjectEntitySchema = z
     description: "Schema representing a project stored in the database.",
   });
 
-export const CreateProjectSchema = z
-  .object({
-    userId: z.string().openapi({
-      description: "CUID2 of the user creating the project.",
-      example: "ckl1y9xyz0000qv7a0h1efgh4",
-    }),
-    title: z.string().min(1).max(100).openapi({
-      description: "Title of the project, 1–100 characters.",
-      example: "E-commerce Mobile App",
-    }),
-    projectCreatorType: z.enum(ROLES).default(ROLES.CREATIVE).openapi({
-      description: "Type of creator who made this project.",
-      example: "CREATIVE",
-    }),
-    imagePlaceholderUrl: z.url().openapi({
-      description: "URL for the placeholder image of the project.",
-      example: "https://img.com",
-    }),
-    id: z.string().optional().openapi({
-      description: "CUID2 of the project.",
-      example: "ckl1y9xyz0000qv7a0h1efgh4",
-    }),
-    description: z.string().optional().openapi({
-      description: "Detailed description of the project, max 1000 characters.",
-      example:
-        "A modern e-commerce mobile application built with React Native.",
-    }),
-    overview: z.string().optional().openapi({
-      description: "Brief overview of the project.",
-      example: "A comprehensive e-commerce solution for mobile devices.",
-    }),
-    url: z.string().optional().openapi({
-      description: "URL to the project or live demo.",
-      example: "https://example.com/project",
-    }),
-    clientId: z.string().optional().openapi({
-      description: "CUID2 of the client if this is a client project.",
-      example: "ckl1y9xyz0000qv7a0h1efgh4",
-    }),
-    clientType: z
-      .enum(CLIENT_TYPES)
-      .optional()
-      .default(CLIENT_TYPES.NONE)
-      .openapi({
-        description: "Type of client for this project.",
-        example: "BRAND",
-      }),
-    clientName: z.string().optional().openapi({
-      description: "Name of the client.",
-      example: "Acme Corp",
-    }),
-    tags: z
-      .array(z.string())
-      .optional()
-      .openapi({
-        description: "Array of tags associated with the project.",
-        example: ["react-native", "e-commerce", "mobile"],
-      }),
-    searchVector: z.string().optional().openapi({
-      description: "Search vector for full-text search indexing.",
-      example: "ecommerce mobile app react native",
-    }),
-    isFeatured: z.boolean().optional().openapi({
-      description: "Whether the project is featured.",
-      example: true,
-    }),
-    startDate: z.coerce
-      .date()
-      .optional()
-      .openapi({
-        description: "Start date of the project.",
-        example: new Date("2024-01-01"),
-      }),
-    endDate: z.coerce
-      .date()
-      .optional()
-      .openapi({
-        description: "End date of the project.",
-        example: new Date("2024-06-30"),
-      }),
-    createdAt: z.coerce
-      .date()
-      .optional()
-      .openapi({
-        description: "Timestamp when the project was created.",
-        example: new Date("2024-01-01T00:00:00.000Z"),
-      }),
-    updatedAt: z.coerce
-      .date()
-      .optional()
-      .openapi({
-        description: "Timestamp when the project was last updated.",
-        example: new Date("2024-06-30T00:00:00.000Z"),
-      }),
-    files: z
-      .array(
-        CreateFileInputSchema.extend({
-          isPlaceholder: z.boolean().default(false),
-          order: z.number().int().default(1),
-        })
-      )
-      .optional()
-      .openapi({
-        description: "Array of files/images for the project.",
-        example: [],
-      }),
-  })
-  .openapi({
-    title: "Create Project",
-    description: "Schema for creating a new project.",
-  });
-
 export const ProjectFileEntitySchema = z
   .object({
     isPlaceholder: z.boolean().openapi({
@@ -240,16 +128,18 @@ export const ProjectSocialGraphEntitySchema = z
   })
   .openapi("ProjectSocialGraphEntity");
 
-export const ProjectWithFilesEntitySchema = ProjectEntitySchema.extend(
-  ProjectSocialGraphEntitySchema.shape
-)
-  .extend({
-    projectFiles: z
-      .array(ProjectFileEntitySchema)
-      .optional()
-      .openapi({ description: "Files associated with the project" }),
-  })
-  .openapi("ProjectWithFilesEntity");
+export const ProjectWithFilesEntitySchema = ProjectEntitySchema.extend({
+  projectFiles: z
+    .array(
+      ProjectFileEntitySchema.extend({
+        file: FileEntitySchema,
+      })
+    )
+    .optional()
+    .openapi({ description: "Files associated with the project." }),
+}).openapi({
+  title: "ProjectWithFilesEntity",
+});
 
 export const ProjectViewEntitySchema = z
   .object({
@@ -314,3 +204,341 @@ export const ProjectUpdateOutputEntitySchema = z
     id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
   })
   .openapi("ProjectUpdateOutputEntity");
+
+export const CreateProjectInputSchema = z
+  .object({
+    title: z.string().min(1).max(100).openapi({
+      description: "Title of the project, 1-100 characters.",
+      example: "E-commerce Mobile App",
+    }),
+    description: z.string().max(1000).optional().default("").openapi({
+      description: "Detailed description of the project, max 1000 characters.",
+      example:
+        "A modern e-commerce mobile application built with React Native.",
+    }),
+    url: z.string().openapi({
+      description: "URL to the project or live demo.",
+      example: "https://example.com/project",
+    }),
+    imagePlaceholderUrl: z.url().openapi({ example: "https://img.com" }),
+    tags: z
+      .array(z.string())
+      .default([])
+      .openapi({
+        description: "Array of tags associated with the project.",
+        example: ["react-native", "e-commerce", "mobile"],
+      }),
+    startDate: z.coerce.date().openapi({
+      description: "Start date of the project.",
+      example: new Date("2024-01-01"),
+    }),
+    endDate: z.coerce
+      .date()
+      .optional()
+      .openapi({
+        description: "End date of the project.",
+        example: new Date("2024-06-30"),
+      }),
+    overview: z.string().optional().openapi({
+      description: "Brief overview of the project.",
+      example: "A comprehensive e-commerce solution for mobile devices.",
+    }),
+    projectCreatorType: z.enum(ROLES).default(ROLES.CREATIVE).openapi({
+      description: "Type of creator who made this project.",
+      example: "CREATIVE",
+    }),
+    clientId: z.string().optional().openapi({
+      description: "CUID2 of the client if this is a client project.",
+      example: "ckl1y9xyz0000qv7a0h1efgh4",
+    }),
+    clientType: z.enum(CLIENT_TYPES).default(CLIENT_TYPES.NONE).openapi({
+      description: "Type of client for this project.",
+      example: "BRAND",
+    }),
+    clientName: z.string().optional().default("").openapi({
+      description: "Name of the client.",
+      example: "Acme Corp",
+    }),
+    files: z
+      .array(
+        CreateFileInputSchema.extend({
+          isPlaceholder: z.boolean().default(false),
+          order: z.int().default(1),
+        })
+      )
+      .openapi({
+        description: "Array of files/images for the project.",
+        example: [],
+      }),
+  })
+  .openapi({
+    title: "Create Project",
+    description: "Schema for creating a new project.",
+  });
+
+export const CreateProjectOutputSchema = ProjectEntitySchema;
+
+export const UpdateProjectInputSchema = z
+  .object({
+    id: z.cuid2().openapi({
+      description: "CUID2 identifier of the project to update.",
+      example: "ckl1z0abc0000qv7a0h1abcd2",
+    }),
+    title: z.string().optional().openapi({
+      description: "Updated title of the project.",
+      example: "Updated E-commerce Mobile App",
+    }),
+    description: z.string().optional().openapi({
+      description: "Updated description of the project.",
+      example: "An updated description of the project.",
+    }),
+    imagePlaceholderUrl: z.url().optional().openapi({
+      example: "https://img.com",
+    }),
+    overview: z.string().optional().openapi({
+      description: "Updated overview of the project.",
+      example: "Updated project overview.",
+    }),
+    url: z.url().optional().openapi({
+      description: "Updated URL to the project or live demo.",
+      example: "https://updated-example.com/project",
+    }),
+    clientId: z.cuid2().optional().openapi({
+      description: "Updated client ID.",
+      example: "ckl1y9xyz0000qv7a0h1efgh5",
+    }),
+    clientType: z.enum(["CREATIVE", "BRAND", "NONE"]).optional().openapi({
+      description: "Updated client type.",
+      example: "BRAND",
+    }),
+    clientName: z.string().optional().openapi({
+      description: "Updated client name.",
+      example: "Updated Acme Corp",
+    }),
+    projectCreatorType: z
+      .enum(["CREATIVE", "BRAND", "INVESTOR", "ADMIN"])
+      .optional()
+      .openapi({
+        description: "Updated project creator type.",
+        example: "CREATIVE",
+      }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({
+        description: "Updated array of tags.",
+        example: ["react-native", "e-commerce", "mobile", "updated"],
+      }),
+    isFeatured: z.boolean().optional().openapi({
+      description: "Whether the project should be featured.",
+      example: true,
+    }),
+    startDate: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Updated start date of the project.",
+        example: new Date("2024-02-01"),
+      }),
+    endDate: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Updated end date of the project.",
+        example: new Date("2024-07-30"),
+      }),
+    createdAt: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Creation date (read-only).",
+        example: new Date("2024-01-01T12:00:00Z"),
+      }),
+    updatedAt: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Last update date (read-only).",
+        example: new Date("2024-06-30T18:00:00Z"),
+      }),
+  })
+  .openapi({
+    title: "Update Project",
+    description: "Schema for updating an existing project.",
+  });
+
+export const UpdateProjectOutputSchema = ProjectEntitySchema;
+export const ProjectIdSchema = z.object({
+  projectId: z.cuid2(),
+});
+export const CommentOnProjectParamsSchema = ProjectIdSchema;
+export const CommentOnProjectInputSchema = z
+  .object({
+    content: z.string().openapi({
+      description: "Content of the comment.",
+      example: "This is a great project!",
+    }),
+    parentCommentId: z.cuid2().optional().openapi({
+      description: "CUID2 of the parent comment if this is a reply.",
+      example: "ckl1z0abc0000qv7a0h1abcd4",
+    }),
+  })
+  .openapi({
+    title: "Comment on Project",
+    description: "Schema for commenting on a project.",
+  });
+export const CommentOnProjectOutputSchema = ProjectCommentEntitySchema;
+
+export const DeleteProjectInputSchema = ProjectIdSchema;
+
+export const DeleteProjectCommentParamsSchema = z.object({
+  commentId: z.cuid2(),
+});
+
+export const DeleteProjectCommentOutputSchema = ProjectCommentEntitySchema;
+
+export const DeleteProjectOutputSchema = ProjectEntitySchema;
+
+export const GetProjectParamsSchema = ProjectIdSchema;
+
+export const GetProjectOutputSchema = ProjectWithFilesEntitySchema;
+
+export const BookmarkProjectParamsSchema = ProjectIdSchema;
+
+export const BookmarkProjectOutputSchema = ProjectBookmarkEntitySchema;
+
+export const LikeProjectParamsSchema = ProjectIdSchema;
+
+export const UnlikeProjectParamsSchema = ProjectIdSchema;
+
+export const ViewProjectInputSchema = z
+  .object({
+    projectId: z.cuid2().openapi({
+      description: "CUID2 identifier of the project being viewed.",
+      example: "ckl1z0abc0000qv7a0h1abcd2",
+    }),
+    id: z.cuid2().optional().openapi({
+      description: "CUID2 identifier of the view record (auto-generated).",
+      example: "ckl1z0abc0000qv7a0h1abcd5",
+    }),
+    userId: z.cuid2().optional().openapi({
+      description: "CUID2 of the user who viewed the project.",
+      example: "ckl1y9xyz0000qv7a0h1efgh3",
+    }),
+    sessionId: z.string().optional().openapi({
+      description: "Session ID for anonymous users.",
+      example: "sess_123456789",
+    }),
+    ipAddress: z.string().optional().openapi({
+      description: "IP address of the viewer.",
+      example: "192.168.1.1",
+    }),
+    userAgent: z.string().optional().openapi({
+      description: "User agent string of the viewer.",
+      example: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    }),
+    viewedAt: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Date and time when the project was viewed.",
+        example: new Date("2024-01-15T14:30:00Z"),
+      }),
+    viewDate: z
+      .date()
+      .optional()
+      .openapi({
+        description: "Date when the project was viewed.",
+        example: new Date("2024-01-15"),
+      }),
+  })
+  .openapi({
+    title: "View Project",
+    description: "Schema for recording a project view.",
+  });
+
+export const MinimalProjectSchema = ProjectEntitySchema.pick({
+  id: true,
+  title: true,
+  description: true,
+  tags: true,
+  startDate: true,
+  endDate: true,
+  imagePlaceholderUrl: true,
+}).openapi({
+  title: "MinimalProject",
+  description: "Subset of project fields for lightweight listings.",
+});
+
+export const ListProjectsInputSchema = z
+  .object({
+    query: z.string().optional().openapi({
+      description: "Search query for projects.",
+      example: "ecommerce app",
+    }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({
+        description: "Tags to filter projects by.",
+        example: ["react", "design"],
+      }),
+    clientName: z.string().optional().openapi({
+      description: "Client name to filter projects by.",
+      example: "Acme Corp",
+    }),
+    userId: z.string().optional().openapi({
+      description: "Filter projects by user ID.",
+      example: "ckl1y9xyz0000qv7a0h1efgh4",
+    }),
+    page: z.number().int().optional().default(1).openapi({
+      description: "Page number for pagination.",
+      example: 1,
+    }),
+    perPage: z.number().int().optional().default(10).openapi({
+      description: "Number of items per page.",
+      example: 10,
+    }),
+  })
+  .openapi({
+    title: "ListProjectsInput",
+    description: "Parameters for listing or searching projects.",
+  });
+
+export const ProjectWithProjectViewsEntitySchema = MinimalProjectSchema.extend({
+  views: z.array(ProjectViewEntitySchema).openapi({
+    description: "Array of project view records.",
+  }),
+}).openapi({
+  title: "ProjectWithProjectViewsEntity",
+  description: "Project entity with associated views.",
+});
+
+export const ProjectWithProjectCommentsEntitySchema =
+  MinimalProjectSchema.extend({
+    comments: z.array(ProjectCommentEntitySchema).openapi({
+      description: "Array of comments on the project.",
+    }),
+  }).openapi({
+    title: "ProjectWithProjectCommentsEntity",
+    description: "Project entity with associated comments.",
+  });
+
+export const ProjectWithProjectLikesEntitySchema = MinimalProjectSchema.extend({
+  likes: z.array(ProjectLikeEntitySchema).openapi({
+    description: "Array of likes on the project.",
+  }),
+}).openapi({
+  title: "ProjectWithProjectLikesEntity",
+  description: "Project entity with associated likes.",
+});
+
+export const ProjectWithProjectBookmarksEntitySchema =
+  MinimalProjectSchema.extend({
+    bookmarks: z.array(ProjectBookmarkEntitySchema).openapi({
+      description: "Array of bookmarks for the project.",
+    }),
+  }).openapi({
+    title: "ProjectWithProjectBookmarksEntity",
+    description: "Project entity with associated bookmarks.",
+  });

package/src/types/project.ts

@@ -1,112 +1,94 @@
-import type { ClientType, Role } from "../constants";
-import type { ProjectSocialGraphEntity } from "./common";
-import { FileEntity } from "./file";
-import type { MinimalUser } from "./user";
+import type { z } from "@hono/zod-openapi";
+import type {
+  ProjectEntitySchema,
+  ProjectFileEntitySchema,
+  ProjectWithFilesEntitySchema,
+  ProjectViewEntitySchema,
+  ProjectLikeEntitySchema,
+  ProjectCommentEntitySchema,
+  ProjectBookmarkEntitySchema,
+  ProjectUpdateOutputEntitySchema,
+  CreateProjectInputSchema,
+  CreateProjectOutputSchema,
+  UpdateProjectInputSchema,
+  UpdateProjectOutputSchema,
+  ProjectIdSchema,
+  CommentOnProjectParamsSchema,
+  CommentOnProjectInputSchema,
+  CommentOnProjectOutputSchema,
+  DeleteProjectInputSchema,
+  DeleteProjectCommentParamsSchema,
+  DeleteProjectCommentOutputSchema,
+  DeleteProjectOutputSchema,
+  GetProjectParamsSchema,
+  GetProjectOutputSchema,
+  BookmarkProjectParamsSchema,
+  BookmarkProjectOutputSchema,
+  LikeProjectParamsSchema,
+  UnlikeProjectParamsSchema,
+  ViewProjectInputSchema,
+  MinimalProjectSchema,
+  ListProjectsInputSchema,
+  ProjectWithProjectViewsEntitySchema,
+  ProjectWithProjectCommentsEntitySchema,
+  ProjectWithProjectLikesEntitySchema,
+  ProjectWithProjectBookmarksEntitySchema,
+} from "../schemas/project";
 
-export type ProjectFileEntity = {
-  id: string;
-  projectId: string;
-  fileId: string;
-  order: number;
-  isPlaceholder: boolean;
-};
+export type ProjectEntity = z.infer<typeof ProjectEntitySchema>;
+export type ProjectFileEntity = z.infer<typeof ProjectFileEntitySchema>;
 
-export type ProjectEntity = {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  userId: string;
-  title: string;
-  description?: string;
-  overview?: string;
-  url?: string;
-  clientId?: string;
-  clientType?: ClientType;
-  clientName?: string;
-  projectCreatorType: Role;
-  tags?: string[];
-  isFeatured?: boolean;
-  startDate?: Date;
-  imagePlaceholderUrl?: string;
-  endDate?: Date;
-};
-
-export type ProjectStatsEntity = ProjectSocialGraphEntity;
-
-export type ProjectViewEntity = {
-  id: string;
-  userId?: string;
-  ipAddress?: string;
-  userAgent?: string;
-  projectId: string;
-  sessionId?: string;
-  viewedAt: Date;
-  viewDate: Date;
-};
-
-export type ProjectLikeEntity = {
-  createdAt: Date;
-  userId: string;
-  projectId: string;
-};
-export type ProjectCommentEntity = {
-  id: string;
-  createdAt: Date;
-  userId: string;
-  projectId: string;
-  parentCommentId?: string;
-  content: string;
-};
-export type ProjectBookmarkEntity = {
-  createdAt: Date;
-  userId: string;
-  projectId: string;
-};
-export type ProjectUpdateOutputEntity = {
-  id: string;
-};
-export type MinimalProject = Pick<
-  ProjectEntity,
-  | "id"
-  | "title"
-  | "description"
-  | "tags"
-  | "startDate"
-  | "endDate"
-  | "imagePlaceholderUrl"
+export type ProjectWithFilesEntity = z.infer<
+  typeof ProjectWithFilesEntitySchema
+>;
+export type ProjectViewEntity = z.infer<typeof ProjectViewEntitySchema>;
+export type ProjectLikeEntity = z.infer<typeof ProjectLikeEntitySchema>;
+export type ProjectCommentEntity = z.infer<typeof ProjectCommentEntitySchema>;
+export type ProjectBookmarkEntity = z.infer<typeof ProjectBookmarkEntitySchema>;
+export type ProjectUpdateOutputEntity = z.infer<
+  typeof ProjectUpdateOutputEntitySchema
 >;
 
-export type ProjectWithClientEntity = MinimalProject & {
-  client: MinimalUser;
-};
-
-export type ProjectWithProjectFilesEntity = MinimalProject & {
-  projectFiles: (ProjectFileEntity & {
-    file: FileEntity;
-  })[];
-};
-
-export type ListProjectsInput = {
-  query?: string;
-  tags?: string[];
-  clientName?: string;
-  userId?: string;
-  page?: number;
-  perPage?: number;
-};
-
-export type ProjectWithProjectViewsEntity = MinimalProject & {
-  views: ProjectViewEntity[];
-};
-
-export type ProjectWithProjectCommentsEntity = MinimalProject & {
-  comments: ProjectCommentEntity[];
-};
+export type CreateProjectInput = z.infer<typeof CreateProjectInputSchema>;
+export type CreateProjectOutput = z.infer<typeof CreateProjectOutputSchema>;
+export type UpdateProjectInput = z.infer<typeof UpdateProjectInputSchema>;
+export type UpdateProjectOutput = z.infer<typeof UpdateProjectOutputSchema>;
 
-export type ProjectWithProjectLikesEntity = MinimalProject & {
-  likes: ProjectLikeEntity[];
-};
+export type ProjectId = z.infer<typeof ProjectIdSchema>;
+export type CommentOnProjectParams = z.infer<
+  typeof CommentOnProjectParamsSchema
+>;
+export type CommentOnProjectInput = z.infer<typeof CommentOnProjectInputSchema>;
+export type CommentOnProjectOutput = z.infer<
+  typeof CommentOnProjectOutputSchema
+>;
+export type DeleteProjectInput = z.infer<typeof DeleteProjectInputSchema>;
+export type DeleteProjectCommentParams = z.infer<
+  typeof DeleteProjectCommentParamsSchema
+>;
+export type DeleteProjectCommentOutput = z.infer<
+  typeof DeleteProjectCommentOutputSchema
+>;
+export type DeleteProjectOutput = z.infer<typeof DeleteProjectOutputSchema>;
+export type GetProjectParams = z.infer<typeof GetProjectParamsSchema>;
+export type GetProjectOutput = z.infer<typeof GetProjectOutputSchema>;
+export type BookmarkProjectParams = z.infer<typeof BookmarkProjectParamsSchema>;
+export type BookmarkProjectOutput = z.infer<typeof BookmarkProjectOutputSchema>;
+export type LikeProjectParams = z.infer<typeof LikeProjectParamsSchema>;
+export type UnlikeProjectParams = z.infer<typeof UnlikeProjectParamsSchema>;
+export type ViewProjectInput = z.infer<typeof ViewProjectInputSchema>;
 
-export type ProjectWithProjectBookmarksEntity = MinimalProject & {
-  bookmarks: ProjectBookmarkEntity[];
-};
+export type MinimalProject = z.infer<typeof MinimalProjectSchema>;
+export type ListProjectsInput = z.infer<typeof ListProjectsInputSchema>;
+export type ProjectWithProjectViewsEntity = z.infer<
+  typeof ProjectWithProjectViewsEntitySchema
+>;
+export type ProjectWithProjectCommentsEntity = z.infer<
+  typeof ProjectWithProjectCommentsEntitySchema
+>;
+export type ProjectWithProjectLikesEntity = z.infer<
+  typeof ProjectWithProjectLikesEntitySchema
+>;
+export type ProjectWithProjectBookmarksEntity = z.infer<
+  typeof ProjectWithProjectBookmarksEntitySchema
+>;