@zyacreatives/shared 2.5.49 → 2.5.51

package/src/schemas/brand.ts

@@ -3,131 +3,92 @@ import { LINK_TYPES } from "../constants";
 import { ProfileIdentifierSchema } from "./common";
 import { MinimalUserSchema } from "./user";
 
-export const MinimalBrandEntitySchema = z.object({
-  id: z.cuid2().openapi({ example: "brd_cksd0v6q0000s9a5y8z7p3x9" }),
-  userId: z.cuid2().openapi({ example: "user_owner_123" }),
-  brandName: z.string().openapi({ example: "TechInnovate Inc." }),
-  bio: z.string().optional().openapi({
-    example: "Leading software development firm focused on AI.",
-  }),
-  disciplines: z
-    .array(z.string())
-    .optional()
-    .openapi({ example: ["Marketing", "Product Development"] }),
-  createdAt: z.coerce
-    .date()
-    .optional()
-    .openapi({ example: "2025-10-13T09:00:00.000Z" }),
-  updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
+
+const BrandShape = z.object({
+  brandName: z.string().min(1).max(200),
+  bio: z.string().max(600).default(""),
+  location: z.string(),
+  disciplines: z.array(z.string()).default([]),
+  links: z
+    .array(
+      z.object({
+        url: z.url(),
+        type: z.enum(LINK_TYPES).default(LINK_TYPES.GENERIC_WEBSITE),
+      }),
+    )
+    .default([]),
+  achievements: z
+    .array(
+      z.object({
+        title: z.string(),
+        link: z.url().optional(),
+        year: z.number().int().optional(),
+      }),
+    )
+    .default([]),
 });
 
-export type MinimalBrandEntity = z.infer<typeof MinimalBrandEntitySchema>;
+export type BrandShapeType = z.infer<typeof BrandShape>;
+
 
 export const BrandEntitySchema = z
   .object({
     id: z.cuid2().openapi({ example: "brd_cksd0v6q0000s9a5y8z7p3x9" }),
     userId: z.cuid2().openapi({ example: "user_owner_123" }),
-    brandName: z.string().openapi({ example: "TechInnovate Inc." }),
-    bio: z.string().optional().openapi({
-      example: "Leading software development firm focused on AI.",
-    }),
-    location: z.string().openapi({
-      example: "UK",
-    }),
-    disciplines: z
-      .array(z.string())
-      .optional()
-      .openapi({ example: ["Marketing", "Product Development"] }),
-    links: z
-      .object({
-        url: z.url(),
-        type: z.enum(LINK_TYPES).default(LINK_TYPES.GENERIC_WEBSITE),
-      })
-      .array()
-      .optional(),
-    achievements: z
-      .object({
-        title: z.string(),
-        link: z.url().optional(),
-        year: z.number().int().optional(),
-      })
-      .array()
-      .optional(),
-    createdAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
-    updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    ...BrandShape.shape,
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
     version: z.int(),
   })
-  .openapi("BrandEntitySchema");
+  .openapi("BrandEntity");
 
 export type BrandEntity = z.infer<typeof BrandEntitySchema>;
 
-export const CreateBrandProfileInputSchema = z
-  .object({
-    brandName: z
-      .string()
-      .min(1, "Brand name is required")
-      .openapi({ example: "Acme Creative Studio" }),
-    location: z.string().openapi({
-      example: "UK",
-    }),
-    disciplineSlugs: z
-      .array(z.string())
-      .min(1, "At least one discipline is required")
-      .default([])
-      .openapi({ example: ["ui-ux", "frontend"] }),
-  })
-  .openapi({
-    title: "create brand profile",
-  });
+export const MinimalBrandEntitySchema = BrandEntitySchema.pick({
+  id: true,
+  userId: true,
+  brandName: true,
+  bio: true,
+  disciplines: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type MinimalBrandEntity = z.infer<typeof MinimalBrandEntitySchema>;
+
+export const BrandWithUserEntitySchema = MinimalBrandEntitySchema.extend({
+  user: MinimalUserSchema,
+});
+
+export type BrandWithUserEntity = z.infer<typeof BrandWithUserEntitySchema>;
+
+export const CreateBrandProfileInputSchema = BrandShape.pick({
+  brandName: true,
+  location: true,
+}).extend({
+  disciplineSlugs: z
+    .array(z.string())
+    .min(1, "At least one discipline is required"),
+});
 
 export type CreateBrandProfileInput = z.infer<
   typeof CreateBrandProfileInputSchema
 >;
 
-export const UpdateBrandProfileInputSchema = z
-  .object({
-    brandName: z.string().min(1).optional().openapi({ example: "Acme Studio" }),
-    links: z
-      .object({
-        url: z.union([
-          z.url({ message: "Please enter a valid URL" }),
-          z.literal(""),
-        ]),
-        type: z.enum(LINK_TYPES),
-      })
-      .array()
-      .optional(),
-    location: z.string().openapi({
-      example: "UK",
-    }),
-    achievements: z
-      .object({
-        title: z.string(),
-        link: z.url().optional(),
-        year: z.number().int().optional(),
-      })
-      .array()
-      .optional(),
-    bio: z
-      .string()
-      .max(600)
-      .optional()
-      .openapi({ example: "Updated bio for our creative agency." }),
-    disciplineSlugs: z
-      .array(z.string())
-      .min(1, "At least one discipline is required")
-      .optional()
-      .openapi({ example: ["frontend", "ui-ux"] }),
+export const UpdateBrandProfileInputSchema = BrandShape.partial()
+  .extend({
+    disciplineSlugs: z.array(z.string()).optional(),
     version: z.int(),
   })
-  .openapi({
-    title: "update brand profile",
+  .refine((d) => Object.values(d).some((v) => v !== undefined), {
+    message: "At least one field must be provided",
   });
 
 export type UpdateBrandProfileInput = z.infer<
   typeof UpdateBrandProfileInputSchema
 >;
 
+
 export const GetBrandInputSchema = z.object({
   value: z.cuid2(),
   by: ProfileIdentifierSchema.shape.by,
@@ -137,35 +98,9 @@ export type GetBrandInput = z.infer<typeof GetBrandInputSchema>;
 
 export const GetBrandQuerySchema = ProfileIdentifierSchema;
 
-export const CreateBrandOutputSchema = BrandEntitySchema;
-
-export type CreateBrandOutput = z.infer<typeof CreateBrandOutputSchema>;
-
-export const GetBrandOutputSchema = BrandEntitySchema;
-
-export type GetBrandOutput = z.infer<typeof GetBrandOutputSchema>;
-
-export const UpdateBrandOutputSchema = BrandEntitySchema;
-
-export type UpdateBrandOutput = z.infer<typeof UpdateBrandOutputSchema>;
-
-export const BrandWithUserEntitySchema = MinimalBrandEntitySchema.extend({
-  user: MinimalUserSchema,
-});
-
-export type BrandWithUserEntity = z.infer<typeof BrandWithUserEntitySchema>;
-
 export const SearchBrandInputSchema = 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),
+  string: z.string().min(1, "Search string cannot be empty").max(200),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
   cursor: z.string().optional(),
 });
 
@@ -173,7 +108,16 @@ export type SearchBrandInput = z.infer<typeof SearchBrandInputSchema>;
 
 export const SearchBrandOutputSchema = z.object({
   brands: z.array(BrandWithUserEntitySchema),
-  nextCursor: z.string().optional().nullable(),
+  nextCursor: z.string().nullable().optional(),
 });
 
 export type SearchBrandOutput = z.infer<typeof SearchBrandOutputSchema>;
+
+export const CreateBrandOutputSchema = BrandEntitySchema;
+export type CreateBrandOutput = z.infer<typeof CreateBrandOutputSchema>;
+
+export const GetBrandOutputSchema = BrandEntitySchema;
+export type GetBrandOutput = z.infer<typeof GetBrandOutputSchema>;
+
+export const UpdateBrandOutputSchema = BrandEntitySchema;
+export type UpdateBrandOutput = z.infer<typeof UpdateBrandOutputSchema>;

package/src/schemas/common.ts

@@ -1,6 +1,7 @@
 import { z } from "@hono/zod-openapi";
 import { CommentEntitySchema } from "./comment";
 import { ActivitySchema } from "./activity";
+import { LINK_TYPES } from "../constants";
 
 export const CuidSchema = z.cuid2({ error: "Invalid CUID2 is written." });
 
@@ -51,3 +52,34 @@ export const EntityRepliesOutputSchema = z.object({
   nextCursor: z.string().nullable(),
 });
 export type EntityRepliesOutput = z.infer<typeof EntityRepliesOutputSchema>;
+
+
+export const LinkSchema = z.object({
+  url: z.url({ message: "Please enter a valid URL" }).or(z.literal("")),
+  type: z.enum(LINK_TYPES).default(LINK_TYPES.GENERIC_WEBSITE),
+});
+
+export const AchievementSchema = z.object({
+  title: z.string().min(1),
+  link: z.url().optional(),
+  year: z.number().int().optional(),
+});
+
+export const WorkExperienceSchema = z.object({
+  companyName: z.string().min(1),
+  position: z.string().min(1),
+  startDate: z.iso.datetime().optional(),
+  endDate: z.iso.datetime().optional(),
+  currentlyWorking: z.boolean().default(false),
+  description: z.string().default(""),
+});
+
+export 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();

package/src/schemas/creative.ts

@@ -3,200 +3,128 @@ import { EXPERIENCE_LEVELS, ExperienceLevel, LINK_TYPES } from "../constants";
 import { ProfileIdentifierSchema } from "./common";
 import { MinimalUserSchema } from "./user";
 
-// -----------------------------------------------------------------------------
-// Minimal Creative Entity
-// -----------------------------------------------------------------------------
-export const MinimalCreativeEntitySchema = z.object({
-  id: z.cuid2().openapi({ example: "cre_cksd0v6q0000s9a5y8z7p3x9" }),
-  userId: z.cuid2().openapi({ example: "user_abc123" }),
-  bio: z.string().optional().openapi({
-    example: "A multi-disciplinary designer specializing in brand identity.",
-  }),
-  role: z.string().optional().openapi({ example: "Designer" }),
-  location: z.string().optional().openapi({ example: "London, UK" }),
-  experienceLevel: z
-    .enum(
-      Object.values(EXPERIENCE_LEVELS) as [
-        ExperienceLevel,
-        ...ExperienceLevel[],
-      ],
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
+
+const CreativeShape = z.object({
+  bio: z.string().max(600).default(""),
+  role: z.string().default(""),
+  location: z.string().max(100).default(""),
+  experienceLevel: z.enum(
+    Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]],
+  ),
+  disciplines: z.array(z.string()).default([]),
+
+  workExperience: z
+    .array(
+      z.object({
+        companyName: z.string(),
+        position: z.string(),
+        startDate: z.string().datetime().optional(),
+        endDate: z.string().datetime().optional(),
+        currentlyWorking: z.boolean().default(false),
+        description: z.string().default(""),
+      }),
     )
-    .optional()
-    .openapi({ example: EXPERIENCE_LEVELS.YEAR_0_1 }),
-  disciplines: z
-    .array(z.string())
-    .optional()
-    .openapi({ example: ["Design", "Art Direction"] }),
-  createdAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
-  updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    .default([]),
+
+  links: z
+    .array(
+      z.object({
+        url: z.url(),
+        type: z.enum(LINK_TYPES).default(LINK_TYPES.GENERIC_WEBSITE),
+      }),
+    )
+    .default([]),
+
+  achievements: z
+    .array(
+      z.object({
+        title: z.string(),
+        link: z.url().optional(),
+        year: z.number().int().optional(),
+      }),
+    )
+    .default([]),
 });
 
-export type MinimalCreativeEntity = z.infer<typeof MinimalCreativeEntitySchema>;
+export type CreativeShapeType = z.infer<typeof CreativeShape>;
+
+/**
+ * --------------------------------
+ * ENTITY (DTO)
+ * --------------------------------
+ */
 
-// -----------------------------------------------------------------------------
-// Full Creative Entity
-// -----------------------------------------------------------------------------
 export const CreativeEntitySchema = z
   .object({
-    id: z.cuid2().openapi({ example: "cre_cksd0v6q0000s9a5y8z7p3x9" }),
-    userId: z.cuid2().openapi({ example: "user_abc123" }),
-    bio: z.string().optional().openapi({
-      example: "A multi-disciplinary designer specializing in brand identity.",
-    }),
-    role: z.string().optional().openapi({ example: "Designer" }),
+    id: z.cuid2(),
+    userId: z.cuid2(),
+    ...CreativeShape.shape,
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
     version: z.int(),
-    location: z.string().optional().openapi({ example: "London, UK" }),
-    experienceLevel: z
-      .enum(
-        Object.values(EXPERIENCE_LEVELS) as [
-          ExperienceLevel,
-          ...ExperienceLevel[],
-        ],
-      )
-      .optional()
-      .openapi({ example: EXPERIENCE_LEVELS.YEAR_0_1 }),
-    disciplines: z
-      .array(z.string())
-      .optional()
-      .openapi({ example: ["Design", "Art Direction"] }),
-    workExperience: z
-      .object({
-        companyName: z.string(),
-        position: z.string(),
-        startDate: z.coerce.date().optional(),
-        endDate: z.coerce.date().optional(),
-        currentlyWorking: z.boolean().optional(),
-        description: z.string(),
-      })
-      .array()
-      .optional(),
-    links: z
-      .object({
-        url: z.union([
-          z.url({ message: "Please enter a valid URL" }),
-          z.literal(""),
-        ]),
-        type: z.enum(LINK_TYPES),
-      })
-      .array()
-      .optional(),
-    achievements: z
-      .object({
-        title: z.string(),
-        link: z.string().optional(),
-        year: z.coerce.number().int().optional(),
-      })
-      .array()
-      .optional(),
-    createdAt: z.coerce
-      .date()
-      .optional()
-      .openapi({ example: "2025-10-13T09:00:00.000Z" }),
-    updatedAt: z.coerce.date().openapi({ example: "2025-10-13T09:00:00.000Z" }),
   })
-  .openapi({
-    title: "CreativeEntitySchema",
-    description:
-      "Represents a creative profile, including bio, experience level, location, disciplines and timestamps.",
-  });
+  .openapi("Creative");
 
 export type CreativeEntity = z.infer<typeof CreativeEntitySchema>;
 
-// -----------------------------------------------------------------------------
-// Creative Profile Actions (Create / Update)
-// -----------------------------------------------------------------------------
-export const CreateCreativeProfileInputSchema = z
-  .object({
-    experienceLevel: z
-      .enum(EXPERIENCE_LEVELS)
-      .describe("Overall experience range of the creative.")
-      .openapi({ example: EXPERIENCE_LEVELS.YEAR_1_3 }),
-    role: z.string().openapi({ example: "Designer" }),
-    location: z
-      .string()
-      .max(100)
-      .describe("Primary location where the creative works or resides.")
-      .openapi({ example: "Lagos, Nigeria" }),
-    disciplineSlugs: z
-      .array(z.string())
-      .min(1, "At least one discipline is required")
-      .default([])
-      .describe("List of discipline slugs representing the creative’s fields.")
-      .openapi({ example: ["ui-ux", "frontend"] }),
-  })
-  .openapi({
-    title: "create creative profile",
-    description: "Payload for creating a new creative profile.",
-  });
+export const MinimalCreativeEntitySchema = CreativeEntitySchema.pick({
+  id: true,
+  userId: true,
+  bio: true,
+  role: true,
+  location: true,
+  experienceLevel: true,
+  disciplines: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export type MinimalCreativeEntity = z.infer<typeof MinimalCreativeEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUT DTOs
+ * --------------------------------
+ */
+
+export const CreateCreativeProfileInputSchema = CreativeShape.pick({
+  experienceLevel: true,
+  role: true,
+  location: true,
+}).extend({
+  disciplineSlugs: z
+    .array(z.string())
+    .min(1, "At least one discipline is required"),
+});
 
 export type CreateCreativeProfileInput = z.infer<
   typeof CreateCreativeProfileInputSchema
 >;
 
-export const UpdateCreativeProfileInputSchema = z
-  .object({
-    experienceLevel: z
-      .enum(EXPERIENCE_LEVELS)
-      .optional()
-      .openapi({ example: EXPERIENCE_LEVELS.YEAR_3_5 }),
-    role: z.string().optional().openapi({ example: "Designer" }),
-    bio: z
-      .string()
-      .max(600)
-      .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"] }),
-    workExperience: z
-      .object({
-        companyName: z.string(),
-        position: z.string(),
-        startDate: z.string().optional(),
-        endDate: z.string().optional(),
-        currentlyWorking: z.boolean().default(false),
-        description: z.string().optional(),
-      })
-      .array()
-      .optional(),
-    links: z
-      .object({
-        url: z.union([
-          z.url({ message: "Please enter a valid URL" }),
-          z.literal(""),
-        ]),
-        type: z.enum(LINK_TYPES),
-      })
-      .array()
-      .optional(),
+export const UpdateCreativeProfileInputSchema = CreativeShape.partial()
+  .extend({
+    disciplineSlugs: z.array(z.string()).optional(),
     version: z.int(),
-    achievements: z
-      .object({
-        title: z.string(),
-        link: z.string().optional(),
-        year: z.coerce.number().int().optional(),
-      })
-      .array()
-      .optional(),
   })
-  .openapi({
-    title: "update creative profile",
+  .refine((d) => Object.values(d).some((v) => v !== undefined), {
+    message: "At least one field must be provided",
   });
 
 export type UpdateCreativeProfileInput = z.infer<
   typeof UpdateCreativeProfileInputSchema
 >;
 
-// -----------------------------------------------------------------------------
-// Queries & Outputs
-// -----------------------------------------------------------------------------
+/**
+ * --------------------------------
+ * GET
+ * --------------------------------
+ */
+
 export const GetCreativeInputSchema = z.object({
   value: z.cuid2(),
   by: ProfileIdentifierSchema.shape.by,
@@ -206,7 +134,12 @@ export type GetCreativeInput = z.infer<typeof GetCreativeInputSchema>;
 
 export const GetCreativeQuerySchema = ProfileIdentifierSchema;
 
-// Re-exports for explicit intent
+/**
+ * --------------------------------
+ * OUTPUT ALIASES
+ * --------------------------------
+ */
+
 export const CreateCreativeOutputSchema = CreativeEntitySchema;
 export type CreateCreativeOutput = z.infer<typeof CreateCreativeOutputSchema>;
 
@@ -216,9 +149,12 @@ export type GetCreativeOutput = z.infer<typeof GetCreativeOutputSchema>;
 export const UpdateCreativeOutputSchema = CreativeEntitySchema;
 export type UpdateCreativeOutput = z.infer<typeof UpdateCreativeOutputSchema>;
 
-// -----------------------------------------------------------------------------
-// Entity With User
-// -----------------------------------------------------------------------------
+/**
+ * --------------------------------
+ * ENTITY WITH USER
+ * --------------------------------
+ */
+
 export const CreativeWithUserEntitySchema = MinimalCreativeEntitySchema.extend({
   user: MinimalUserSchema,
 });
@@ -227,20 +163,15 @@ export type CreativeWithUserEntity = z.infer<
   typeof CreativeWithUserEntitySchema
 >;
 
-// -----------------------------------------------------------------------------
-// Search Actions
-// -----------------------------------------------------------------------------
+/**
+ * --------------------------------
+ * SEARCH
+ * --------------------------------
+ */
+
 export const SearchCreativeInputSchema = 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),
+  string: z.string().min(1).max(200),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
   cursor: z.string().optional(),
 });