robodev 0.22.0 → 0.24.0

package/templates/marketplace/apps/fe/src/types/i18next.d.ts

@@ -0,0 +1,12 @@
+import "i18next";
+
+import type { defaultNS, resources } from "@/config/i18n";
+
+declare module "i18next" {
+  interface CustomTypeOptions {
+    enableSelector: true;
+    returnNull: false;
+    defaultNS: typeof defaultNS;
+    resources: (typeof resources)["en"];
+  }
+}

package/templates/marketplace/apps/fe/src/types/table.d.ts

@@ -0,0 +1,17 @@
+/* oxlint-disable unused-imports/no-unused-vars */
+import "@tanstack/react-table";
+
+declare module "@tanstack/react-table" {
+  interface ColumnMeta<TData extends RowData, TValue> {
+    width?: string;
+    headerClass?: string;
+    cellClass?: string;
+    sortClass?: string;
+  }
+
+  interface CellContext<TData extends RowData, TValue> {
+    original: TData;
+    data: TData;
+    value: TValue;
+  }
+}

package/templates/marketplace/apps/fe/src/types/ui.d.ts

@@ -0,0 +1,26 @@
+import "@povio/ui";
+import type { UIOverrides } from "@povio/ui";
+import type { LinkProps } from "@tanstack/react-router";
+import type { RowData } from "@tanstack/react-table";
+
+import type { tableRowOverride } from "@/styles/overrides/defaults/table.override";
+import type { typographyOverride } from "@/styles/overrides/defaults/typography.override";
+
+declare module "@povio/ui" {
+  interface LinkNavigationProps extends LinkProps {}
+
+  interface TypographyVariantProps {
+    size?: UIOverrides.VariantProps<typeof typographyOverride>["size"];
+    sizeMobile?: UIOverrides.VariantProps<typeof typographyOverride>["sizeMobile"];
+  }
+
+  interface TableRowVariantProps {
+    rowSize?: UIOverrides.VariantProps<typeof tableRowOverride>["rowSize"];
+  }
+}
+
+declare module "@tanstack/react-table" {
+  interface ColumnMeta<TData extends RowData, TValue> {
+    filterKey?: string;
+  }
+}

package/templates/marketplace/apps/fe/src/types/vite-env.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_PUBLIC_ENABLE_WEB_VITALS: "true" | "false";
+  readonly VITE_PUBLIC_API_URL: string;
+  readonly VITE_PUBLIC_API_MODE?: "fake" | "real";
+  readonly VITE_PUBLIC_FAKE_BE_SEED_VERSION?: string;
+  readonly VITE_PUBLIC_LOG_LEVEL: "error" | "warn";
+  readonly VITE_PUBLIC_SENTRY_DSN: string;
+  readonly VITE_PUBLIC_SENTRY_ENVIRONMENT: string;
+  readonly VITE_PUBLIC_SENTRY_TRACES_SAMPLE_RATE: string;
+  readonly VITE_PUBLIC_SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE: string;
+  readonly VITE_PUBLIC_SENTRY_REPLAYS_SESSION_SAMPLE_RATE: string;
+  readonly VITE_PUBLIC_GOOGLE_ANALYTICS_MEASUREMENT_ID: string;
+  readonly VITE_PUBLIC_AUTH_CUSTOM_JWT_ENABLE_MAGIC_LINK: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/templates/marketplace/apps/fe/src/utils/date.utils.ts

@@ -0,0 +1,17 @@
+import { DateUtils as PovioDateUtils } from "@povio/ui";
+
+export namespace DateUtils {
+  export const parseDate = (date: string | Date): Date => (typeof date === "string" ? new Date(date) : date);
+
+  export const formatDate = (date: string | Date, format = "dd/MM/yyyy") => {
+    const parsedDate = parseDate(date);
+
+    return PovioDateUtils.formatDate(parsedDate, format);
+  };
+
+  export const formatDateTime = (date: string | Date, format = "dd/MM/yyyy HH:mm") => {
+    const parsedDate = parseDate(date);
+
+    return PovioDateUtils.formatDate(parsedDate, format);
+  };
+}

package/templates/marketplace/apps/fe/src/utils/image-fallback.ts

@@ -0,0 +1,9 @@
+interface ImageFallbackOptions {
+  width: number;
+  height: number;
+  text?: string;
+}
+
+export function getFallbackImageUrl({ width, height, text = "No image" }: ImageFallbackOptions): string {
+  return `https://placehold.co/${width}x${height}?text=${encodeURIComponent(text)}`;
+}

package/templates/marketplace/apps/fe/src/utils/listing-form.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  bindLocalListingImages,
+  buildListingFormData,
+  dollarsToCents,
+  listingFormRequestConfig,
+  localListingImageUpload,
+} from "./listing-form";
+
+describe("listing multipart submit", () => {
+  it("builds FormData with text fields and multiple files", () => {
+    const first = new File(["png"], "one.png", { type: "image/png" });
+    const second = new File(["jpg"], "two.jpg", { type: "image/jpeg" });
+    const form = buildListingFormData({
+      title: "Lamp",
+      description: "Desk lamp",
+      categoryId: "cat-1",
+      priceCents: 2500,
+      quantity: 2,
+      shippingCents: 400,
+      shippingDays: 3,
+      files: [first, second],
+    });
+
+    expect(form.get("title")).toBe("Lamp");
+    expect(form.get("priceCents")).toBe("2500");
+    expect(form.getAll("files")).toHaveLength(2);
+    expect(form.get("clearImage")).toBeNull();
+  });
+
+  it("sends removeImageIds when updating without those media ids", () => {
+    const form = buildListingFormData({
+      title: "Lamp",
+      categoryId: "cat-1",
+      priceCents: 2500,
+      quantity: 1,
+      shippingCents: 400,
+      shippingDays: 3,
+      removeImageIds: ["media-1", "media-2"],
+    });
+    expect(form.get("removeImageIds")).toBe("media-1,media-2");
+  });
+
+  it("does not set Content-Type so the browser can add the multipart boundary", () => {
+    const config = listingFormRequestConfig() as { headers?: Record<string, string> };
+    expect(config.headers?.["Content-Type"]).toBeUndefined();
+    expect("Content-Type" in (config.headers ?? {})).toBe(false);
+  });
+
+  it("local FileUpload handler never fetches", async () => {
+    const file = new File(["png"], "lamp.png", { type: "image/png" });
+    const result = await localListingImageUpload({ data: {} } as never, file);
+    expect(result).toEqual({ id: "lamp.png" });
+  });
+
+  it("bindLocalListingImages keeps Files locally without fetching", async () => {
+    const seen: File[] = [];
+    const handlers = bindLocalListingImages((file) => seen.push(file));
+    const file = new File(["png"], "lamp.png", { type: "image/png" });
+    await handlers.fileUpload({ data: {} }, file);
+    expect(seen).toEqual([file]);
+  });
+
+  it("converts dollars to integer cents", () => {
+    expect(dollarsToCents("12.99")).toBe(1299);
+    expect(dollarsToCents(12)).toBe(1200);
+  });
+});

package/templates/marketplace/apps/fe/src/utils/listing-form.ts

@@ -0,0 +1,77 @@
+export type ListingWriteFields = {
+  title: string;
+  description?: string | null;
+  categoryId: string;
+  priceCents: number;
+  quantity: number;
+  shippingCents: number;
+  shippingDays: number;
+  status?: string;
+  files?: File[];
+  removeImageIds?: string[];
+};
+
+function appendOptional(form: FormData, key: string, value: unknown) {
+  if (value == null || value === "") return;
+  form.append(key, String(value));
+}
+
+export function buildListingFormData(fields: ListingWriteFields): FormData {
+  const form = new FormData();
+  form.append("title", fields.title);
+  appendOptional(form, "description", fields.description);
+  form.append("categoryId", fields.categoryId);
+  form.append("priceCents", String(fields.priceCents));
+  form.append("quantity", String(fields.quantity));
+  form.append("shippingCents", String(fields.shippingCents));
+  form.append("shippingDays", String(fields.shippingDays));
+  appendOptional(form, "status", fields.status);
+  for (const file of fields.files ?? []) {
+    form.append("files", file);
+    form.append("file", file);
+  }
+  if (fields.removeImageIds?.length) {
+    form.append("removeImageIds", fields.removeImageIds.join(","));
+  }
+  return form;
+}
+
+/** Axios/browser must set the multipart boundary. Never set Content-Type. */
+export function listingFormRequestConfig() {
+  return {};
+}
+
+export async function localListingImageUpload(
+  _request: unknown,
+  file: File,
+): Promise<{ id: string }> {
+  return { id: file.name };
+}
+
+export function bindLocalListingImages(onFile: (file: File) => void, onClear?: () => void) {
+  return {
+    fileUpload: async (request: unknown, file: File) => {
+      onFile(file);
+      return localListingImageUpload(request, file);
+    },
+    fileRemove: async () => {
+      onClear?.();
+    },
+  };
+}
+
+export function dollarsToCents(value: string | number): number {
+  const amount = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(amount)) return 0;
+  return Math.round(amount * 100);
+}
+
+export function centsToDollarsInput(cents: number): string {
+  return (cents / 100).toFixed(2);
+}
+
+export function formatCents(cents: number): string {
+  return new Intl.NumberFormat(undefined, { style: "currency", currency: "USD" }).format(
+    cents / 100,
+  );
+}

package/templates/marketplace/apps/fe/src/utils/listing-submit.ts

@@ -0,0 +1,29 @@
+import { AppRestClient } from "@/clients/app-rest-client";
+import { ListingModels } from "@/openapi/listing/listing.models";
+
+import {
+  buildListingFormData,
+  listingFormRequestConfig,
+  type ListingWriteFields,
+} from "./listing-form";
+
+export async function createListing(fields: ListingWriteFields): Promise<ListingModels.ListingDto> {
+  return AppRestClient.post(
+    { resSchema: ListingModels.ListingDtoSchema },
+    "/api/listings",
+    buildListingFormData(fields),
+    listingFormRequestConfig(),
+  );
+}
+
+export async function updateListing(
+  id: string,
+  fields: ListingWriteFields,
+): Promise<ListingModels.ListingDto> {
+  return AppRestClient.put(
+    { resSchema: ListingModels.ListingDtoSchema },
+    `/api/listings/${id}`,
+    buildListingFormData(fields),
+    listingFormRequestConfig(),
+  );
+}

package/templates/marketplace/apps/fe/src/utils/number.utils.ts

@@ -0,0 +1,12 @@
+export namespace NumberUtils {
+  export function formatNumber(value: number, options?: Intl.NumberFormatOptions): string {
+    return new Intl.NumberFormat(undefined, options).format(value);
+  }
+
+  export function formatInteger(value: number, options?: Intl.NumberFormatOptions): string {
+    return formatNumber(value, {
+      maximumFractionDigits: 0,
+      ...options,
+    });
+  }
+}

package/templates/marketplace/apps/fe/src/utils/string.utils.ts

@@ -0,0 +1,5 @@
+export namespace StringUtils {
+  export function emptyToUndefined(value: string | null | undefined): string | undefined {
+    return value || undefined;
+  }
+}

package/templates/marketplace/apps/fe/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/templates/marketplace/apps/fe/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client", "node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": false,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Absolute imports */
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src", "node_modules/@povio/ui/dist/index.d.ts"]
+}

package/templates/marketplace/apps/fe/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "files": [],
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }]
+}

package/templates/marketplace/apps/fe/tsconfig.node.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Absolute imports */
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/templates/marketplace/apps/fe/vite.config.ts

@@ -0,0 +1,125 @@
+import { applyEnv, resolveConfigSync, getNumber, getString } from "@povio/resolve-config";
+import reactScan from "@povio/vite-plugin-react-scan";
+import tailwindCSS from "@tailwindcss/vite";
+import { devtools } from "@tanstack/devtools-vite";
+import { tanstackRouter } from "@tanstack/router-plugin/vite";
+import viteReact from "@vitejs/plugin-react";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { defineConfig as defineViteConfig, mergeConfig } from "vite";
+import devtoolsJson from "vite-plugin-devtools-json";
+import { defineConfig as defineVitestConfig } from "vitest/config";
+import { reactIconsSprite } from "react-icons-sprite/vite";
+
+const repoRoot = new URL("../..", import.meta.url).pathname;
+
+function readDotEnvKey(root: string, key: string): string | undefined {
+  try {
+    const content = readFileSync(join(root, ".env"), "utf8");
+    const line = content.split(/\r?\n/).find((row) => row.startsWith(`${key}=`));
+    const value = line?.slice(key.length + 1).trim();
+    return value || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function loadResolvedSpaEnv(cwd: string): Record<string, unknown> {
+  try {
+    const resolved = resolveConfigSync({ cwd, module: "spa", target: "resolved" });
+    if (resolved && typeof resolved === "object") {
+      return resolved as Record<string, unknown>;
+    }
+  } catch {
+    // unnamed or missing spa manifest
+  }
+  return {};
+}
+
+const env = loadResolvedSpaEnv(repoRoot);
+applyEnv(env, "__");
+
+const apiUrl =
+  getString(env, "VITE_PUBLIC_API_URL") ||
+  process.env.VITE_PUBLIC_API_URL ||
+  readDotEnvKey(repoRoot, "VITE_PUBLIC_API_URL") ||
+  "http://localhost:4000";
+
+const isInTestMode = process.env.VITEST === "true";
+const iconsSpritePlugin = reactIconsSprite();
+const iconsSpriteTransform = iconsSpritePlugin.transform;
+
+if (typeof iconsSpriteTransform === "function") {
+  iconsSpritePlugin.transform = function transformAppIcons(code, id, ...args) {
+    if (id.includes("/node_modules/")) {
+      return null;
+    }
+
+    return iconsSpriteTransform.call(this, code, id, ...args);
+  };
+}
+
+const createViteConfig = (isDevServer: boolean) => ({
+  plugins: [
+    isDevServer && reactScan(),
+    !isInTestMode &&
+      tanstackRouter({
+        target: "react",
+        autoCodeSplitting: true,
+        routesDirectory: "./src/pages",
+      }),
+    devtools({
+      eventBusConfig: { enabled: false },
+    }),
+    iconsSpritePlugin,
+    viteReact({
+      babel: {
+        plugins: ["babel-plugin-react-compiler"],
+      },
+    }),
+    tailwindCSS(),
+    !isInTestMode && devtoolsJson(),
+  ],
+  server: {
+    open: false,
+    port: getNumber(env, "VITE_DEV_PORT") ?? 3000,
+    strictPort: false,
+    proxy: {
+      "^/api(?:/|$)": {
+        target: apiUrl,
+        changeOrigin: true,
+        secure: false,
+      },
+    },
+  },
+  build: {
+    target: "esnext",
+  },
+  optimizeDeps: {
+    entries: ["src/**/*.{ts,tsx}"],
+  },
+  worker: {
+    format: "es",
+  },
+  resolve: {
+    alias: {
+      "@": new URL("src", import.meta.url).pathname,
+    },
+    dedupe: ["react", "react-dom", "i18next", "react-i18next"],
+    tsconfigPaths: true,
+  },
+});
+
+const vitestConfig = defineVitestConfig({
+  test: {
+    root: "./",
+    include: ["src/**/*.test.{ts,tsx}"],
+    watch: false,
+    globals: true,
+    reporters: ["default"],
+  },
+});
+
+export default defineViteConfig(({ command }) =>
+  mergeConfig(createViteConfig(command === "serve"), vitestConfig),
+);

package/templates/marketplace/database.ts

@@ -0,0 +1,154 @@
+import {
+  defineDatabase,
+  integer,
+  pgTable,
+  text,
+  timestamp,
+  unique,
+  uniqueIndex,
+  uuid,
+} from "@robodev-ai/sdk";
+
+export const media = pgTable("media", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  key: text("key").notNull(),
+  userId: text("userId").notNull(),
+  resourceName: text("resourceName").notNull(),
+  fileName: text("fileName").notNull(),
+  fileSize: integer("fileSize").notNull(),
+  mimeType: text("mimeType").notNull(),
+  uploaded: timestamp("uploaded", { withTimezone: true }),
+  createdAt: timestamp("createdAt", { withTimezone: true }).defaultNow(),
+});
+
+export const categories = pgTable(
+  "categories",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+  },
+  (table) => [uniqueIndex("categories_slug_idx").on(table.slug)],
+);
+
+export const listings = pgTable("listings", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  sellerId: text("sellerId").notNull(),
+  sellerName: text("sellerName"),
+  sellerEmail: text("sellerEmail").notNull(),
+  categoryId: uuid("categoryId")
+    .notNull()
+    .references(() => categories.id),
+  title: text("title").notNull(),
+  description: text("description"),
+  priceCents: integer("priceCents").notNull(),
+  quantity: integer("quantity").notNull(),
+  shippingCents: integer("shippingCents").notNull(),
+  shippingDays: integer("shippingDays").notNull(),
+  status: text("status").notNull().default("active"),
+  createdAt: timestamp("createdAt", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updatedAt", { withTimezone: true }).defaultNow(),
+});
+
+export const listingImages = pgTable("listing_images", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  listingId: uuid("listingId")
+    .notNull()
+    .references(() => listings.id, { onDelete: "cascade" }),
+  mediaId: uuid("mediaId")
+    .notNull()
+    .references(() => media.id, { onDelete: "cascade" }),
+  sortOrder: integer("sortOrder").notNull().default(0),
+});
+
+export const cartItems = pgTable(
+  "cart_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("userId").notNull(),
+    listingId: uuid("listingId")
+      .notNull()
+      .references(() => listings.id, { onDelete: "cascade" }),
+    quantity: integer("quantity").notNull(),
+  },
+  (table) => [unique("cart_items_user_listing").on(table.userId, table.listingId)],
+);
+
+export const orders = pgTable("orders", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  buyerId: text("buyerId").notNull(),
+  buyerEmail: text("buyerEmail").notNull(),
+  sellerId: text("sellerId").notNull(),
+  sellerEmail: text("sellerEmail").notNull(),
+  status: text("status").notNull(),
+  shippingName: text("shippingName").notNull(),
+  shippingLine1: text("shippingLine1").notNull(),
+  shippingLine2: text("shippingLine2"),
+  shippingCity: text("shippingCity").notNull(),
+  shippingRegion: text("shippingRegion"),
+  shippingPostal: text("shippingPostal").notNull(),
+  shippingCountry: text("shippingCountry").notNull(),
+  shippingCents: integer("shippingCents").notNull(),
+  totalCents: integer("totalCents").notNull(),
+  last4: text("last4"),
+  createdAt: timestamp("createdAt", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updatedAt", { withTimezone: true }).defaultNow(),
+});
+
+export const orderItems = pgTable("order_items", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  orderId: uuid("orderId")
+    .notNull()
+    .references(() => orders.id, { onDelete: "cascade" }),
+  listingId: uuid("listingId")
+    .notNull()
+    .references(() => listings.id),
+  title: text("title").notNull(),
+  qty: integer("qty").notNull(),
+  unitPriceCents: integer("unitPriceCents").notNull(),
+});
+
+export const watches = pgTable(
+  "watches",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("userId").notNull(),
+    listingId: uuid("listingId")
+      .notNull()
+      .references(() => listings.id, { onDelete: "cascade" }),
+  },
+  (table) => [unique("watches_user_listing").on(table.userId, table.listingId)],
+);
+
+export const reviews = pgTable(
+  "reviews",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    listingId: uuid("listingId")
+      .notNull()
+      .references(() => listings.id, { onDelete: "cascade" }),
+    orderId: uuid("orderId")
+      .notNull()
+      .references(() => orders.id, { onDelete: "cascade" }),
+    buyerId: text("buyerId").notNull(),
+    rating: integer("rating").notNull(),
+    body: text("body"),
+    createdAt: timestamp("createdAt", { withTimezone: true }).defaultNow(),
+  },
+  (table) => [unique("reviews_order_listing").on(table.orderId, table.listingId)],
+);
+
+export default defineDatabase({
+  name: "marketplace",
+  tables: {
+    media,
+    categories,
+    listings,
+    listingImages,
+    cartItems,
+    orders,
+    orderItems,
+    watches,
+    reviews,
+  },
+});