@zyacreatives/shared 2.5.54 → 2.5.56

package/src/schemas/product.ts

@@ -1,47 +1,127 @@
 import { z } from "@hono/zod-openapi";
+
 import {
   DISCOUNT_TYPES,
   PRICING_MODELS,
   PRODUCT_STATUS,
   WAGES_CURRENCY,
 } from "../constants";
+
 import { CreateFileInputSchema, FileEntitySchema } from "./file";
 
+/**
+ * --------------------------------
+ * SHARED
+ * --------------------------------
+ */
+
 export const ProductDiscountEntitySchema = z.object({
   discountType: z.enum(DISCOUNT_TYPES),
-  amount: z
-    .number()
-    .int("Amount must be a whole number")
-    .min(0, "Discount amount cannot be negative"),
+  amount: z.number().int().min(0),
   discountCode: z.string().optional(),
   active: z.boolean().default(true),
 });
 
+export type ProductDiscountEntity = z.infer<typeof ProductDiscountEntitySchema>;
+
 export const ProductLinkSchema = z.object({
   title: z.string().nullable(),
   url: z.string(),
 });
 
-const ProductCoreInputSchema = z.object({
-  id: z.cuid2().openapi({ description: "Client-generated ID for the product" }),
+export type ProductLink = z.infer<typeof ProductLinkSchema>;
+
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
 
-  title: z.string().min(1, "Title is required").max(255),
-  description: z.string().min(1, "Description is required"),
+const ProductShape = z.object({
+  title: z.string().min(1).max(255),
+  description: z.string().min(1),
   keyFeatures: z.string(),
+
   status: z.enum(PRODUCT_STATUS).default("DRAFT"),
-  category: z.string().min(1, "Category is required"),
+
+  category: z.string().min(1),
   subcategory: z.string().optional(),
-  tags: z.array(z.string()).max(10, "Keep tags to a maximum of 10").default([]),
-  files: z.array(CreateFileInputSchema).default([]),
-  productLinks: z.array(ProductLinkSchema).default([]),
+
+  tags: z.array(z.string()).max(10).default([]),
 
   currency: z.enum(WAGES_CURRENCY),
   pricingModel: z.enum(PRICING_MODELS).default(PRICING_MODELS.FIXED),
-  price: z.number().int("Must be a whole number").min(0).optional(),
-  suggestedPrice: z.number().int("Must be in cents").min(0).optional(),
+  price: z.number().int().min(0).optional(),
+  suggestedPrice: z.number().int().min(0).optional(),
+
   discounts: z.array(ProductDiscountEntitySchema).max(3).default([]),
 });
 
+export type ProductShapeType = z.infer<typeof ProductShape>;
+
+const ProductComplianceShape = z.object({
+  supportEmail: z.email(),
+  supportPhone: z.string().optional(),
+
+  ownsRights: z.literal(true),
+  noHarmfulContent: z.literal(true),
+  providesSupport: z.boolean(),
+  agreesToTerms: z.literal(true),
+});
+
+export type ProductComplianceShapeType = z.infer<typeof ProductComplianceShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
+export const ProductEntitySchema = z
+  .object({
+    id: z.cuid2(),
+
+    sellerId: z.cuid2(),
+    sellerUsername: z.string(),
+    sellerName: z.string(),
+    sellerImageUrl: z.url().nullable().optional(),
+
+    ...ProductShape.shape,
+
+    subcategory: z.string().nullable().optional(),
+
+    files: z.array(FileEntitySchema).default([]),
+    productLinks: z.array(ProductLinkSchema).default([]),
+
+    ownsRights: z.boolean(),
+    noHarmfulContent: z.boolean(),
+    providesSupport: z.boolean(),
+    agreesToTerms: z.boolean(),
+
+    supportEmail: z.email().nullable().optional(),
+    supportPhone: z.string().nullable().optional(),
+
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    deletedAt: z.iso.datetime().nullable().optional(),
+  })
+  .openapi("Product");
+
+export type ProductEntity = z.infer<typeof ProductEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
+
+const ProductCoreInputSchema = ProductShape.extend({
+  id: z.cuid2(),
+
+  files: z.array(CreateFileInputSchema).default([]),
+  productLinks: z.array(ProductLinkSchema).default([]),
+});
+
 export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
   (data, ctx) => {
     if (
@@ -81,10 +161,11 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
     }
 
     const deliveryFiles = data.files.filter(
-      (f) => f.parentType === "PRODUCT_DELIVERY",
+      (file) => file.parentType === "PRODUCT_DELIVERY",
     );
+
     const coverImages = data.files.filter(
-      (f) => f.parentType === "PRODUCT_COVER",
+      (file) => file.parentType === "PRODUCT_COVER",
     );
 
     if (deliveryFiles.length === 0 && data.productLinks.length === 0) {
@@ -103,7 +184,8 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
         path: ["files"],
       });
     } else {
-      const thumbnails = coverImages.filter((img) => img.isThumbnail);
+      const thumbnails = coverImages.filter((image) => image.isThumbnail);
+
       if (thumbnails.length !== 1) {
         ctx.addIssue({
           code: "custom",
@@ -142,209 +224,190 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
   },
 );
 
-export const ProductServiceAndComplianceInputSchema = z.object({
-  id: z.cuid2().openapi({ description: "ID of the product" }),
-  supportEmail: z.email("A valid support email is required"),
-  supportPhone: z.string().optional(),
-  ownsRights: z.literal(
-    true,
-    '"You must confirm you own the rights to this product."',
-  ),
-  noHarmfulContent: z.literal(true, "You must confirm no harmful content."),
-  providesSupport: z.boolean(),
-  agreesToTerms: z.literal(true, "You must agree to the Terms."),
-});
+export type CreateProductInputEntity = z.infer<typeof CreateProductInputSchema>;
+
+export const ProductServiceAndComplianceInputSchema =
+  ProductComplianceShape.extend({
+    id: z.cuid2(),
+  }).openapi("ProductServiceAndComplianceInput");
+
+export type ProductServiceAndComplianceInputEntity = z.infer<
+  typeof ProductServiceAndComplianceInputSchema
+>;
 
 export const UpdateProductInputSchema = ProductCoreInputSchema.extend(
-  ProductServiceAndComplianceInputSchema.omit({ id: true }).shape,
+  ProductComplianceShape.shape,
 )
   .partial()
   .extend({
-    id: z.cuid2().openapi({ description: "ID of the product being updated" }),
+    id: z.cuid2(),
   });
 
-export const ProductEntitySchema = z
-  .object({
-    id: z.cuid2(),
-    sellerId: z.cuid2().openapi({ description: "ID of the creator/seller" }),
-    sellerUsername: z.string(),
-    sellerName: z.string(),
-    sellerImageUrl: z.url().optional().nullable(),
+export type UpdateProductInputEntity = z.infer<typeof UpdateProductInputSchema>;
 
-    title: z.string(),
-    description: z.string(),
-    keyFeatures: z.string(),
-    status: z.enum(PRODUCT_STATUS).default("DRAFT"),
-    category: z.string(),
-    subcategory: z.string().optional().nullable(),
-    tags: z.array(z.string()),
+export const SearchProductInputSchema = z.object({
+  queryString: z.string().max(200).optional(),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(30),
+  tags: z.array(z.string()).optional(),
+  filters: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  subcategory: z.string().optional(),
+});
 
-    files: z.array(FileEntitySchema).default([]),
-    productLinks: z.array(ProductLinkSchema).default([]),
+export type SearchProductInput = z.infer<typeof SearchProductInputSchema>;
 
-    pricingModel: z.enum(PRICING_MODELS),
-    currency: z.enum(WAGES_CURRENCY),
-    price: z.number().int().optional().nullable(),
-    suggestedPrice: z.number().int().optional().nullable(),
-    discounts: z.array(ProductDiscountEntitySchema).default([]),
+export const ProductDiscountCheckInputSchema = z.object({
+  discountCode: z.string(),
+  productId: z.cuid2(),
+});
 
-    ownsRights: z.boolean(),
-    noHarmfulContent: z.boolean(),
-    providesSupport: z.boolean(),
-    agreesToTerms: z.boolean(),
-    supportEmail: z.email().optional().nullable(),
-    supportPhone: z.string().optional().nullable(),
+export type ProductDiscountCheckInput = z.infer<
+  typeof ProductDiscountCheckInputSchema
+>;
 
-    createdAt: z.coerce.date(),
-    updatedAt: z.coerce.date(),
-    deletedAt: z.coerce.date().optional().nullable(),
-  })
-  .openapi({ title: "ProductEntity" });
+export const RevenueChartInputSchema = z.object({
+  startDate: z.string().optional(),
+  endDate: z.string().optional(),
+});
+
+export type RevenueChartInput = z.infer<typeof RevenueChartInputSchema>;
+
+/**
+ * --------------------------------
+ * SEARCH / MARKETPLACE
+ * --------------------------------
+ */
 
 export const ProductSearchDocumentSchema = z.object({
   id: z.cuid2(),
+
   sellerId: z.cuid2(),
   sellerUsername: z.string(),
   sellerName: z.string(),
-  status: z.enum(PRODUCT_STATUS),
   sellerImageUrl: z.url().nullable(),
+
+  status: z.enum(PRODUCT_STATUS),
+
   title: z.string(),
   category: z.string(),
   subcategory: z.string().nullable(),
   tags: z.array(z.string()),
+
   thumbnailImgUrl: z.url().nullable(),
+
   currency: z.enum(WAGES_CURRENCY),
   price: z.number().nullable(),
   suggestedPrice: z.number().nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-  deletedAt: z.coerce.date().optional().nullable(),
-});
 
-export const SearchProductInputSchema = z.object({
-  queryString: z
-    .string()
-    .max(200, { message: "Search string cannot exceed 200 characters" })
-    .optional()
-    .openapi({ example: "typescript utility types" }),
-  cursor: z.string().optional().openapi({ example: "ckj1a2b3c0000cur" }),
-  limit: z.coerce.number().int().min(1).max(100).optional().default(30),
-  tags: z.array(z.string()).optional(),
-  filters: z.array(z.string()).optional(),
-  category: z.string().optional(),
-  subcategory: z.string().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+  deletedAt: z.iso.datetime().nullable().optional(),
 });
 
-export const SearchProductOutputSchema = z.object({
-  products: z.array(ProductSearchDocumentSchema),
-  nextCursor: z.string().optional().nullable(),
+export type ProductSearchDocument = z.infer<typeof ProductSearchDocumentSchema>;
+
+export const MarketplaceProductEntitySchema = ProductEntitySchema.omit({
+  discounts: true,
 });
 
+export type MarketplaceProductEntity = z.infer<
+  typeof MarketplaceProductEntitySchema
+>;
+
 export const MarketplaceCategorySchema = z.object({
   name: z.string(),
   imgUrl: z.url(),
   subcategories: z.array(z.string()),
 });
 
+export type MarketplaceCategoryOutput = z.infer<
+  typeof MarketplaceCategorySchema
+>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
+
+export const SearchProductOutputSchema = z.object({
+  products: z.array(ProductSearchDocumentSchema),
+  nextCursor: z.string().optional(),
+});
+
+export type SearchProductOutput = z.infer<typeof SearchProductOutputSchema>;
+
 export const GetMarketplaceInfoOutputSchema = z.object({
   categories: z.array(MarketplaceCategorySchema),
   whatsHot: z.array(ProductSearchDocumentSchema),
   communityFavourites: z.array(ProductSearchDocumentSchema),
 });
 
-export const MarketplaceProductEntitySchema = ProductEntitySchema.omit({
-  discounts: true,
-});
-
-export const ProductDiscountCheckInputSchema = z.object({
-  discountCode: z.string(),
-  productId: z.cuid2(),
-});
+export type GetMarketplaceInfoOutput = z.infer<
+  typeof GetMarketplaceInfoOutputSchema
+>;
 
 export const ProductDiscountCheckOutputSchema = z.object({
   exists: z.boolean(),
   discount: ProductDiscountEntitySchema.nullable(),
 });
 
+export type ProductDiscountCheckOutput = z.infer<
+  typeof ProductDiscountCheckOutputSchema
+>;
+
 export const ProductStatsOutputSchema = z.object({
   salesToday: z.number().int(),
   revenueToday: z.number().int(),
   totalProductRevenue: z.number().int(),
 });
 
+export type ProductStatsOutput = z.infer<typeof ProductStatsOutputSchema>;
+
 export const ProductTransactionItemSchema = z.object({
   id: z.string(),
   customerEmail: z.string().nullable(),
   orderId: z.string().nullable(),
   price: z.number().int(),
   status: z.string(),
-  date: z.coerce.date(),
+  date: z.iso.datetime(),
 });
 
+export type ProductTransactionItem = z.infer<
+  typeof ProductTransactionItemSchema
+>;
+
 export const ProductTransactionsOutputSchema = z.object({
   transactions: z.array(ProductTransactionItemSchema),
 });
 
+export type ProductTransactionsOutput = z.infer<
+  typeof ProductTransactionsOutputSchema
+>;
+
 export const RevenueChartPointSchema = z.object({
-  date: z.string().openapi({ example: "2023-11-25" }),
+  date: z.string(),
   revenue: z.number().int(),
 });
 
+export type RevenueChartPoint = z.infer<typeof RevenueChartPointSchema>;
+
 export const ProductRevenueChartOutputSchema = z.object({
   chartData: z.array(RevenueChartPointSchema),
 });
 
-export const RevenueChartInputSchema = z.object({
-  startDate: z.string().optional().openapi({ description: "YYYY-MM-DD" }),
-  endDate: z.string().optional().openapi({ description: "YYYY-MM-DD" }),
-});
+export type ProductRevenueChartOutput = z.infer<
+  typeof ProductRevenueChartOutputSchema
+>;
 
 export const SellerDashboardStatsOutputSchema = z.object({
   totalSales: z.number().int(),
-  totalViews: z.number().int(), 
+  totalViews: z.number().int(),
   totalProducts: z.number().int(),
   totalDrafts: z.number().int(),
 });
 
-export type SellerDashboardStatsOutput = z.infer<typeof SellerDashboardStatsOutputSchema>;
-
-export type ProductLink = z.infer<typeof ProductLinkSchema>;
-export type SearchProductInput = z.infer<typeof SearchProductInputSchema>;
-export type SearchProductOutput = z.infer<typeof SearchProductOutputSchema>;
-export type MarketplaceCategoryOutput = z.infer<
-  typeof MarketplaceCategorySchema
->;
-export type GetMarketplaceInfoOutput = z.infer<
-  typeof GetMarketplaceInfoOutputSchema
->;
-
-export type ProductDiscountEntity = z.infer<typeof ProductDiscountEntitySchema>;
-export type CreateProductInputEntity = z.infer<typeof CreateProductInputSchema>;
-export type ProductServiceAndComplianceInputEntity = z.infer<
-  typeof ProductServiceAndComplianceInputSchema
->;
-export type UpdateProductInputEntity = z.infer<typeof UpdateProductInputSchema>;
-export type ProductEntity = z.infer<typeof ProductEntitySchema>;
-export type ProductSearchDocument = z.infer<typeof ProductSearchDocumentSchema>;
-export type MarketplaceProductEntity = z.infer<
-  typeof MarketplaceProductEntitySchema
->;
-
-export type ProductDiscountCheckInput = z.infer<
-  typeof ProductDiscountCheckInputSchema
->;
-export type ProductDiscountCheckOutput = z.infer<
-  typeof ProductDiscountCheckOutputSchema
+export type SellerDashboardStatsOutput = z.infer<
+  typeof SellerDashboardStatsOutputSchema
 >;
-export type ProductStatsOutput = z.infer<typeof ProductStatsOutputSchema>;
-export type ProductTransactionItem = z.infer<
-  typeof ProductTransactionItemSchema
->;
-export type ProductTransactionsOutput = z.infer<
-  typeof ProductTransactionsOutputSchema
->;
-export type RevenueChartPoint = z.infer<typeof RevenueChartPointSchema>;
-export type ProductRevenueChartOutput = z.infer<
-  typeof ProductRevenueChartOutputSchema
->;
-export type RevenueChartInput = z.infer<typeof RevenueChartInputSchema>;