@zyacreatives/shared 1.0.1 → 1.1.1

package/src/schemas/brand.ts

@@ -0,0 +1,91 @@
+import { z } from "@hono/zod-openapi";
+import { CuidSchema, ProfileIdentifierSchema } from "./common";
+import { MinimalUserSchema } from "./user";
+
+export const BrandEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    brandName: z.string().min(1).openapi({ example: "Acme Creative Studio" }),
+    searchVector: z.string().optional(),
+    bio: z.string().optional().openapi({
+      example: "A creative studio specializing in product design.",
+    }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["branding", "design", "marketing"] }),
+    createdAt: z.iso
+      .datetime()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    updatedAt: z.iso
+      .datetime()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+  })
+  .openapi("BrandEntity");
+
+export const CreateBrandProfileSchema = z
+  .object({
+    brandName: z
+      .string()
+      .min(1, "Brand name is required")
+      .openapi({ example: "Acme Creative Studio" }),
+    bio: z.string().max(210).optional().default("").openapi({
+      example: "We help brands tell their stories through design.",
+    }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .default([])
+      .openapi({ example: ["branding", "ux", "campaigns"] }),
+  })
+  .openapi({
+    title: "create brand profile",
+  });
+
+export const UpdateBrandProfileSchema = z
+  .object({
+    brandName: z.string().min(1).optional().openapi({ example: "Acme Studio" }),
+    bio: z.string().max(210).optional().openapi({
+      example: "Updated bio for our creative agency.",
+    }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["branding", "product", "illustration"] }),
+  })
+  .openapi({
+    title: "update brand profile",
+  });
+
+export const GetBrandParamsSchema = z.object({
+  value: CuidSchema,
+});
+
+export const GetBrandQuerySchema = ProfileIdentifierSchema;
+
+export const CreateBrandEndpointResponseSchema = BrandEntitySchema;
+export const GetBrandEndpointResponseSchema = BrandEntitySchema.extend({
+  user: MinimalUserSchema,
+});
+export const UpdateBrandEndpointResponseSchema = BrandEntitySchema;
+
+export type CreateBrandDto = z.infer<typeof CreateBrandProfileSchema> & {
+  userId: string;
+};
+export type UpdateBrandDto = z.infer<typeof UpdateBrandProfileSchema> & {
+  userId: string;
+};
+
+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/schemas/common.ts

@@ -0,0 +1,67 @@
+import { z } from "@hono/zod-openapi";
+
+export const CuidSchema = z.cuid2({ error: "Invalid CUID2 is written." });
+
+export const UserIdentifierSchema = z.object({
+  by: z.enum(["id", "username"]).optional().default("id"),
+});
+
+export type UserIdentifier = z.infer<typeof UserIdentifierSchema>;
+
+export const ProfileIdentifierSchema = z.object({
+  by: z.enum(["id", "userId"]).optional().default("id"),
+});
+
+export type ProfileIdentifier = z.infer<typeof ProfileIdentifierSchema>;
+
+export const ProjectIdentifierSchema = z.object({
+  by: z.enum(["id", "userId"]).optional().default("id"),
+});
+
+export type ProjectIdentifier = z.infer<typeof ProjectIdentifierSchema>;
+
+export const ProjectSocialGraphEntitySchema = z
+  .object({
+    noOfLikes: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 350 }),
+    noOfComments: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 78 }),
+    noOfBookmarks: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 25 }),
+    noOfViews: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 1024 }),
+  })
+  .openapi("ProjectSocialGraphEntity");
+
+export const UserSocialGraphEntitySchema = z
+  .object({
+    followerCount: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 120 }),
+    followingCount: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .openapi({ example: 45 }),
+  })
+  .openapi("UserSocialGraphEntity");

package/src/schemas/creative.ts

@@ -0,0 +1,125 @@
+import { z } from "@hono/zod-openapi";
+import { EXPERIENCE_LEVELS } from "../constants";
+import { CuidSchema, ProfileIdentifierSchema } from "./common";
+import { MinimalUserSchema } from "./user";
+
+export const CreativeEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    userId: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    bio: z
+      .string()
+      .optional()
+      .openapi({ example: "Passionate visual artist." }),
+    location: z.string().optional().openapi({ example: "Lagos, Nigeria" }),
+    searchVector: z.string().optional(),
+    experienceLevel: z
+      .enum(Object.values(EXPERIENCE_LEVELS) as [string, ...string[]])
+      .optional()
+      .openapi({ example: "1-3 years" }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["digital-art", "illustration"] }),
+    disciplines: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["painting", "animation"] }),
+    createdAt: z.iso
+      .datetime()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    updatedAt: z.iso
+      .datetime()
+      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+  })
+  .openapi("CreativeEntity");
+
+export const CreateCreativeProfileSchema = z
+  .object({
+    experienceLevel: z
+      .enum(EXPERIENCE_LEVELS)
+      .default(EXPERIENCE_LEVELS.YEAR_0_1)
+      .openapi({ example: EXPERIENCE_LEVELS.YEAR_1_3 }),
+    bio: z
+      .string()
+      .max(210)
+      .optional()
+      .default("")
+      .openapi({ example: "I am a freelance UI/UX designer." }),
+    location: z
+      .string()
+      .max(100)
+      .optional()
+      .default("")
+      .openapi({ example: "Lagos, Nigeria" }),
+    disciplineSlugs: z
+      .array(z.string())
+      .min(1, "At least one discipline is required")
+      .default([])
+      .openapi({ example: ["ui-ux", "frontend"] }),
+  })
+  .openapi({
+    title: "create creative profile",
+  });
+
+export const UpdateCreativeProfileSchema = z
+  .object({
+    experienceLevel: z
+      .enum(EXPERIENCE_LEVELS)
+      .optional()
+      .openapi({ example: EXPERIENCE_LEVELS.YEAR_3_5 }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["react", "design", "product"] }),
+    bio: z
+      .string()
+      .max(210)
+      .optional()
+      .openapi({ example: "I am a freelance UI/UX designer." }),
+    location: z
+      .string()
+      .max(100)
+      .optional()
+      .openapi({ example: "Lagos, Nigeria" }),
+    disciplineSlugs: z
+      .array(z.string())
+      .min(1, "At least one discipline is required")
+      .optional()
+      .openapi({ example: ["frontend", "ui-ux"] }),
+  })
+  .openapi({
+    title: "update creative profile",
+  });
+
+export const GetCreativeParamsSchema = z.object({
+  value: CuidSchema,
+});
+
+export const GetCreativeQuerySchema = ProfileIdentifierSchema;
+
+export const CreateCreativeEndpointResponseSchema = CreativeEntitySchema;
+export const GetCreativeEndpointResponseSchema = CreativeEntitySchema.extend({
+  user: MinimalUserSchema,
+})
+export const UpdateCreativeEndpointResponseSchema = CreativeEntitySchema;
+
+export type CreateCreativeDto = z.infer<typeof CreateCreativeProfileSchema> & {
+  userId: string;
+};
+export type UpdateCreativeDto = z.infer<typeof UpdateCreativeProfileSchema> & {
+  userId: string;
+};
+
+export type GetCreativeParams = z.infer<typeof GetCreativeParamsSchema>;
+export type GetCreativeQuery = z.infer<typeof GetCreativeQuerySchema>;
+
+export type CreateCreativeEndpointResponse = z.infer<
+  typeof CreateCreativeEndpointResponseSchema
+>;
+export type GetCreativeEndpointResponse = z.infer<
+  typeof GetCreativeEndpointResponseSchema
+>;
+export type UpdateCreativeEndpointResponse = z.infer<
+  typeof UpdateCreativeEndpointResponseSchema
+>;

package/src/schemas/index.ts

@@ -0,0 +1,4 @@
+export * from "./brand";
+export * from "./common";
+export * from "./creative";
+export * from "./user";

package/src/schemas/user.ts

@@ -0,0 +1,125 @@
+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 { UserSocialGraphEntitySchema } from "./common";
+
+export const BaseUserEntitySchema = z
+  .object({
+    id: z.cuid2().openapi({ example: "cksd0v6q0000s9a5y8z7p3x9" }),
+    email: z.email().openapi({ example: "user@example.com" }),
+    emailVerified: z.boolean().openapi({ example: true }),
+    name: z.string().optional().openapi({ example: "John Doe" }),
+    image: z
+      .string()
+      .optional()
+      .openapi({ example: "https://example.com/avatar.png" }),
+    username: z.string().optional().openapi({ example: "johndoe" }),
+    displayUsername: z.string().optional().openapi({ example: "@johndoe" }),
+    role: z.enum(Object.values(ROLES) as [Role, ...Role[]]).openapi({
+      example: "CREATIVE",
+    }),
+    status: z
+      .enum(Object.values(USER_STATUSES) as [UserStatus, ...UserStatus[]])
+      .openapi({
+        example: "ACTIVE",
+      }),
+    onboardingPage: z
+      .enum(
+        Object.values(ONBOARDING_PAGES) as [OnboardingPage, ...OnboardingPage[]]
+      )
+      .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" }),
+  })
+  .openapi("BaseUserEntity");
+
+export const MinimalUserSchema = BaseUserEntitySchema.pick({
+  id: true,
+  name: true,
+  email: true,
+  image: true,
+  username: true,
+  role: true,
+}).openapi("MinimalUser");
+
+export const UserEntitySchema = BaseUserEntitySchema.merge(
+  UserSocialGraphEntitySchema
+).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 }),
+}).openapi("UserProfileEntity");

package/src/types/brand.ts

@@ -0,0 +1,27 @@
+import type { MinimalUser } from "./user";
+
+export type BrandEntity = {
+  id: string;
+  userId: string;
+  brandName: string;
+  searchVector?: string;
+  bio?: string;
+  tags?: string[];
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type BrandWithUserEntity = BrandEntity & {
+  user: MinimalUser;
+  disciplines: string[];
+};
+
+export type ListBrandsInput = {
+  query?: string;
+  disciplines?: string[];
+  experienceLevels?: string[];
+  location?: string;
+  tags?: string[];
+  page?: number;
+  perPage?: number;
+};

package/src/types/common.ts

@@ -0,0 +1,11 @@
+export type ProjectSocialGraphEntity = {
+  noOfLikes?: number;
+  noOfComments?: number;
+  noOfBookmarks?: number;
+  noOfViews?: number;
+};
+
+export type UserSocialGraphEntity = {
+  followerCount?: number;
+  followingCount?: number;
+};

package/src/types/creative.ts

@@ -0,0 +1,32 @@
+import type { ExperienceLevel } from "../constants";
+import type { MinimalUser } from "./user";
+
+export type BaseCreativeEntity = {
+  id: string;
+  userId: string;
+  bio?: string;
+  location?: string;
+  experienceLevel?: ExperienceLevel;
+  tags?: string[];
+  disciplines?: string[];
+  user?: any;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type CreativeEntity = BaseCreativeEntity;
+
+export type CreativeWithUserEntity = CreativeEntity & {
+  user: MinimalUser;
+  disciplines: string[];
+};
+
+export type ListCreativesInput = {
+  query?: string;
+  disciplines?: string[];
+  experienceLevels?: string[];
+  location?: string;
+  tags?: string[];
+  page?: number;
+  perPage?: number;
+};

package/src/types/discipline.ts

@@ -0,0 +1,9 @@
+export type DisciplineEntity = {
+  slug: string;
+  name: string;
+  tags?: string[];
+};
+
+export type DisciplineUpdateOutputEntity = {
+  slug: string;
+};

package/src/types/file.ts

@@ -0,0 +1,13 @@
+export type FileEntity = {
+  key: string;
+  id: string;
+  url?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  userId: string;
+  mimeType: string;
+};
+
+export type FileUpdateOutputEntity = {
+  id: string;
+};

package/src/types/index.ts

@@ -1 +1,8 @@
-export * from "./enums";
+export * from "./brand";
+export * from "./common";
+export * from "./creative";
+export * from "./discipline";
+export * from "./file";
+export * from "./investor";
+export * from "./project";
+export * from "./user";

package/src/types/investor.ts

@@ -0,0 +1,38 @@
+import type {
+  ExperienceLevel,
+  GeographicFocus,
+  InvestmentSize,
+  InvestorType,
+} from "../constants";
+import type { MinimalUser } from "./user";
+
+export type InvestorEntity = {
+  id: string;
+  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 ListInvestorsInput = {
+  query?: string;
+  disciplines?: string[];
+  experienceLevels?: string[];
+  location?: string;
+  tags?: string[];
+  page?: number;
+  perPage?: number;
+};

package/src/types/project.ts

@@ -0,0 +1,101 @@
+import type { ClientType, CommentStatus, Role } from "../constants";
+import type { ProjectSocialGraphEntity } from "./common";
+import type { BaseUserEntity, MinimalUser } from "./user";
+
+export type ProjectFileEntity = {
+  id: string;
+  projectId: string;
+  fileId: string;
+  order: number;
+  isPlaceholder: boolean;
+};
+
+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 | null;
+  imagePlaceholderUrl?: string;
+  endDate?: Date | null;
+};
+
+export type ProjectWithFilesEntity = ProjectEntity &
+  ProjectSocialGraphEntity & {
+    projectFiles?: ProjectFileEntity[];
+  };
+
+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;
+  status: CommentStatus;
+  createdAt: Date;
+  userId: string;
+  projectId: string;
+  parentCommentId?: string;
+  content: string;
+};
+
+export type ProjectBookmarkEntity = {
+  createdAt: Date;
+  userId: string;
+  projectId: string;
+};
+
+export type MinimalProject = Pick<
+  ProjectEntity,
+  | "id"
+  | "title"
+  | "description"
+  | "tags"
+  | "startDate"
+  | "endDate"
+  | "imagePlaceholderUrl"
+>;
+
+export type ProjectWithClientEntity = MinimalProject & {
+  client: MinimalUser;
+};
+
+export type ProjectWithUserEntity = MinimalProject & {
+  user: Pick<
+    BaseUserEntity,
+    "id" | "name" | "email" | "image" | "username" | "role"
+  >;
+  projectFiles: (ProjectFileEntity & { fileUrl: string })[];
+} & Partial<ProjectSocialGraphEntity>;
+
+export type ListProjectsDto = {
+  query?: string;
+  tags?: string[];
+  clientName?: string;
+  userId?: string;
+  page?: number;
+  perPage?: number;
+};