Initial commit

app/api/submit/project/route.ts

@@ -0,0 +1,158 @@
+// app/api/submit/project/route.ts
+import { NextRequest, NextResponse } from "next/server";
+import {
+  uploadFile,
+  createProjectRow,
+  patchProject,
+  bytesFromMB,
+} from "@/lib/directus";
+
+// Optional: tweak via env
+const MAX_MB = Number(process.env.FILE_MAX_MB || 25);
+const MAX_BYTES = bytesFromMB(MAX_MB);
+
+// ultra-simple in-memory rate limiter (per server instance)
+const BUCKET = new Map<string, { c: number; resetAt: number }>();
+const WINDOW_MS = Number(process.env.RATE_LIMIT_WINDOW || 60) * 1000;
+const MAX_REQ = Number(process.env.RATE_LIMIT_MAX || 15);
+
+function rateLimitOk(ip: string) {
+  const now = Date.now();
+  const rec = BUCKET.get(ip);
+  if (!rec || now > rec.resetAt) {
+    BUCKET.set(ip, { c: 1, resetAt: now + WINDOW_MS });
+    return true;
+  }
+  if (rec.c >= MAX_REQ) return false;
+  rec.c += 1;
+  return true;
+}
+
+export const runtime = "nodejs";
+
+export async function POST(req: NextRequest) {
+  try {
+    const ip =
+      req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+      "0.0.0.0";
+    if (!rateLimitOk(ip)) {
+      return NextResponse.json({ error: "Rate limited" }, { status: 429 });
+    }
+
+    const ct = req.headers.get("content-type") || "";
+    if (!ct.includes("multipart/form-data")) {
+      return NextResponse.json(
+        { error: "Expected multipart/form-data" },
+        { status: 400 }
+      );
+    }
+
+    const form = await req.formData();
+
+    // Required read-side field names from your repo:
+    // title, body (markdown), uploader, category, tags[], p_image (file), p_files (M2M to files)
+    const title = String(form.get("title") || "").trim();
+    const uploader = String(form.get("uploader") || "").trim();
+    const category = String(form.get("category") || "").trim();
+    const body = String(form.get("body") || form.get("description") || "").trim();
+
+    if (!title || !uploader || !body) {
+      return NextResponse.json(
+        { error: "Missing required fields: title, uploader, body" },
+        { status: 400 }
+      );
+    }
+
+    // tags: allow comma-separated string or JSON array
+    let tags: string[] = [];
+    const rawTags = form.get("tags");
+    if (typeof rawTags === "string" && rawTags.trim()) {
+      try {
+        // Accept JSON array
+        const maybeArray = JSON.parse(rawTags);
+        if (Array.isArray(maybeArray)) {
+          tags = maybeArray.map((t) => String(t).trim()).filter(Boolean);
+        } else {
+          // Fallback: comma list
+          tags = rawTags
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+        }
+      } catch {
+        // Comma-separated
+        tags = rawTags
+          .split(",")
+          .map((t) => t.trim())
+          .filter(Boolean);
+      }
+    }
+
+    // Optional license (not shown on read pages, but harmless to store)
+    const license =
+      (form.get("license") && String(form.get("license")).trim()) ||
+      undefined;
+
+    // Upload hero image (single)
+    const hero = form.get("image") as File | null; // input name="image"
+    let p_image_id: string | undefined;
+    if (hero && typeof hero === "object" && "size" in hero) {
+      if (hero.size > MAX_BYTES) {
+        return NextResponse.json(
+          { error: `Hero image exceeds ${MAX_MB} MB` },
+          { status: 400 }
+        );
+      }
+      const up = await uploadFile(hero, (hero as File).name || "project-image");
+      p_image_id = up.id;
+    }
+
+    // Upload attachments (multiple)
+    const fileBlobs = form.getAll("files").filter(Boolean) as File[];
+    const attachIds: string[] = [];
+    for (const f of fileBlobs.slice(0, 20)) {
+      if (f.size > MAX_BYTES) {
+        return NextResponse.json(
+          { error: `One of the files exceeds ${MAX_MB} MB` },
+          { status: 400 }
+        );
+      }
+      const up = await uploadFile(f, (f as File).name || "attachment");
+      attachIds.push(up.id);
+    }
+
+    // 1) Create the project row
+    const { data: created } = await createProjectRow({
+      title,
+      body,                 // you render `project.body` in detail page
+      uploader,             // exact key used by your list/detail
+      category,
+      tags,                 // stored as array
+      ...(license ? { license } : {}),
+      status: "pending",
+      submitted_via: "makearmy-app",
+      submitted_at: new Date().toISOString(),
+    });
+
+    // 2) Patch hero image + M2M attachments in one go
+    // For M2M (p_files), Directus accepts nested objects to create junction rows
+    // e.g. [{ directus_files_id: "<file-id>" }, ...]
+    const patch: Record<string, any> = {};
+    if (p_image_id) patch.p_image = p_image_id;
+    if (attachIds.length) {
+      patch.p_files = attachIds.map((id) => ({ directus_files_id: id }));
+    }
+
+    if (Object.keys(patch).length) {
+      await patchProject(created.id, patch);
+    }
+
+    return NextResponse.json({ ok: true, id: created.id });
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: err?.message || "Unknown error" },
+      { status: 500 }
+    );
+  }
+}
+

app/api/submit/settings/route.ts

@@ -0,0 +1,391 @@
+// app/api/submit/settings/route.ts
+import { NextRequest, NextResponse } from "next/server";
+import {
+  bytesFromMB,
+  createSettingsItem,
+  directusFetch,
+  uploadFile,
+} from "@/lib/directus";
+
+/** ─────────────────────────────────────────────────────────────
+ * Accepts EITHER:
+ *  - application/json  (photo/screen can be data URLs: photo_data, screen_data)
+ *  - multipart/form-data with:
+ *      - "payload"  = JSON string (same shape as JSON body)
+ *      - "photo"    = result image (REQUIRED)
+ *      - "screen"   = screenshot image (optional)
+ *
+ * Targets (collections):
+ *  - settings_fiber   (+ laser_soft, repeat_all)
+ *  - settings_co2gan
+ *  - settings_co2gal
+ *  - settings_uv
+ * ──────────────────────────────────────────────────────────── */
+
+export const runtime = "nodejs";
+
+const MAX_MB = Number(process.env.FILE_MAX_MB || 25);
+const MAX_BYTES = bytesFromMB(MAX_MB);
+
+// light in-memory rate limiter
+const BUCKET = new Map<string, { c: number; resetAt: number }>();
+const WINDOW_MS = Number(process.env.RATE_LIMIT_WINDOW || 60) * 1000;
+const MAX_REQ = Number(process.env.RATE_LIMIT_MAX || 15);
+function rateLimitOk(ip: string) {
+  const now = Date.now();
+  const rec = BUCKET.get(ip);
+  if (!rec || now > rec.resetAt) {
+    BUCKET.set(ip, { c: 1, resetAt: now + WINDOW_MS });
+    return true;
+  }
+  if (rec.c >= MAX_REQ) return false;
+  rec.c += 1;
+  return true;
+}
+
+type Target = "settings_fiber" | "settings_co2gan" | "settings_co2gal" | "settings_uv";
+
+/** Map target + kind → Directus folder name */
+function folderName(target: Target, kind: "photo" | "screen") {
+  const base =
+    target === "settings_fiber"
+      ? "le_fiber_settings"
+      : target === "settings_uv"
+      ? "le_uv_settings"
+      : target === "settings_co2gal"
+      ? "le_co2gal_settings"
+      : "le_co2gan_settings";
+  return kind === "photo" ? `${base}_photos` : `${base}_screenshots`;
+}
+
+/** Lookup a folder id by name, returns null if not found */
+async function findFolderIdByName(name: string): Promise<string | null> {
+  try {
+    const res = await directusFetch<{ data: Array<{ id: string }> }>(
+      `/folders?limit=1&fields=id&filter[name][_eq]=${encodeURIComponent(name)}`
+    );
+    const id = res?.data?.[0]?.id ?? null;
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Patch a file to move it into a folder (no-op if folderId is null) */
+async function moveFileToFolder(fileId: string, folderId: string | null) {
+  if (!fileId || !folderId) return;
+  await directusFetch(`/files/${fileId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ folder: folderId }),
+  });
+}
+
+// Whitelists for repeaters (matches your Directus repeater schemas)
+const FILL_KEYS = new Set([
+  "name",
+  "power",
+  "speed",
+  "interval",
+  "pass",
+  "type",
+  "flood",
+  "air",
+  "frequency",
+  "pulse",
+  "angle",
+  "auto",
+  "increment",
+  "cross",
+]);
+const LINE_KEYS = new Set([
+  "name",
+  "power",
+  "speed",
+  "perf",
+  "cut",
+  "skip",
+  "pass",
+  "air",
+  "frequency",
+  "pulse",
+  "wobble",
+  "step",
+  "size",
+]);
+const RASTER_KEYS = new Set([
+  "name",
+  "power",
+  "speed",
+  "type",
+  "dither",
+  "halftone_cell",
+  "halftone_angle",
+  "inversion",
+  "interval",
+  "dot",
+  "pass",
+  "air",
+  "frequency",
+  "pulse",
+  "cross",
+]);
+
+function sanitizeNumber(n: any, fallback: number | null = null) {
+  if (n === null || n === undefined || n === "") return fallback;
+  const v = Number(n);
+  return Number.isFinite(v) ? v : fallback;
+}
+
+function sanitizeRepeaterRow(
+  row: Record<string, any>,
+  allowed: Set<string>
+): Record<string, any> {
+  const out: Record<string, any> = {};
+  for (const k of Object.keys(row || {})) {
+    if (!allowed.has(k)) continue;
+    if (
+      [
+        "power",
+        "speed",
+        "interval",
+        "pass",
+        "halftone_cell",
+        "halftone_angle",
+        "dot",
+        "frequency",
+        "pulse",
+        "angle",
+        "increment",
+        "step",
+        "size",
+      ].includes(k)
+    ) {
+      out[k] = sanitizeNumber(row[k]);
+    } else if (["auto", "cross", "wobble", "perf", "air", "flood", "inversion"].includes(k)) {
+      out[k] = !!row[k];
+    } else {
+      out[k] = row[k];
+    }
+  }
+  return out;
+}
+
+async function readJsonOrMultipart(req: NextRequest) {
+  const ct = req.headers.get("content-type") || "";
+
+  if (ct.includes("multipart/form-data")) {
+    const form = await req.formData();
+    const payloadRaw = String(form.get("payload") || "{}");
+    let body: any = {};
+    try {
+      body = JSON.parse(payloadRaw);
+    } catch {
+      throw new Error("Invalid JSON in 'payload' field");
+    }
+    const files = {
+      photo: (form.get("photo") as File) || null,
+      screen: (form.get("screen") as File) || null,
+    };
+    return { mode: "multipart" as const, body, files };
+  }
+
+  if (ct.includes("application/json")) {
+    const body = await req.json();
+    return { mode: "json" as const, body, files: { photo: null as File | null, screen: null as File | null } };
+  }
+
+  throw new Error("Unsupported content-type. Use JSON or multipart/form-data.");
+}
+
+export async function POST(req: NextRequest) {
+  const started = Date.now();
+  try {
+    const ip =
+      req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+      "0.0.0.0";
+    if (!rateLimitOk(ip)) {
+      return NextResponse.json({ error: "Rate limited" }, { status: 429 });
+    }
+
+    const { mode, body, files } = await readJsonOrMultipart(req);
+
+    const target: Target = body?.target;
+    if (!["settings_fiber", "settings_co2gan", "settings_co2gal", "settings_uv"].includes(target as any)) {
+      return NextResponse.json({ error: "Invalid target" }, { status: 400 });
+    }
+
+    // Required base fields
+    const setting_title = String(body?.setting_title || body?.title || "").trim();
+    const uploader = String(body?.uploader || "").trim();
+
+    // Relations (required)
+    const mat         = body?.mat ?? null;
+    const mat_coat    = body?.mat_coat ?? null;
+    const mat_color   = body?.mat_color ?? null;
+    const mat_opacity = body?.mat_opacity ?? null;
+    const source      = body?.source ?? null;
+    const lens        = body?.lens ?? null;
+
+    // Numbers
+    const mat_thickness = sanitizeNumber(body?.mat_thickness, null);
+    const focus         = sanitizeNumber(body?.focus, null);
+
+    // Notes (optional)
+    const setting_notes = String(body?.setting_notes || body?.notes || "").trim() || "";
+
+    // Fiber-only (required)
+    const laser_soft =
+      target === "settings_fiber" ? (body?.laser_soft ?? null) : null;
+    const repeat_all =
+      target === "settings_fiber" ? sanitizeNumber(body?.repeat_all, null) : null;
+
+    // Validate requireds
+    const missing: string[] = [];
+    if (!setting_title) missing.push("setting_title");
+    if (!uploader) missing.push("uploader");
+    if (!source) missing.push("source");
+    if (!lens) missing.push("lens");
+    if (focus === null || !Number.isFinite(focus)) missing.push("focus");
+    if (!mat) missing.push("mat");
+    if (!mat_coat) missing.push("mat_coat");
+    if (!mat_color) missing.push("mat_color");
+    if (!mat_opacity) missing.push("mat_opacity");
+    if (target === "settings_fiber") {
+      if (!laser_soft) missing.push("laser_soft");
+      if (repeat_all === null || !Number.isFinite(repeat_all)) missing.push("repeat_all");
+    }
+
+    // Handle files (photo required)
+    let photo_id: string | null = null;
+    let screen_id: string | null = null;
+
+    // If multipart, use file objects. Else allow base64 in JSON: photo_data/screen_data
+    if (mode === "multipart") {
+      if (!files.photo) missing.push("photo");
+      if (files.photo) {
+        if (files.photo.size > MAX_BYTES) {
+          return NextResponse.json(
+            { error: `Photo exceeds ${MAX_MB} MB` },
+            { status: 400 }
+          );
+        }
+        const up = await uploadFile(files.photo, (files.photo as File).name || "photo");
+        photo_id = (up as any)?.id ?? null;
+
+        // after upload, move into appropriate folder
+        const folder = await findFolderIdByName(folderName(target, "photo"));
+        await moveFileToFolder(String(photo_id), folder);
+      }
+      if (files.screen) {
+        if (files.screen.size > MAX_BYTES) {
+          return NextResponse.json(
+            { error: `Screenshot exceeds ${MAX_MB} MB` },
+            { status: 400 }
+          );
+        }
+        const up = await uploadFile(files.screen, (files.screen as File).name || "screen");
+        screen_id = (up as any)?.id ?? null;
+        const folder = await findFolderIdByName(folderName(target, "screen"));
+        await moveFileToFolder(String(screen_id), folder);
+      }
+    } else {
+      // JSON mode with optional base64 strings
+      const pushBase64 = async (dataUrl: string, name: string) => {
+        const base64 = (dataUrl || "").split(",")[1] || "";
+        if (!base64) return null;
+        const raw = Buffer.from(base64, "base64");
+        if (raw.byteLength > MAX_BYTES) throw new Error(`${name} exceeds ${MAX_MB} MB`);
+        const blob = new Blob([raw]);
+        const up = await uploadFile(blob as any, name);
+        return (up as any)?.id ?? null;
+      };
+
+      if (body?.photo_data) {
+        photo_id = await pushBase64(body.photo_data, "photo");
+        const folder = await findFolderIdByName(folderName(target, "photo"));
+        await moveFileToFolder(String(photo_id), folder);
+      } else {
+        missing.push("photo");
+      }
+      if (body?.screen_data) {
+        screen_id = await pushBase64(body.screen_data, "screen");
+        const folder = await findFolderIdByName(folderName(target, "screen"));
+        await moveFileToFolder(String(screen_id), folder);
+      }
+    }
+
+    if (missing.length) {
+      return NextResponse.json(
+        { error: `Missing required: ${missing.join(", ")}` },
+        { status: 400 }
+      );
+    }
+
+    // Repeaters
+    const fillsRaw   = Array.isArray(body?.fill_settings)   ? body.fill_settings   : body?.fills   || [];
+    const linesRaw   = Array.isArray(body?.line_settings)   ? body.line_settings   : body?.lines   || [];
+    const rastersRaw = Array.isArray(body?.raster_settings) ? body.raster_settings : body?.rasters || [];
+
+    const fill_settings   = (fillsRaw as any[]).map((r) => sanitizeRepeaterRow(r, FILL_KEYS));
+    const line_settings   = (linesRaw as any[]).map((r) => sanitizeRepeaterRow(r, LINE_KEYS));
+    const raster_settings = (rastersRaw as any[]).map((r) => sanitizeRepeaterRow(r, RASTER_KEYS));
+
+    // Build record
+    const nowIso = new Date().toISOString();
+    const payload: Record<string, any> = {
+      setting_title,
+      uploader,
+      setting_notes,
+      // relations
+      mat,
+      mat_coat,
+      mat_color,
+      mat_opacity,
+      source,
+      lens,
+      // numbers
+      focus,
+      mat_thickness,
+      // files
+      photo: photo_id,
+      screen: screen_id,
+      // repeaters
+      fill_settings,
+      line_settings,
+      raster_settings,
+      // meta
+      submission_date: nowIso,
+      last_modified_date: nowIso,
+      status: "pending",
+      submitted_via: "makearmy-app",
+      submitted_at: nowIso,
+    };
+
+    if (target === "settings_fiber") {
+      payload.laser_soft = laser_soft;
+      payload.repeat_all = repeat_all;
+    }
+
+    const created = await createSettingsItem(target, payload);
+
+    // normalize PK to always provide "id" (your tables use submission_id)
+    const newId =
+      (created as any)?.submission_id ??
+      (created as any)?.data?.submission_id ??
+      (created as any)?.id ??
+      (created as any)?.data?.id ??
+      null;
+
+    return NextResponse.json({
+      ok: true,
+      id: newId,
+      submission_id: newId,
+      took_ms: Date.now() - started,
+    });
+  } catch (err: any) {
+    const msg = err?.message || "Unknown error";
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}
+