@zyacreatives/shared 2.5.49 → 2.5.51

package/src/schemas/investor.ts

@@ -13,333 +13,209 @@ import {
 import { CuidSchema, ProfileIdentifierSchema } from "./common";
 import { MinimalUserSchema } from "./user";
 
-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();
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
 
-const InvestorLinkSchema = z.object({
-  url: z.union([z.url({ message: "Please enter a valid URL" }), z.literal("")]),
-  type: z.enum(LINK_TYPES),
-});
+const InvestorShape = z.object({
+  bio: z.string().max(600).default(""),
+  location: z.string().default(""),
 
-const InvestorAchievementSchema = z.object({
-  title: z.string(),
-  link: z.string().optional(),
-  year: z.coerce.number().int().optional(),
-});
+  experienceLevel: z.enum(
+    Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]],
+  ),
 
-export const MinimalInvestorEntitySchema = z.object({
-  id: z.cuid2().openapi({ example: "inv_cksd0v6q0000s9a5y8z7p3x9" }),
-  userId: z.cuid2().openapi({ example: "user_owner_123" }),
-  bio: z
-    .string()
-    .optional()
-    .openapi({ example: "Early stage VC focusing on creative technology." }),
-  location: z.string().optional().openapi({ example: "New York, USA" }),
-  experienceLevel: z
-    .enum(
-      Object.values(EXPERIENCE_LEVELS) as [
-        ExperienceLevel,
-        ...ExperienceLevel[],
-      ],
-    )
-    .optional()
-    .openapi({ example: "EXPERT" }),
-  investorType: z
-    .enum(Object.values(INVESTOR_TYPES) as [InvestorType, ...InvestorType[]])
-    .optional()
-    .openapi({ example: "VC" }),
-  investmentSize: z
-    .enum(
-      Object.values(INVESTMENT_SIZES) as [InvestmentSize, ...InvestmentSize[]],
+  investorType: z.enum(
+    Object.values(INVESTOR_TYPES) as [InvestorType, ...InvestorType[]],
+  ),
+
+  investmentSize: z.enum(
+    Object.values(INVESTMENT_SIZES) as [InvestmentSize, ...InvestmentSize[]],
+  ),
+
+  geographicFocus: z.enum(
+    Object.values(GEOGRAPHIC_FOCUS) as [GeographicFocus, ...GeographicFocus[]],
+  ),
+
+  websiteURL: z.url().default(""),
+
+  disciplines: z.array(z.string()).default([]),
+
+  links: z
+    .array(
+      z.object({
+        url: z.url(),
+        type: z.enum(LINK_TYPES).default(LINK_TYPES.GENERIC_WEBSITE),
+      }),
     )
-    .optional()
-    .openapi({
-      example: "SEED",
-    }),
-  geographicFocus: z
-    .enum(
-      Object.values(GEOGRAPHIC_FOCUS) as [
-        GeographicFocus,
-        ...GeographicFocus[],
-      ],
+    .default([]),
+
+  achievements: z
+    .array(
+      z.object({
+        title: z.string(),
+        link: z.url().optional(),
+        year: z.number().int().optional(),
+      }),
     )
-    .optional()
-    .openapi({
-      example: "GLOBAL",
-    }),
-  websiteURL: z
-    .url()
-    .optional()
-    .openapi({ example: "https://investorpartners.com" }),
-  disciplines: z
-    .array(z.string())
-    .optional()
-    .openapi({ example: ["Product Design", "AI Strategy"] }),
-  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" }),
+    .default([]),
 });
 
-export type MinimalInvestorEntity = z.infer<typeof MinimalInvestorEntitySchema>;
+export type InvestorShapeType = z.infer<typeof InvestorShape>;
+
+/**
+ * --------------------------------
+ * ENTITY (DTO)
+ * --------------------------------
+ */
 
 export const InvestorEntitySchema = z
   .object({
-    id: z.cuid2().openapi({ example: "inv_cksd0v6q0000s9a5y8z7p3x9" }),
-    userId: z.cuid2().openapi({ example: "user_owner_123" }),
-    bio: z
-      .string()
-      .optional()
-      .openapi({ example: "Early stage VC focusing on creative technology." }),
-    location: z.string().optional().openapi({ example: "New York, USA" }),
-    experienceLevel: z
-      .enum(
-        Object.values(EXPERIENCE_LEVELS) as [
-          ExperienceLevel,
-          ...ExperienceLevel[],
-        ],
-      )
-      .optional()
-      .openapi({ example: "EXPERT" }),
-    geographicFocus: z
-      .enum(
-        Object.values(GEOGRAPHIC_FOCUS) as [
-          GeographicFocus,
-          ...GeographicFocus[],
-        ],
-      )
-      .optional()
-      .openapi({ example: "NORTH_AMERICA" }),
-    investmentSize: z
-      .enum(
-        Object.values(INVESTMENT_SIZES) as [
-          InvestmentSize,
-          ...InvestmentSize[],
-        ],
-      )
-      .optional()
-      .openapi({ example: "SEED" }),
-    investorType: z
-      .enum(Object.values(INVESTOR_TYPES) as [InvestorType, ...InvestorType[]])
-      .optional()
-      .openapi({ example: "VC" }),
-    websiteURL: z
-      .url()
-      .optional()
-      .openapi({ example: "https://investorpartners.com" }),
-    links: z.array(InvestorLinkSchema).optional(),
-    achievements: z.array(InvestorAchievementSchema).optional(),
-    disciplines: z
-      .array(z.string())
-      .optional()
-      .openapi({ example: ["Product Design", "AI Strategy"] }),
-    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" }),
+    id: z.cuid2(),
+    userId: z.cuid2(),
+    ...InvestorShape.shape,
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
     version: z.int(),
   })
-  .openapi("InvestorEntity");
+  .openapi("Investor");
 
 export type InvestorEntity = z.infer<typeof InvestorEntitySchema>;
 
-export const InvestorWithUserEntitySchema = MinimalInvestorEntitySchema.extend({
-  user: MinimalUserSchema,
+/**
+ * Minimal version = derived, not duplicated
+ */
+
+export const MinimalInvestorEntitySchema = InvestorEntitySchema.pick({
+  id: true,
+  userId: true,
+  bio: true,
+  location: true,
+  experienceLevel: true,
+  investorType: true,
+  investmentSize: true,
+  geographicFocus: true,
+  websiteURL: true,
+  disciplines: true,
+  createdAt: true,
+  updatedAt: true,
 });
 
-export type InvestorWithUserEntity = z.infer<
-  typeof InvestorWithUserEntitySchema
->;
+export type MinimalInvestorEntity = z.infer<typeof MinimalInvestorEntitySchema>;
 
-export const CreateInvestorProfileInputSchema = z
-  .object({
-    websiteURL: WebsiteUrlInputSchema,
-    experienceLevel: z
-      .enum(
-        Object.values(EXPERIENCE_LEVELS) as [
-          ExperienceLevel,
-          ...ExperienceLevel[],
-        ],
-      )
-      .openapi({
-        example: "0-1 year",
-      }),
-    location: z.string().openapi({
-      example: "UK",
-    }),
-  })
-  .openapi({
-    title: "Create Investor Profile",
-  });
+/**
+ * --------------------------------
+ * INPUT DTOs
+ * --------------------------------
+ */
+
+export const CreateInvestorProfileInputSchema = InvestorShape.pick({
+  experienceLevel: true,
+  location: true,
+  websiteURL: true,
+}).extend({
+  disciplineSlugs: z.array(z.string()).min(1),
+});
 
 export type CreateInvestorInput = z.infer<
   typeof CreateInvestorProfileInputSchema
 >;
 
-export const UpdateInvestorProfileInputSchema = z
-  .object({
-    bio: z.string().max(600).optional().openapi({
-      example: "Seasoned venture capitalist with a focus on healthtech.",
-    }),
-    websiteURL: WebsiteUrlInputSchema,
-    experienceLevel: z
-      .enum(
-        Object.values(EXPERIENCE_LEVELS) as [
-          ExperienceLevel,
-          ...ExperienceLevel[],
-        ],
-      )
-      .optional()
-      .openapi({
-        example: "SENIOR",
-      }),
-    investorType: z
-      .enum(Object.values(INVESTOR_TYPES) as [InvestorType, ...InvestorType[]])
-      .optional()
-      .openapi({
-        example: "VC",
-      }),
-    disciplineSlugs: z
-      .array(z.string())
-      .min(1, "At least one discipline is required")
-      .optional()
-      .openapi({
-        example: ["fintech", "edtech"],
-      }),
-    investmentSize: z
-      .enum(
-        Object.values(INVESTMENT_SIZES) as [
-          InvestmentSize,
-          ...InvestmentSize[],
-        ],
-      )
-      .optional()
-      .openapi({
-        example: "SEED",
-      }),
-    geographicFocus: z
-      .enum(
-        Object.values(GEOGRAPHIC_FOCUS) as [
-          GeographicFocus,
-          ...GeographicFocus[],
-        ],
-      )
-      .optional()
-      .openapi({
-        example: "GLOBAL",
-      }),
-    links: z.array(InvestorLinkSchema).optional(),
-    achievements: z.array(InvestorAchievementSchema).optional(),
-    location: z.string().optional().openapi({
-      example: "UK",
-    }),
+export const UpdateInvestorProfileInputSchema = InvestorShape.partial()
+  .extend({
+    disciplineSlugs: z.array(z.string()).optional(),
     version: z.int(),
   })
-  .openapi({
-    title: "Update Investor Profile",
+  .refine((d) => Object.values(d).some((v) => v !== undefined), {
+    message: "At least one field must be provided",
   });
 
 export type UpdateInvestorInput = z.infer<
   typeof UpdateInvestorProfileInputSchema
 >;
 
-export const ListInvestorsInputSchema = z
-  .object({
-    query: z.string().optional().openapi({ example: "creative tech investor" }),
-    disciplines: z
-      .array(z.string())
-      .optional()
-      .openapi({ example: ["branding", "UX"] }),
-    experienceLevels: z
-      .array(
-        z.enum(
-          Object.values(EXPERIENCE_LEVELS) as [
-            ExperienceLevel,
-            ...ExperienceLevel[],
-          ],
-        ),
-      )
-      .optional()
-      .openapi({
-        description: "Filter based on the required experience level.",
-      }),
-    location: z.string().optional().openapi({ example: "San Francisco" }),
-    tags: z
-      .array(z.string())
-      .optional()
-      .openapi({ example: ["design", "future"] }),
-    page: z.number().int().min(1).default(1).optional().openapi({ example: 1 }),
-    perPage: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .default(20)
-      .optional()
-      .openapi({ example: 20 }),
-  })
-  .openapi("ListInvestorsInput");
-
-export type ListInvestorsInput = z.infer<typeof ListInvestorsInputSchema>;
-
-export const SearchInvestorInputSchema = z.object({
-  string: z
-    .string()
-    .min(1, { message: "Search string cannot be empty" })
-    .max(200, { message: "Search string cannot exceed 200 characters" }),
-  limit: z.coerce
-    .number()
-    .int({ message: "Limit must be an integer" })
-    .min(1, { message: "Limit must be at least 1" })
-    .max(100, { message: "Limit cannot exceed 100" })
-    .default(20),
-  cursor: z.string().optional(),
-});
-
-export type SearchInvestorInput = z.infer<typeof SearchInvestorInputSchema>;
+/**
+ * --------------------------------
+ * GET / SEARCH
+ * --------------------------------
+ */
 
 export const GetInvestorParamsSchema = z.object({
   value: CuidSchema,
 });
 
-export type GetInvestorParams = z.infer<typeof GetInvestorParamsSchema>;
-
 export const GetInvestorQuerySchema = ProfileIdentifierSchema;
 
-export type GetInvestorQuery = z.infer<typeof GetInvestorQuerySchema>;
+/**
+ * --------------------------------
+ * OUTPUT
+ * --------------------------------
+ */
 
 export const CreateInvestorOutputSchema = InvestorEntitySchema;
+export const GetInvestorOutputSchema = InvestorEntitySchema;
+export const UpdateInvestorOutputSchema = InvestorEntitySchema;
 
 export type CreateInvestorOutput = z.infer<typeof CreateInvestorOutputSchema>;
+export type GetInvestorOutput = z.infer<typeof GetInvestorOutputSchema>;
+export type UpdateInvestorOutput = z.infer<typeof UpdateInvestorOutputSchema>;
 
-export const GetInvestorOutputSchema = InvestorEntitySchema;
+/**
+ * --------------------------------
+ * ENTITY WITH USER
+ * --------------------------------
+ */
 
-export type GetInvestorOutput = z.infer<typeof GetInvestorOutputSchema>;
+export const InvestorWithUserEntitySchema = MinimalInvestorEntitySchema.extend({
+  user: MinimalUserSchema,
+});
 
-export const UpdateInvestorOutputSchema = InvestorEntitySchema;
+export type InvestorWithUserEntity = z.infer<
+  typeof InvestorWithUserEntitySchema
+>;
 
-export type UpdateInvestorOutput = z.infer<typeof UpdateInvestorOutputSchema>;
+/**
+ * --------------------------------
+ * LIST / SEARCH
+ * --------------------------------
+ */
+
+export const ListInvestorsInputSchema = z.object({
+  query: z.string().default(""),
+  disciplines: z.array(z.string()).optional(),
+  experienceLevels: z
+    .array(
+      z.enum(
+        Object.values(EXPERIENCE_LEVELS) as [
+          ExperienceLevel,
+          ...ExperienceLevel[],
+        ],
+      ),
+    )
+    .optional(),
+
+  location: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+
+  page: z.coerce.number().int().min(1).default(1),
+  perPage: z.coerce.number().int().min(1).max(100).default(20),
+});
+
+export type ListInvestorsInput = z.infer<typeof ListInvestorsInputSchema>;
+
+export const SearchInvestorInputSchema = z.object({
+  string: z.string().min(1).max(200),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  cursor: z.string().optional(),
+});
+
+export type SearchInvestorInput = z.infer<typeof SearchInvestorInputSchema>;
 
 export const SearchInvestorOutputSchema = z.object({
   investors: z.array(InvestorWithUserEntitySchema),
-  nextCursor: z.string().optional().nullable(),
+  nextCursor: z.string().nullable().optional(),
 });
 
 export type SearchInvestorOutput = z.infer<typeof SearchInvestorOutputSchema>;