feat: vendors seeding script

scripts/seed-strapi-categories.mjs

@@ -18,6 +18,7 @@ const token =
   process.env.STRAPI_TOKEN ??
   process.env.STRAPI_API_TOKEN ??
   process.env.AUTH_TOKEN;
+const isDryRun = process.argv.includes("--dry-run");
 
 function readCategorySource(slug) {
   const filePath = path.join(categoriesDir, `${slug}.json`);
@@ -113,7 +114,7 @@ async function createCategory(input) {
   return data?.createCategory;
 }
 
-async function seedCategories(slugs) {
+async function seedCategories(slugs, dryRun = false) {
   let createdCount = 0;
   let skippedCount = 0;
 
@@ -133,24 +134,22 @@ async function seedCategories(slugs) {
       continue;
     }
 
-    const created = await createCategory({
-      slug,
-      title,
-      description,
-      group,
-    });
+    if (dryRun) {
+      createdCount += 1;
+      console.log(`DRY-RUN CREATE ${slug} -> ${title} [group=${group}]`);
+      continue;
+    }
 
+    const created = await createCategory({ slug, title, description, group });
     createdCount += 1;
-    console.log(
-      `CREATE ${created.slug} -> ${created.title} [group=${created.group}]`
-    );
+    console.log(`CREATE ${created.slug} -> ${created.title} [group=${created.group}]`);
   }
 
   return { createdCount, skippedCount };
 }
 
 async function main() {
-  console.log(`Seeding categories to ${endpoint}`);
+  console.log(`Seeding categories to ${endpoint}${isDryRun ? " (dry-run)" : ""}`);
   if (!token) {
     console.warn(
       "No STRAPI token provided. If endpoint is protected, set STRAPI_TOKEN."
@@ -158,7 +157,7 @@ async function main() {
   }
 
   const slugs = discoverCategorySlugs();
-  const { createdCount, skippedCount } = await seedCategories(slugs);
+  const { createdCount, skippedCount } = await seedCategories(slugs, isDryRun);
 
   console.log(
     `Done. created=${createdCount}, skipped=${skippedCount}, total=${createdCount + skippedCount}`

scripts/seed-strapi-vendors.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
+const categoriesDir = path.join(root, "src", "content", "categories");
+
+const defaultEndpoint = "http://localhost:1337/graphql";
+const endpoint =
+  process.env.STRAPI_GRAPHQL_URL ??
+  process.env.PUBLIC_GRAPHQL_URL ??
+  defaultEndpoint;
+
+const token =
+  process.env.STRAPI_TOKEN ??
+  process.env.STRAPI_API_TOKEN ??
+  process.env.AUTH_TOKEN;
+const isDryRun = process.argv.includes("--dry-run");
+
+function readCategorySource(slug) {
+  const filePath = path.join(categoriesDir, `${slug}.json`);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Missing source file: ${path.relative(root, filePath)}`);
+  }
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function discoverCategorySlugs() {
+  if (!fs.existsSync(categoriesDir)) {
+    throw new Error(`Categories directory missing: ${path.relative(root, categoriesDir)}`);
+  }
+
+  const slugs = [];
+  for (const dirent of fs.readdirSync(categoriesDir, { withFileTypes: true })) {
+    if (!dirent.isFile() || !dirent.name.endsWith(".json")) continue;
+    slugs.push(path.basename(dirent.name, ".json"));
+  }
+
+  if (slugs.length === 0) {
+    throw new Error(`No *.json categories in ${path.relative(root, categoriesDir)}`);
+  }
+
+  return slugs;
+}
+
+function normalizeProducts(products) {
+  if (!Array.isArray(products)) return [];
+  const unique = new Set();
+  for (const product of products) {
+    if (typeof product !== "string") continue;
+    const trimmed = product.trim();
+    if (!trimmed) continue;
+    unique.add(trimmed);
+  }
+  return [...unique].map((value) => ({ value }));
+}
+
+function collectVendorsBySlug(categorySlugs) {
+  const vendors = new Map();
+
+  for (const categorySlug of categorySlugs) {
+    const source = readCategorySource(categorySlug);
+    const categoryVendors = Array.isArray(source.vendors) ? source.vendors : [];
+
+    for (const rawVendor of categoryVendors) {
+      const name = typeof rawVendor?.name === "string" ? rawVendor.name.trim() : "";
+      if (!name) continue;
+
+      const vendorSlug = typeof rawVendor?.slug === "string" ? rawVendor.slug.trim() : "";
+      if (!vendorSlug) {
+        throw new Error(`Missing vendor slug for "${name}" in ${categorySlug}.json`);
+      }
+
+      const description =
+        typeof rawVendor?.description === "string" ? rawVendor.description.trim() : "";
+      const products = normalizeProducts(rawVendor?.products);
+
+      if (!vendors.has(vendorSlug)) {
+        vendors.set(vendorSlug, {
+          slug: vendorSlug,
+          title: name,
+          description,
+          products: new Map(products.map((item) => [item.value, item])),
+          categories: new Set([categorySlug]),
+        });
+        continue;
+      }
+
+      const existing = vendors.get(vendorSlug);
+      existing.categories.add(categorySlug);
+      for (const product of products) {
+        existing.products.set(product.value, product);
+      }
+      if (!existing.description && description) {
+        existing.description = description;
+      }
+    }
+  }
+
+  return [...vendors.values()].map((vendor) => ({
+    slug: vendor.slug,
+    title: vendor.title,
+    description: vendor.description,
+    products: [...vendor.products.values()],
+    categorySlugs: [...vendor.categories],
+  }));
+}
+
+async function gql(query, variables = {}) {
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/graphql-response+json, application/json",
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query, variables }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`GraphQL HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    const messages = payload.errors.map((err) => err.message).join("; ");
+    throw new Error(`GraphQL error: ${messages}`);
+  }
+
+  return payload.data;
+}
+
+async function fetchCategoryDocumentIds() {
+  const query = `
+    query CategoryIds {
+      categories(pagination: { limit: 500 }) {
+        documentId
+        slug
+      }
+    }
+  `;
+
+  const data = await gql(query);
+  const map = new Map();
+  for (const category of data?.categories ?? []) {
+    if (!category?.slug || !category?.documentId) continue;
+    map.set(category.slug, category.documentId);
+  }
+  return map;
+}
+
+async function findVendorBySlug(slug) {
+  const query = `
+    query VendorBySlug($slug: String!) {
+      vendors(filters: { slug: { eq: $slug } }, pagination: { limit: 1 }) {
+        documentId
+        slug
+      }
+    }
+  `;
+
+  const data = await gql(query, { slug });
+  return data?.vendors?.[0] ?? null;
+}
+
+async function createVendor(input) {
+  const mutation = `
+    mutation CreateVendor($data: VendorInput!) {
+      createVendor(data: $data) {
+        documentId
+        slug
+        title
+      }
+    }
+  `;
+
+  const data = await gql(mutation, { data: input });
+  return data?.createVendor;
+}
+
+async function updateVendor(documentId, input) {
+  const mutation = `
+    mutation UpdateVendor($documentId: ID!, $data: VendorInput!) {
+      updateVendor(documentId: $documentId, data: $data) {
+        documentId
+        slug
+        title
+      }
+    }
+  `;
+
+  const data = await gql(mutation, { documentId, data: input });
+  return data?.updateVendor;
+}
+
+async function seedVendors(vendors, categoryIdBySlug, dryRun = false) {
+  let createdCount = 0;
+  let updatedCount = 0;
+
+  for (const vendor of vendors) {
+    const categoryDocumentIds = vendor.categorySlugs.map((slug) => {
+      const docId = categoryIdBySlug.get(slug);
+      if (!docId) {
+        throw new Error(
+          `Category "${slug}" is missing in Strapi. Seed categories before seeding vendors.`
+        );
+      }
+      return docId;
+    });
+
+    const input = {
+      slug: vendor.slug,
+      title: vendor.title,
+      description: vendor.description,
+      products: vendor.products,
+      categories: categoryDocumentIds,
+    };
+
+    const existing = await findVendorBySlug(vendor.slug);
+    if (existing?.documentId) {
+      if (dryRun) {
+        updatedCount += 1;
+        console.log(`DRY-RUN UPDATE ${vendor.slug} -> ${vendor.title}`);
+        continue;
+      }
+
+      const updated = await updateVendor(existing.documentId, input);
+      updatedCount += 1;
+      console.log(`UPDATE ${updated.slug} -> ${updated.title}`);
+      continue;
+    }
+
+    if (dryRun) {
+      createdCount += 1;
+      console.log(`DRY-RUN CREATE ${vendor.slug} -> ${vendor.title}`);
+      continue;
+    }
+
+    const created = await createVendor(input);
+    createdCount += 1;
+    console.log(`CREATE ${created.slug} -> ${created.title}`);
+  }
+
+  return { createdCount, updatedCount };
+}
+
+async function main() {
+  console.log(`Seeding vendors to ${endpoint}${isDryRun ? " (dry-run)" : ""}`);
+  if (!token) {
+    console.warn("No STRAPI token provided. If endpoint is protected, set STRAPI_TOKEN.");
+  }
+
+  const categorySlugs = discoverCategorySlugs();
+  const vendors = collectVendorsBySlug(categorySlugs);
+  const categoryIdBySlug = await fetchCategoryDocumentIds();
+  const { createdCount, updatedCount } = await seedVendors(vendors, categoryIdBySlug, isDryRun);
+
+  console.log(`Done. created=${createdCount}, updated=${updatedCount}, total=${vendors.length}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});