@zyacreatives/shared 1.1.4 → 1.2.2

package/src/schemas/project.ts

@@ -0,0 +1,162 @@
+import { z } from "@hono/zod-openapi";
+import { CLIENT_TYPES, ClientType, Role, ROLES } from "../constants";
+
+export const ProjectEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    createdAt: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    updatedAt: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    title: z.string().openapi({ example: "Brand Identity Design" }),
+    description: z
+      .string()
+      .optional()
+      .openapi({ example: "A full rebrand for a fashion label." }),
+    overview: z
+      .string()
+      .optional()
+      .openapi({ example: "Detailed project story and outcomes." }),
+    url: z
+      .string()
+      .url()
+      .optional()
+      .openapi({ example: "https://example.com/project" }),
+    clientId: z.string().optional().openapi({ example: "client_abc123" }),
+    clientType: z
+      .enum(Object.values(CLIENT_TYPES) as [ClientType, ...ClientType[]])
+      .optional()
+      .openapi({ example: "BRAND" }),
+    clientName: z.string().optional().openapi({ example: "Nike" }),
+    projectCreatorType: z
+      .enum(Object.values(ROLES) as [Role, ...Role[]])
+      .openapi({ example: "CREATIVE" }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["branding", "logo"] }),
+    isFeatured: z.boolean().optional().openapi({ example: false }),
+    startDate: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-06-01T00:00:00.000Z" }),
+    endDate: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-07-15T00:00:00.000Z" }),
+    imagePlaceholderUrl: z
+      .string()
+      .url()
+      .optional()
+      .openapi({ example: "https://example.com/project-image.png" }),
+  })
+  .openapi("ProjectEntity");
+
+export const ProjectFileEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "pfe_cksd0v6q0000s9a5y8z7p3x9" }),
+    projectId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    url: z
+      .string()
+      .url()
+      .openapi({ example: "https://cdn.example.com/project/image.jpg" }),
+    mimeType: z.string().openapi({ example: "image/jpeg" }),
+    fileSize: z.number().int().positive().openapi({ example: 1500000 }), // size in bytes
+  })
+  .openapi("ProjectFileEntity");
+
+export const ProjectSocialGraphEntitySchema = z
+  .object({
+    noOfLikes: z.number().int().optional().openapi({ example: 150 }),
+    noOfComments: z.number().int().optional().openapi({ example: 45 }),
+    noOfBookmarks: z.number().int().optional().openapi({ example: 22 }),
+    noOfViews: z.number().int().optional().openapi({ example: 1200 }),
+  })
+  .openapi("ProjectSocialGraphEntity");
+
+export const UserSocialGraphEntitySchema = z
+  .object({
+    followerCount: z.number().int().optional().openapi({ example: 5000 }),
+    followingCount: z.number().int().optional().openapi({ example: 150 }),
+  })
+  .openapi("UserSocialGraphEntity");
+
+export const ProjectWithFilesEntitySchema = ProjectEntitySchema.merge(
+  ProjectSocialGraphEntitySchema
+)
+  .extend({
+    projectFiles: z
+      .array(ProjectFileEntitySchema)
+      .optional()
+      .openapi({ description: "Files associated with the project" }),
+  })
+  .openapi("ProjectWithFilesEntity");
+
+export const ProjectViewEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "view_cksd0v6q0000s9a5y8z7p3x9" }),
+    userId: z.cuid2().optional().openapi({ example: "user_view_xyz" }),
+    ipAddress: z.ipv4().optional().openapi({ example: "192.168.1.1" }),
+    userAgent: z
+      .string()
+      .optional()
+      .openapi({ example: "Mozilla/5.0 (Windows NT 10.0; Win64)" }),
+    projectId: z.cuid2().openapi({ example: "proj_abc456" }),
+    sessionId: z.string().optional().openapi({ example: "sess_xyz789" }),
+    viewedAt: z.coerce.date().openapi({ example: "2025-10-14T10:30:00.000Z" }),
+    viewDate: z.coerce.date().openapi({ example: "2025-10-14T00:00:00.000Z" }),
+  })
+  .openapi("ProjectViewEntity");
+
+export const ProjectLikeEntitySchema = z
+  .object({
+    createdAt: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-10-13T11:00:00.000Z" }),
+    userId: z.cuid2().openapi({ example: "user_liker_123" }),
+    projectId: z.cuid2().openapi({ example: "proj_abc456" }),
+  })
+  .openapi("ProjectLikeEntity");
+
+export const ProjectCommentEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "comment_id_1" }),
+    createdAt: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-10-13T12:00:00.000Z" }),
+    userId: z.cuid2().openapi({ example: "user_commenter_456" }),
+    projectId: z.cuid2().openapi({ example: "proj_abc456" }),
+    parentCommentId: z
+      .cuid2()
+      .optional()
+      .openapi({ example: "comment_id_parent_1" }),
+    content: z
+      .string()
+      .min(1)
+      .openapi({ example: "Amazing work on the color palette!" }),
+  })
+  .openapi("ProjectCommentEntity");
+
+export const ProjectBookmarkEntitySchema = z
+  .object({
+    createdAt: z.coerce
+      .date()
+      .optional()
+      .openapi({ example: "2025-10-13T13:00:00.000Z" }),
+    userId: z.cuid2().openapi({ example: "user_bookmark_789" }),
+    projectId: z.cuid2().openapi({ example: "proj_abc456" }),
+  })
+  .openapi("ProjectBookmarkEntity");
+
+export const ProjectUpdateOutputEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+  })
+  .openapi("ProjectUpdateOutputEntity");

package/src/schemas/user.ts

@@ -1,29 +1,14 @@
 import { z } from "@hono/zod-openapi";
 
-import {
-  ROLES,
-  USER_STATUSES,
-  ONBOARDING_PAGES,
-  EXPERIENCE_LEVELS,
-  INVESTOR_TYPES,
-  INVESTMENT_SIZES,
-  GEOGRAPHIC_FOCUS,
-} from "../constants";
-import type {
-  Role,
-  UserStatus,
-  OnboardingPage,
-  ExperienceLevel,
-  InvestorType,
-  InvestmentSize,
-  GeographicFocus,
-} from "../constants";
+import { ROLES, USER_STATUSES, ONBOARDING_PAGES } from "../constants";
+import type { Role, UserStatus, OnboardingPage } from "../constants";
 import { UserSocialGraphEntitySchema } from "./common";
+import { ProjectBookmarkEntitySchema, ProjectEntitySchema } from "./project";
 
 export const BaseUserEntitySchema = z
   .object({
     id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
-    email: z.email().openapi({ example: "user@example.com" }),
+    email: z.string().email().openapi({ example: "user@example.com" }),
     emailVerified: z.boolean().openapi({ example: true }),
     name: z.string().optional().openapi({ example: "John Doe" }),
     image: z
@@ -47,12 +32,8 @@ export const BaseUserEntitySchema = z
       .openapi({
         example: "DONE",
       }),
-    createdAt: z.iso
-      .datetime()
-      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
-    updatedAt: z.iso
-      .datetime()
-      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    createdAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
   })
   .openapi("BaseUserEntity");
 
@@ -70,56 +51,53 @@ export const UserEntitySchema = BaseUserEntitySchema.merge(
 ).openapi("UserEntity");
 
 export const UserProfileEntitySchema = UserEntitySchema.extend({
-  profileType: z.enum(["creative", "brand", "investor"]).optional().openapi({
-    example: "creative",
-  }),
-  bio: z.string().optional().openapi({
-    example: "Passionate digital artist focusing on UI/UX.",
-  }),
-  location: z.string().optional().openapi({
-    example: "Lagos, Nigeria",
-  }),
-  experienceLevel: z
-    .enum(
-      Object.values(EXPERIENCE_LEVELS) as [
-        ExperienceLevel,
-        ...ExperienceLevel[]
-      ]
-    )
-    .optional()
-    .openapi({ example: EXPERIENCE_LEVELS.YEAR_1_3 }),
-  disciplines: z
-    .array(z.string())
-    .optional()
-    .openapi({
-      example: ["ui-ux", "frontend"],
-    }),
-  tags: z
-    .array(z.string())
-    .optional()
-    .openapi({
-      example: ["react", "design", "product"],
-    }),
-  brandName: z.string().optional().openapi({
-    example: "Acme Creative Studio",
-  }),
-  websiteURL: z.string().optional().openapi({
-    example: "https://acme-creative.com",
-  }),
-  investorType: z
-    .enum(Object.values(INVESTOR_TYPES) as [InvestorType, ...InvestorType[]])
-    .optional()
-    .openapi({ example: INVESTOR_TYPES.ANGEL_INVESTOR }),
-  investmentSize: z
-    .enum(
-      Object.values(INVESTMENT_SIZES) as [InvestmentSize, ...InvestmentSize[]]
-    )
-    .optional()
-    .openapi({ example: INVESTMENT_SIZES.BETWEEN_25K_100K }),
-  geographicFocus: z
-    .enum(
-      Object.values(GEOGRAPHIC_FOCUS) as [GeographicFocus, ...GeographicFocus[]]
-    )
-    .optional()
-    .openapi({ example: GEOGRAPHIC_FOCUS.AFRICA }),
+  profileType: z.enum(["creative", "brand", "investor"]).optional(),
+  bio: z.string().optional(),
+  location: z.string().optional(),
+  experienceLevel: z.string().optional(),
+  disciplines: z.array(z.any()).optional(),
+  tags: z.array(z.any()).optional(),
+  brandName: z.string().optional(),
+  websiteURL: z.string().url().optional(),
+  investorType: z.string().optional(),
+  investmentSize: z.string().optional(),
+  geographicFocus: z.string().optional(),
 }).openapi("UserProfileEntity");
+
+export const UserWithProjectsEntitySchema = z
+  .object({
+    userId: z.cuid2(),
+    projects: z.array(ProjectEntitySchema.omit({ overview: true })),
+  })
+  .openapi("UserWithProjectsEntity");
+
+export const UserWithProjectBookmarksEntitySchema = z
+  .object({
+    userId: z.cuid2(),
+    projectBookmarks: z.array(
+      ProjectBookmarkEntitySchema.extend({
+        project: ProjectEntitySchema.pick({
+          id: true,
+          title: true,
+          description: true,
+          tags: true,
+          startDate: true,
+          endDate: true,
+          imagePlaceholderUrl: true,
+        }),
+      })
+    ),
+  })
+  .openapi("UserWithProjectBookmarksEntity");
+
+export const UserWithFollowingEntitySchema = MinimalUserSchema.extend({
+  following: z
+    .array(MinimalUserSchema)
+    .openapi({ description: "List of users this user is following." }),
+}).openapi("UserWithFollowingEntity");
+
+export const UserWithFollowersEntitySchema = MinimalUserSchema.extend({
+  followers: z
+    .array(MinimalUserSchema)
+    .openapi({ description: "List of users who follow this user." }),
+}).openapi("UserWithFollowersEntity");

package/src/types/brand.ts

@@ -1,27 +1,41 @@
-import type { MinimalUser } from "./user";
+import { z } from "@hono/zod-openapi";
+import {
+  BrandEntitySchema,
+  BrandWithUserEntitySchema,
+  CreateBrandEndpointResponseSchema,
+  CreateBrandProfileSchema,
+  GetBrandEndpointResponseSchema,
+  GetBrandParamsSchema,
+  GetBrandQuerySchema,
+  ListBrandsInputSchema,
+  UpdateBrandEndpointResponseSchema,
+  UpdateBrandProfileSchema,
+} from "../schemas";
 
-export type BrandEntity = {
-  id: string;
+export type BrandEntity = z.infer<typeof BrandEntitySchema>;
+
+export type BrandWithUserEntity = z.infer<typeof BrandWithUserEntitySchema>;
+
+export type ListBrandsInput = z.infer<typeof ListBrandsInputSchema>;
+
+export type CreateBrandDto = z.infer<typeof CreateBrandProfileSchema> & {
   userId: string;
-  brandName: string;
-  searchVector?: string;
-  bio?: string;
-  tags?: string[];
-  createdAt: Date;
-  updatedAt: Date;
 };
 
-export type BrandWithUserEntity = BrandEntity & {
-  user: MinimalUser;
-  disciplines: string[];
+export type UpdateBrandDto = z.infer<typeof UpdateBrandProfileSchema> & {
+  userId: string;
 };
 
-export type ListBrandsInput = {
-  query?: string;
-  disciplines?: string[];
-  experienceLevels?: string[];
-  location?: string;
-  tags?: string[];
-  page?: number;
-  perPage?: number;
-};
+export type GetBrandParams = z.infer<typeof GetBrandParamsSchema>;
+
+export type GetBrandQuery = z.infer<typeof GetBrandQuerySchema>;
+
+export type CreateBrandEndpointResponse = z.infer<
+  typeof CreateBrandEndpointResponseSchema
+>;
+export type GetBrandEndpointResponse = z.infer<
+  typeof GetBrandEndpointResponseSchema
+>;
+export type UpdateBrandEndpointResponse = z.infer<
+  typeof UpdateBrandEndpointResponseSchema
+>;

package/src/types/creative.ts

@@ -1,32 +1,44 @@
-import type { ExperienceLevel } from "../constants";
-import type { MinimalUser } from "./user";
+import { z } from "@hono/zod-openapi";
+import {
+  CreateCreativeEndpointResponseSchema,
+  CreateCreativeProfileSchema,
+  CreativeEntitySchema,
+  CreativeWithUserEntitySchema,
+  GetCreativeEndpointResponseSchema,
+  GetCreativeParamsSchema,
+  GetCreativeQuerySchema,
+  ListCreativesInputSchema,
+  UpdateCreativeEndpointResponseSchema,
+  UpdateCreativeProfileSchema,
+} from "../schemas";
 
-export type BaseCreativeEntity = {
-  id: string;
+export type CreativeEntity = z.infer<typeof CreativeEntitySchema>;
+
+export type CreativeWithUserEntity = z.infer<
+  typeof CreativeWithUserEntitySchema
+>
+
+export type ListCreativesDto = z.infer<typeof ListCreativesInputSchema>;
+
+export type CreateCreativeDto = z.infer<typeof CreateCreativeProfileSchema> & {
+  userId: string;
+};
+export type UpdateCreativeDto = z.infer<typeof UpdateCreativeProfileSchema> & {
   userId: string;
-  bio?: string;
-  location?: string;
-  experienceLevel?: ExperienceLevel;
-  tags?: string[];
-  disciplines?: string[];
-  user?: any;
-  createdAt: Date;
-  updatedAt: Date;
 };
 
-export type CreativeEntity = BaseCreativeEntity;
+export type GetCreativeParams = z.infer<typeof GetCreativeParamsSchema>;
 
-export type CreativeWithUserEntity = CreativeEntity & {
-  user: MinimalUser;
-  disciplines: string[];
-};
+export type GetCreativeQuery = z.infer<typeof GetCreativeQuerySchema>;
+
+export type CreateCreativeEndpointResponse = z.infer<
+  typeof CreateCreativeEndpointResponseSchema
+>;
+
+export type GetCreativeEndpointResponse = z.infer<
+  typeof GetCreativeEndpointResponseSchema
+>;
 
-export type ListCreativesInput = {
-  query?: string;
-  disciplines?: string[];
-  experienceLevels?: string[];
-  location?: string;
-  tags?: string[];
-  page?: number;
-  perPage?: number;
-};
+export type UpdateCreativeEndpointResponse = z.infer<
+  typeof UpdateCreativeEndpointResponseSchema
+>;

package/src/types/investor.ts

@@ -1,38 +1,43 @@
-import type {
-  ExperienceLevel,
-  GeographicFocus,
-  InvestmentSize,
-  InvestorType,
-} from "../constants";
-import type { MinimalUser } from "./user";
-
-export type InvestorEntity = {
-  id: string;
+import { z } from "@hono/zod-openapi";
+import {
+  CreateInvestorEndpointResponseSchema,
+  CreateInvestorProfileSchema,
+  GetInvestorEndpointResponseSchema,
+  GetInvestorParamsSchema,
+  GetInvestorQuerySchema,
+  InvestorEntitySchema,
+  InvestorWithUserEntitySchema,
+  ListInvestorsInputSchema,
+  UpdateInvestorEndpointResponseSchema,
+  UpdateInvestorProfileSchema,
+} from "../schemas/investor";
+
+export type InvestorEntity = z.infer<typeof InvestorEntitySchema>;
+
+export type InvestorWithUserEntity = z.infer<
+  typeof InvestorWithUserEntitySchema
+>;
+
+export type ListInvestorsInput = z.infer<typeof ListInvestorsInputSchema>;
+
+export type CreateInvestorDto = z.infer<typeof CreateInvestorProfileSchema> & {
   userId: string;
-  bio?: string;
-  location?: string;
-  experienceLevel?: ExperienceLevel;
-  geographicFocus?: GeographicFocus;
-  investmentSize?: InvestmentSize;
-  investorType?: InvestorType;
-  websiteURL?: string;
-  disciplines?: string[];
-  user?: any;
-  createdAt: Date;
-  updatedAt: Date;
 };
 
-export type InvestorWithUserEntity = InvestorEntity & {
-  user: MinimalUser;
-  disciplines: string[];
+export type UpdateInvestorDto = z.infer<typeof UpdateInvestorProfileSchema> & {
+  userId: string;
 };
 
-export type ListInvestorsInput = {
-  query?: string;
-  disciplines?: string[];
-  experienceLevels?: string[];
-  location?: string;
-  tags?: string[];
-  page?: number;
-  perPage?: number;
-};
+export type GetInvestorParams = z.infer<typeof GetInvestorParamsSchema>;
+
+export type GetInvestorQuery = z.infer<typeof GetInvestorQuerySchema>;
+
+export type CreateInvestorEndpointResponse = z.infer<
+  typeof CreateInvestorEndpointResponseSchema
+>;
+export type GetInvestorEndpointResponse = z.infer<
+  typeof GetInvestorEndpointResponseSchema
+>;
+export type UpdateInvestorEndpointResponse = z.infer<
+  typeof UpdateInvestorEndpointResponseSchema
+>;

package/src/types/project.ts

@@ -25,9 +25,9 @@ export type ProjectEntity = {
   projectCreatorType: Role;
   tags?: string[];
   isFeatured?: boolean;
-  startDate?: Date | null;
+  startDate?: Date;
   imagePlaceholderUrl?: string;
-  endDate?: Date | null;
+  endDate?: Date;
 };
 
 export type ProjectWithFilesEntity = ProjectEntity &

package/src/types/user.ts

@@ -1,61 +1,35 @@
-import type { OnboardingPage, Role, UserStatus } from "../constants";
-import type { UserSocialGraphEntity } from "./common";
-import type { ProjectBookmarkEntity, ProjectEntity } from "./project";
-
-export type BaseUserEntity = {
-  id: string;
-  email: string;
-  emailVerified: boolean;
-  name?: string;
-  image?: string;
-  username?: string;
-  displayUsername?: string;
-  searchVector?: string;
-  role: Role;
-  status: UserStatus;
-  onboardingPage: OnboardingPage;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
-export type MinimalUser = Pick<
-  BaseUserEntity,
-  "id" | "name" | "email" | "image" | "username" | "role"
+import { z } from "@hono/zod-openapi";
+import {
+  BaseUserEntitySchema,
+  UserWithFollowingEntitySchema,
+  MinimalUserSchema,
+  UserEntitySchema,
+  UserProfileEntitySchema,
+  UserWithProjectBookmarksEntitySchema,
+  UserWithProjectsEntitySchema,
+  UserWithFollowersEntitySchema,
+} from "../schemas";
+
+export type BaseUserEntity = z.infer<typeof BaseUserEntitySchema>;
+
+export type MinimalUser = z.infer<typeof MinimalUserSchema>;
+
+export type UserEntity = z.infer<typeof UserEntitySchema>;
+
+export type UserProfileEntity = z.infer<typeof UserProfileEntitySchema>;
+
+export type UserWithProjectsEntity = z.infer<
+  typeof UserWithProjectsEntitySchema
 >;
 
-export type UserEntity = BaseUserEntity & UserSocialGraphEntity;
-
-export type UserProfileEntity = UserEntity & {
-  profileType?: "creative" | "brand" | "investor";
-  bio?: string;
-  location?: string;
-  experienceLevel?: string;
-  disciplines?: any[];
-  tags?: any[];
-  brandName?: string;
-  websiteURL?: string;
-  investorType?: string;
-  investmentSize?: string;
-  geographicFocus?: string;
-};
-
-export type UserWithProjectsEntity = {
-  userId: string;
-  projects: Omit<ProjectEntity, "overview">[];
-};
-
-export type UserWithProjectBookmarksEntity = {
-  userId: string;
-  projectBookmarks: (ProjectBookmarkEntity & {
-    project: Pick<
-      ProjectEntity,
-      | "id"
-      | "title"
-      | "description"
-      | "tags"
-      | "startDate"
-      | "endDate"
-      | "imagePlaceholderUrl"
-    >;
-  })[];
-};
+export type UserWithProjectBookmarksEntity = z.infer<
+  typeof UserWithProjectBookmarksEntitySchema
+>;
+
+export type UserWithFollowingEntity = z.infer<
+  typeof UserWithFollowingEntitySchema
+>;
+
+export type UserWithFollowersEntity = z.infer<
+  typeof UserWithFollowersEntitySchema
+>;

package/src/utils/slugify.ts

@@ -0,0 +1,10 @@
+export const slugify = ({ value }: { value: string }) => {
+  return value
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "") // Remove diacritics
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "_") // Replace non-alphanum with underscore
+    .replace(/^_+|_+$/g, "") // Trim leading/trailing underscores
+    .replace(/__+/g, "_"); // Collapse multiple underscores
+};