robodev 0.22.0 → 0.24.0

package/templates/marketplace/api/_lib.ts

@@ -0,0 +1,677 @@
+import { and, asc, eq, gt, ilike, inArray, or, type InferSelectModel } from "@robodev-ai/sdk";
+import type { ApiHandlerContext, EmailClient, UploadedFile } from "@robodev-ai/sdk";
+import {
+  cartItems,
+  categories,
+  listingImages,
+  listings,
+  media,
+  orderItems,
+  orders,
+  reviews,
+  watches,
+} from "../database";
+
+export const LISTING_IMAGE_RESOURCE = "listing-image";
+export const SEED_SELLER_ID = "seed-seller";
+export const SEED_SELLER_NAME = "Marketplace Demo";
+export const SEED_SELLER_EMAIL = "seed-seller@marketplace.local";
+export const MAX_LISTING_IMAGES = 8;
+export const LISTING_STATUS = { active: "active", inactive: "inactive" } as const;
+export const ORDER_STATUS = {
+  paid: "paid",
+  shipped: "shipped",
+  completed: "completed",
+} as const;
+
+const ALLOWED_LISTING_IMAGE_TYPES = new Set(["image/jpeg", "image/png", "image/webp"]);
+const MAX_LISTING_IMAGE_BYTES = 2 * 1024 * 1024;
+
+export const CATEGORY_SEEDS = [
+  { slug: "electronics", name: "Electronics" },
+  { slug: "home", name: "Home" },
+  { slug: "fashion", name: "Fashion" },
+  { slug: "collectibles", name: "Collectibles" },
+] as const;
+
+export const LISTING_SEEDS = [
+  {
+    slug: "electronics",
+    title: "Vintage analog synthesizer",
+    description: "Fully working 1980s synth with original case and power supply.",
+    priceCents: 42900,
+    quantity: 1,
+    shippingCents: 2500,
+    shippingDays: 5,
+  },
+  {
+    slug: "electronics",
+    title: "Wireless noise-cancelling headphones",
+    description: "Over-ear headphones with 30-hour battery and USB-C charging.",
+    priceCents: 8900,
+    quantity: 4,
+    shippingCents: 799,
+    shippingDays: 3,
+  },
+  {
+    slug: "electronics",
+    title: "Refurbished tablet 10-inch",
+    description: "Factory-reset tablet with charger. Light scuffs on the back.",
+    priceCents: 12900,
+    quantity: 2,
+    shippingCents: 995,
+    shippingDays: 4,
+  },
+  {
+    slug: "home",
+    title: "Cast iron skillet 12-inch",
+    description: "Pre-seasoned skillet. Heavy, even heat for stovetop and oven.",
+    priceCents: 4500,
+    quantity: 6,
+    shippingCents: 1200,
+    shippingDays: 4,
+  },
+  {
+    slug: "home",
+    title: "Linen duvet cover set",
+    description: "Queen size, stone-washed linen, includes two pillow shams.",
+    priceCents: 7800,
+    quantity: 3,
+    shippingCents: 899,
+    shippingDays: 5,
+  },
+  {
+    slug: "home",
+    title: "Ceramic pour-over coffee set",
+    description: "Dripper, carafe, and two mugs. Unused in original box.",
+    priceCents: 3600,
+    quantity: 5,
+    shippingCents: 650,
+    shippingDays: 3,
+  },
+  {
+    slug: "fashion",
+    title: "Wool overcoat, size M",
+    description: "Charcoal wool coat, worn twice. No stains or missing buttons.",
+    priceCents: 11500,
+    quantity: 1,
+    shippingCents: 1400,
+    shippingDays: 4,
+  },
+  {
+    slug: "fashion",
+    title: "Leather belt, 34-inch",
+    description: "Full-grain leather belt with brass buckle. Barely used.",
+    priceCents: 2800,
+    quantity: 3,
+    shippingCents: 499,
+    shippingDays: 2,
+  },
+  {
+    slug: "fashion",
+    title: "Canvas sneakers, size 42",
+    description: "Low-top canvas sneakers. Clean uppers, original laces.",
+    priceCents: 3200,
+    quantity: 2,
+    shippingCents: 599,
+    shippingDays: 3,
+  },
+  {
+    slug: "collectibles",
+    title: "First-print sci-fi paperback",
+    description: "1970s first printing. Tight spine, light shelf wear.",
+    priceCents: 5400,
+    quantity: 1,
+    shippingCents: 450,
+    shippingDays: 3,
+  },
+  {
+    slug: "collectibles",
+    title: "Enamel pin lot of 12",
+    description: "Assorted enamel pins from independent artists. All backed.",
+    priceCents: 1800,
+    quantity: 8,
+    shippingCents: 399,
+    shippingDays: 2,
+  },
+  {
+    slug: "collectibles",
+    title: "Framed concert poster",
+    description: "18x24 poster in a black frame. Ready to hang.",
+    priceCents: 6700,
+    quantity: 1,
+    shippingCents: 1800,
+    shippingDays: 6,
+  },
+] as const;
+
+export type CategoryRow = InferSelectModel<typeof categories>;
+export type ListingRow = InferSelectModel<typeof listings>;
+export type CartItemRow = InferSelectModel<typeof cartItems>;
+export type OrderRow = InferSelectModel<typeof orders>;
+export type OrderItemRow = InferSelectModel<typeof orderItems>;
+export type ReviewRow = InferSelectModel<typeof reviews>;
+
+export type ImageDto = { id: string; url: string };
+export type CategoryDto = { id: string; slug: string; name: string };
+
+export type ListingDto = {
+  id: string;
+  sellerId: string;
+  sellerName?: string | null;
+  sellerEmail: string;
+  categoryId: string;
+  title: string;
+  description?: string | null;
+  priceCents: number;
+  quantity: number;
+  shippingCents: number;
+  shippingDays: number;
+  status: string;
+  createdAt: string;
+  updatedAt: string;
+  images: ImageDto[];
+  category: CategoryDto | null;
+  sellerAverageRating: number | null;
+  watchedByMe: boolean;
+};
+
+export type CartItemDto = {
+  id: string;
+  userId: string;
+  listingId: string;
+  quantity: number;
+  listing: ListingDto;
+};
+
+export type OrderItemDto = {
+  id: string;
+  orderId: string;
+  listingId: string;
+  title: string;
+  qty: number;
+  unitPriceCents: number;
+};
+
+export type OrderDto = {
+  id: string;
+  buyerId: string;
+  buyerEmail: string;
+  sellerId: string;
+  sellerEmail: string;
+  status: string;
+  shippingName: string;
+  shippingLine1: string;
+  shippingLine2?: string | null;
+  shippingCity: string;
+  shippingRegion?: string | null;
+  shippingPostal: string;
+  shippingCountry: string;
+  shippingCents: number;
+  totalCents: number;
+  last4?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  items: OrderItemDto[];
+};
+
+export type ReviewDto = {
+  id: string;
+  listingId: string;
+  orderId: string;
+  buyerId: string;
+  rating: number;
+  body?: string | null;
+  createdAt: string;
+};
+
+type Db = ApiHandlerContext<unknown, unknown>["db"];
+
+export function fail(status: number, message: string) {
+  return { status, body: { message } };
+}
+
+export function iso(value: Date | string | null | undefined): string | null {
+  if (!value) return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+export function requiredIso(value: Date | string | null | undefined): string {
+  return iso(value) ?? new Date().toISOString();
+}
+
+export function toInt(value: unknown, fallback = 0): number {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return Math.trunc(parsed);
+  }
+  return fallback;
+}
+
+export function parseOptionalInt(value: unknown): number | undefined {
+  if (value == null || value === "") return undefined;
+  const parsed = toInt(value, Number.NaN);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function isTruthyQuery(value: unknown): boolean {
+  return value === true || value === "true" || value === "1" || value === 1;
+}
+
+export function paginate<T>(items: T[], page?: number, limit?: number) {
+  const currentPage = page && page > 0 ? page : 1;
+  const currentLimit = limit && limit > 0 ? Math.min(limit, 20) : 20;
+  const start = (currentPage - 1) * currentLimit;
+  const nextPage = currentPage * currentLimit < items.length ? currentPage + 1 : null;
+  return {
+    items: items.slice(start, start + currentLimit),
+    page: currentPage,
+    cursor: String(currentPage),
+    nextCursor: nextPage ? String(nextPage) : null,
+    limit: currentLimit,
+    totalItems: items.length,
+  };
+}
+
+export function isSeedRecipient(to: string, sellerId?: string | null) {
+  return to === SEED_SELLER_EMAIL || sellerId === SEED_SELLER_ID;
+}
+
+export async function sendMail(
+  email: EmailClient,
+  input: { to: string; subject: string; text: string; sellerId?: string | null },
+) {
+  if (isSeedRecipient(input.to, input.sellerId)) return;
+  await email.send({ to: input.to, subject: input.subject, text: input.text });
+}
+
+export async function ensureSeed(db: Db) {
+  const existingCategories = await db.select({ id: categories.id }).from(categories).limit(1);
+  if (existingCategories.length === 0) {
+    try {
+      await db.insert(categories).values(
+        CATEGORY_SEEDS.map((row) => ({
+          slug: row.slug,
+          name: row.name,
+        })),
+      );
+    } catch {
+      // First request won the seed race.
+    }
+  }
+
+  const existingListings = await db.select({ id: listings.id }).from(listings).limit(1);
+  if (existingListings.length > 0) return;
+
+  const categoryRows = await db.select().from(categories);
+  if (categoryRows.length === 0) return;
+  const bySlug = new Map(categoryRows.map((row) => [row.slug, row]));
+  const now = new Date();
+  try {
+    await db.insert(listings).values(
+      LISTING_SEEDS.flatMap((seed) => {
+        const category = bySlug.get(seed.slug);
+        if (!category) return [];
+        return [
+          {
+            sellerId: SEED_SELLER_ID,
+            sellerName: SEED_SELLER_NAME,
+            sellerEmail: SEED_SELLER_EMAIL,
+            categoryId: category.id,
+            title: seed.title,
+            description: seed.description,
+            priceCents: seed.priceCents,
+            quantity: seed.quantity,
+            shippingCents: seed.shippingCents,
+            shippingDays: seed.shippingDays,
+            status: LISTING_STATUS.active,
+            createdAt: now,
+            updatedAt: now,
+          },
+        ];
+      }),
+    );
+  } catch {
+    // First request won the seed race.
+  }
+}
+
+function sanitizeFilename(name: string): string {
+  const base = name.split(/[/\\]/).pop() ?? "";
+  return base
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 80);
+}
+
+export function listingUploadFiles(files: UploadedFile[] | undefined): UploadedFile[] {
+  const all = files ?? [];
+  const named = all.filter((file) => file.fieldname === "file" || file.fieldname === "files");
+  return (named.length > 0 ? named : all).filter((file) => file.data.length > 0);
+}
+
+export async function saveListingImage(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  file: UploadedFile,
+): Promise<{ id: string } | ReturnType<typeof fail>> {
+  const mimeType = file.mimetype || "application/octet-stream";
+  if (file.data.length > MAX_LISTING_IMAGE_BYTES) {
+    return fail(400, "File is too large");
+  }
+  if (!ALLOWED_LISTING_IMAGE_TYPES.has(mimeType)) {
+    return fail(400, "Unsupported image type");
+  }
+
+  const fileName = file.filename || "image";
+  const safe = sanitizeFilename(fileName) || "image";
+  const key = `listing-images/${ctx.user!.id}/${crypto.randomUUID()}-${safe}`;
+  const [row] = await ctx.db
+    .insert(media)
+    .values({
+      key,
+      userId: ctx.user!.id,
+      resourceName: LISTING_IMAGE_RESOURCE,
+      fileName,
+      fileSize: file.data.length,
+      mimeType,
+    })
+    .returning();
+
+  try {
+    await ctx.storage.upload(row!.key, file.data, {
+      public: true,
+      contentType: mimeType,
+    });
+  } catch (error) {
+    return fail(503, error instanceof Error ? error.message : "Storage is not configured");
+  }
+
+  await ctx.db.update(media).set({ uploaded: new Date() }).where(eq(media.id, row!.id));
+  return { id: row!.id };
+}
+
+export async function resolveImage(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  imageId: string,
+): Promise<ImageDto | null> {
+  const [row] = await ctx.db.select().from(media).where(eq(media.id, imageId)).limit(1);
+  if (!row?.uploaded) return null;
+  try {
+    const url = await ctx.storage.getUrl(row.key);
+    return { id: row.id, url };
+  } catch {
+    return { id: row.id, url: `/storage/objects/${encodeURIComponent(row.key)}` };
+  }
+}
+
+export async function findListing(db: Db, id: string) {
+  const [row] = await db.select().from(listings).where(eq(listings.id, id)).limit(1);
+  return row ?? null;
+}
+
+export async function findCategory(db: Db, id: string) {
+  const [row] = await db.select().from(categories).where(eq(categories.id, id)).limit(1);
+  return row ?? null;
+}
+
+export function isActiveForSale(listing: ListingRow) {
+  return listing.status === LISTING_STATUS.active && listing.quantity > 0;
+}
+
+export function browsePredicate(search?: string | null, categoryId?: string | null) {
+  const parts = [eq(listings.status, LISTING_STATUS.active), gt(listings.quantity, 0)];
+  if (categoryId) parts.push(eq(listings.categoryId, categoryId));
+  const term = search?.trim();
+  if (term) {
+    const pattern = `%${term}%`;
+    parts.push(or(ilike(listings.title, pattern), ilike(listings.description, pattern))!);
+  }
+  return and(...parts);
+}
+
+export async function enrichListings(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  rows: ListingRow[],
+  currentUserId: string,
+): Promise<ListingDto[]> {
+  if (rows.length === 0) return [];
+  const listingIds = rows.map((row) => row.id);
+  const sellerIds = [...new Set(rows.map((row) => row.sellerId))];
+  const categoryIds = [...new Set(rows.map((row) => row.categoryId))];
+
+  const [categoryRows, imageRows, watchRows, sellerListingRows] = await Promise.all([
+    ctx.db.select().from(categories).where(inArray(categories.id, categoryIds)),
+    ctx.db
+      .select()
+      .from(listingImages)
+      .where(inArray(listingImages.listingId, listingIds))
+      .orderBy(asc(listingImages.sortOrder)),
+    ctx.db
+      .select()
+      .from(watches)
+      .where(and(eq(watches.userId, currentUserId), inArray(watches.listingId, listingIds))),
+    ctx.db
+      .select({ id: listings.id, sellerId: listings.sellerId })
+      .from(listings)
+      .where(inArray(listings.sellerId, sellerIds)),
+  ]);
+
+  const sellerListingIds = sellerListingRows.map((row) => row.id);
+  const reviewRows =
+    sellerListingIds.length === 0
+      ? []
+      : await ctx.db
+          .select({ listingId: reviews.listingId, rating: reviews.rating })
+          .from(reviews)
+          .where(inArray(reviews.listingId, sellerListingIds));
+
+  const categoryById = new Map(categoryRows.map((row) => [row.id, row]));
+  const watched = new Set(watchRows.map((row) => row.listingId));
+  const listingIdsBySeller = new Map<string, string[]>();
+  for (const row of sellerListingRows) {
+    const list = listingIdsBySeller.get(row.sellerId) ?? [];
+    list.push(row.id);
+    listingIdsBySeller.set(row.sellerId, list);
+  }
+  const ratingByListing = new Map<string, number[]>();
+  for (const row of reviewRows) {
+    const list = ratingByListing.get(row.listingId) ?? [];
+    list.push(row.rating);
+    ratingByListing.set(row.listingId, list);
+  }
+  const averageBySeller = new Map<string, number | null>();
+  for (const sellerId of sellerIds) {
+    const ids = listingIdsBySeller.get(sellerId) ?? [];
+    const ratings = ids.flatMap((id) => ratingByListing.get(id) ?? []);
+    averageBySeller.set(
+      sellerId,
+      ratings.length === 0
+        ? null
+        : Math.round((ratings.reduce((sum, value) => sum + value, 0) / ratings.length) * 10) / 10,
+    );
+  }
+
+  const imagesByListing = new Map<string, ImageDto[]>();
+  for (const image of imageRows) {
+    const resolved = await resolveImage(ctx, image.mediaId);
+    if (!resolved) continue;
+    const list = imagesByListing.get(image.listingId) ?? [];
+    list.push(resolved);
+    imagesByListing.set(image.listingId, list);
+  }
+
+  return rows.map((row) => {
+    const category = categoryById.get(row.categoryId);
+    return {
+      id: row.id,
+      sellerId: row.sellerId,
+      sellerName: row.sellerName,
+      sellerEmail: row.sellerEmail,
+      categoryId: row.categoryId,
+      title: row.title,
+      description: row.description,
+      priceCents: row.priceCents,
+      quantity: row.quantity,
+      shippingCents: row.shippingCents,
+      shippingDays: row.shippingDays,
+      status: row.status,
+      createdAt: requiredIso(row.createdAt),
+      updatedAt: requiredIso(row.updatedAt),
+      images: imagesByListing.get(row.id) ?? [],
+      category: category ? { id: category.id, slug: category.slug, name: category.name } : null,
+      sellerAverageRating: averageBySeller.get(row.sellerId) ?? null,
+      watchedByMe: watched.has(row.id),
+    };
+  });
+}
+
+export async function enrichOne(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  listing: ListingRow,
+  currentUserId: string,
+) {
+  const [dto] = await enrichListings(ctx, [listing], currentUserId);
+  return dto!;
+}
+
+export async function replaceListingImages(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  listingId: string,
+  files: UploadedFile[],
+  removeImageIds: string[],
+  existingCount: number,
+): Promise<ReturnType<typeof fail> | { added: number }> {
+  if (removeImageIds.length > 0) {
+    await ctx.db
+      .delete(listingImages)
+      .where(
+        and(eq(listingImages.listingId, listingId), inArray(listingImages.mediaId, removeImageIds)),
+      );
+  }
+  const remaining = await ctx.db
+    .select()
+    .from(listingImages)
+    .where(eq(listingImages.listingId, listingId));
+  if (remaining.length + files.length > MAX_LISTING_IMAGES) {
+    return fail(400, "Too many images");
+  }
+  let sortOrder = remaining.reduce((max, row) => Math.max(max, row.sortOrder), -1) + 1;
+  for (const file of files) {
+    const saved = await saveListingImage(ctx, file);
+    if (!("id" in saved)) return saved;
+    await ctx.db.insert(listingImages).values({
+      listingId,
+      mediaId: saved.id,
+      sortOrder,
+    });
+    sortOrder += 1;
+  }
+  return { added: files.length + existingCount };
+}
+
+export function parseRemoveImageIds(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === "string" && item.length > 0);
+  }
+  if (typeof value !== "string" || !value.trim()) return [];
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      return Array.isArray(parsed)
+        ? parsed.filter((item): item is string => typeof item === "string" && item.length > 0)
+        : [];
+    } catch {
+      return [];
+    }
+  }
+  return trimmed
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function parseListingWrite(body: {
+  title: string;
+  description?: string;
+  categoryId: string;
+  priceCents: number;
+  quantity: number;
+  shippingCents: number;
+  shippingDays: number;
+  status?: string;
+}) {
+  if (!body.title.trim()) return fail(400, "Title is required");
+  if (body.priceCents < 0 || body.quantity < 0 || body.shippingCents < 0 || body.shippingDays < 1) {
+    return fail(400, "Invalid listing amounts");
+  }
+  const status =
+    body.status === LISTING_STATUS.inactive ? LISTING_STATUS.inactive : LISTING_STATUS.active;
+  return {
+    title: body.title.trim(),
+    description: body.description?.trim() ? body.description.trim() : null,
+    categoryId: body.categoryId,
+    priceCents: body.priceCents,
+    quantity: body.quantity,
+    shippingCents: body.shippingCents,
+    shippingDays: body.shippingDays,
+    status,
+  };
+}
+
+export function toOrderDto(order: OrderRow, items: OrderItemRow[]): OrderDto {
+  return {
+    id: order.id,
+    buyerId: order.buyerId,
+    buyerEmail: order.buyerEmail,
+    sellerId: order.sellerId,
+    sellerEmail: order.sellerEmail,
+    status: order.status,
+    shippingName: order.shippingName,
+    shippingLine1: order.shippingLine1,
+    shippingLine2: order.shippingLine2,
+    shippingCity: order.shippingCity,
+    shippingRegion: order.shippingRegion,
+    shippingPostal: order.shippingPostal,
+    shippingCountry: order.shippingCountry,
+    shippingCents: order.shippingCents,
+    totalCents: order.totalCents,
+    last4: order.last4,
+    createdAt: requiredIso(order.createdAt),
+    updatedAt: requiredIso(order.updatedAt),
+    items: items.map((item) => ({
+      id: item.id,
+      orderId: item.orderId,
+      listingId: item.listingId,
+      title: item.title,
+      qty: item.qty,
+      unitPriceCents: item.unitPriceCents,
+    })),
+  };
+}
+
+export function toReviewDto(row: ReviewRow): ReviewDto {
+  return {
+    id: row.id,
+    listingId: row.listingId,
+    orderId: row.orderId,
+    buyerId: row.buyerId,
+    rating: row.rating,
+    body: row.body,
+    createdAt: requiredIso(row.createdAt),
+  };
+}
+
+export {
+  cartItems,
+  categories,
+  listingImages,
+  listings,
+  media,
+  orderItems,
+  orders,
+  reviews,
+  watches,
+};