@zyacreatives/shared 1.1.4 → 1.2.2

package/dist/types/user.d.ts

@@ -1,43 +1,10 @@
-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">;
-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">;
-    })[];
-};
+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 UserWithProjectBookmarksEntity = z.infer<typeof UserWithProjectBookmarksEntitySchema>;
+export type UserWithFollowingEntity = z.infer<typeof UserWithFollowingEntitySchema>;
+export type UserWithFollowersEntity = z.infer<typeof UserWithFollowersEntitySchema>;

package/dist/utils/slugify.d.ts

@@ -0,0 +1,3 @@
+export declare const slugify: ({ value }: {
+    value: string;
+}) => string;

package/dist/utils/slugify.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = void 0;
+const slugify = ({ value }) => {
+    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
+};
+exports.slugify = slugify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zyacreatives/shared",
-  "version": "1.1.4",
+  "version": "1.2.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/schemas/brand.ts

@@ -1,34 +1,76 @@
 import { z } from "@hono/zod-openapi";
 import { CuidSchema, ProfileIdentifierSchema } from "./common";
 import { MinimalUserSchema } from "./user";
+import { EXPERIENCE_LEVELS, ExperienceLevel } from "../constants";
 
 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.",
-    }),
+    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." }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["technology", "saas", "startup"] }),
+    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" }),
+  })
+  .openapi("BrandEntity");
+
+export const BrandWithUserEntitySchema = BrandEntitySchema.extend({
+  user: MinimalUserSchema,
+  disciplines: z
+    .array(z.string())
+    .openapi({ example: ["Marketing", "Product Development"] }),
+}).openapi("BrandWithUserEntity");
+
+export const ListBrandsInputSchema = z
+  .object({
+    query: z.string().optional().openapi({ example: "AI software brand" }),
     disciplines: z
       .array(z.string())
       .optional()
+      .openapi({ example: ["design", "marketing"] }),
+    experienceLevels: z
+      .array(
+        z.enum(
+          Object.values(EXPERIENCE_LEVELS) as [
+            ExperienceLevel,
+            ...ExperienceLevel[]
+          ]
+        )
+      )
+      .optional()
       .openapi({
-        example: ["graphic-design", "branding"],
+        description:
+          "Filter based on the required experience level of partners.",
       }),
+    location: z.string().optional().openapi({ example: "San Francisco" }),
     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({ example: ["fintech", "remote"] }),
+    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("BrandEntity");
+  .openapi("ListBrandsInput");
 
 export const CreateBrandProfileSchema = z
   .object({
@@ -75,23 +117,3 @@ 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/creative.ts

@@ -1,38 +1,83 @@
 import { z } from "@hono/zod-openapi";
-import { EXPERIENCE_LEVELS } from "../constants";
+import { EXPERIENCE_LEVELS, ExperienceLevel } from "../constants";
 import { CuidSchema, ProfileIdentifierSchema } from "./common";
 import { MinimalUserSchema } from "./user";
 
-export const CreativeEntitySchema = z
+export const BaseCreativeEntitySchema = 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(),
+    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.",
+    }),
+    location: z.string().optional().openapi({ example: "London, UK" }),
     experienceLevel: z
-      .enum(Object.values(EXPERIENCE_LEVELS) as [string, ...string[]])
+      .enum(
+        Object.values(EXPERIENCE_LEVELS) as [
+          ExperienceLevel,
+          ...ExperienceLevel[]
+        ]
+      )
       .optional()
-      .openapi({ example: "1-3 years" }),
+      .openapi({ example: "SENIOR" }),
     tags: z
       .array(z.string())
       .optional()
-      .openapi({ example: ["digital-art", "illustration"] }),
+      .openapi({ example: ["branding", "typography", "UX"] }),
     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: ["Design", "Art Direction"] }),
+    user: z.any().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("BaseCreativeEntity");
+
+export const CreativeEntitySchema =
+  BaseCreativeEntitySchema.openapi("CreativeEntity");
+
+export const CreativeWithUserEntitySchema = CreativeEntitySchema.extend({
+  user: MinimalUserSchema,
+}).openapi("CreativeWithUserEntity");
+
+export const ListCreativesInputSchema = z
+  .object({
+    query: z.string().optional().openapi({ example: "logo designer" }),
+    disciplines: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["branding", "web design"] }),
+    experienceLevels: z
+      .array(
+        z.enum(
+          Object.values(EXPERIENCE_LEVELS) as [
+            ExperienceLevel,
+            ...ExperienceLevel[]
+          ]
+        )
+      )
+      .optional()
+      .openapi({ example: ["SENIOR", "EXPERT"] }),
+    location: z.string().optional().openapi({ example: "Los Angeles" }),
+    tags: z
+      .array(z.string())
+      .optional()
+      .openapi({ example: ["Figma", "AI"] }),
+    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("CreativeEntity");
+  .openapi("ListCreativesInput");
 
 export const CreateCreativeProfileSchema = z
   .object({
@@ -101,25 +146,5 @@ 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/investor.ts

@@ -0,0 +1,212 @@
+import { z } from "@hono/zod-openapi";
+import {
+  EXPERIENCE_LEVELS,
+  ExperienceLevel,
+  GEOGRAPHIC_FOCUS,
+  GeographicFocus,
+  INVESTMENT_SIZES,
+  InvestmentSize,
+  INVESTOR_TYPES,
+  InvestorType,
+} from "../constants";
+import { MinimalUserSchema } from "./user";
+import { CuidSchema, ProfileIdentifierSchema } from "./common";
+
+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
+      .string()
+      .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" }),
+  })
+  .openapi("InvestorEntity");
+
+export const InvestorWithUserEntitySchema = InvestorEntitySchema.extend({
+  user: MinimalUserSchema,
+  disciplines: z
+    .array(z.string())
+    .openapi({ example: ["Product Design", "AI Strategy"] }),
+}).openapi("InvestorWithUserEntity");
+
+export const CreateInvestorProfileSchema = z
+  .object({
+    bio: z.string().max(210).optional().default("").openapi({
+      example: "Angel investor backing early-stage African startups.",
+    }),
+    websiteURL: z.string().url("Invalid url").optional().openapi({
+      example: "https://www.investorportfolio.com",
+    }),
+    experienceLevel: z
+      .enum(
+        Object.values(EXPERIENCE_LEVELS) as [
+          ExperienceLevel,
+          ...ExperienceLevel[]
+        ]
+      )
+      .default(EXPERIENCE_LEVELS.YEAR_0_1)
+      .openapi({
+        example: "0-1 year",
+      }),
+    location: z.string().openapi({
+      example: "UK",
+    }),
+  })
+  .openapi({
+    title: "Create Investor Profile",
+  });
+
+export const UpdateInvestorProfileSchema = z
+  .object({
+    bio: z.string().max(210).optional().openapi({
+      example: "Seasoned venture capitalist with a focus on healthtech.",
+    }),
+    websiteURL: z.string().url("Invalid url").optional().openapi({
+      example: "https://www.vcgroup.com",
+    }),
+    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",
+      }),
+    location: z.string().optional().openapi({
+      example: "UK",
+    }),
+  })
+  .openapi({
+    title: "Update Investor Profile",
+  });
+
+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 const GetInvestorParamsSchema = z.object({
+  value: CuidSchema,
+});
+
+export const GetInvestorQuerySchema = ProfileIdentifierSchema;
+
+export const CreateInvestorEndpointResponseSchema = InvestorEntitySchema;
+export const GetInvestorEndpointResponseSchema = InvestorEntitySchema.extend({
+  user: MinimalUserSchema,
+});
+export const UpdateInvestorEndpointResponseSchema = InvestorEntitySchema;