@zalify/cli 0.6.1 → 0.7.0

package/dist/cli.js

@@ -11293,7 +11293,7 @@ function updateNotifier(options) {
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "node:module";
-import { dirname, join as join4 } from "node:path";
+import { dirname, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -12056,10 +12056,260 @@ async function imagesGenerate(storeDir) {
   console.log(`Done: ${counters.produced} generated (already in the asset library), ${counters.failed} failed${counters.failed ? " — re-run to retry" : ""}.`);
 }
 
+// src/shopify.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
+import { basename, join as join4, resolve as resolve3 } from "node:path";
+function proxyError(auth, status, json) {
+  if (status === 404) {
+    return new Error("Shopify Admin proxy not found (404) — the /api/shopify/admin endpoint " + "is probably not deployed yet on this Zalify app. Try again after the next deploy.");
+  }
+  if (status === 402 || json.code === "UPGRADE_REQUIRED") {
+    return new Error(`${json.error ?? "Paid plan required."}
+  Upgrade: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/billing`);
+  }
+  if (status === 409) {
+    return new Error(`${json.error ?? "No Shopify store is connected to this workspace."}
+` + `  Connect one: ${auth.appUrl}/store/${auth.workspaceSlug}/settings/integrations`);
+  }
+  return new Error(`shopify/admin ${status}: ${JSON.stringify(json)}`);
+}
+async function gql(auth, query, variables = {}) {
+  const res = await fetch(`${auth.appUrl}/api/shopify/admin`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${auth.key}`
+    },
+    body: JSON.stringify({ workspaceId: auth.workspaceId, query, variables })
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok)
+    throw proxyError(auth, res.status, json);
+  if (json.errors)
+    throw new Error(JSON.stringify(json.errors));
+  if (!json.data)
+    throw new Error(`shopify/admin: empty response`);
+  return json.data;
+}
+function readJson(path9, label) {
+  if (!existsSync4(path9)) {
+    throw new Error(`No ${label} at ${path9}`);
+  }
+  return JSON.parse(readFileSync4(path9, "utf8"));
+}
+function joinErrors(errs) {
+  return errs.map((e) => e.message).join("; ");
+}
+var PRODUCT_SET = `
+  mutation productSet($input: ProductSetInput!) {
+    productSet(input: $input, synchronous: true) {
+      product { id handle }
+      userErrors { field message }
+    }
+  }`;
+var COLLECTION_CREATE = `
+  mutation collectionCreate($input: CollectionInput!) {
+    collectionCreate(input: $input) {
+      collection { id handle }
+      userErrors { field message }
+    }
+  }`;
+async function findProductId(auth, handle) {
+  const data = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${handle}` });
+  const node = data.products.nodes[0];
+  return node && node.handle === handle ? node.id : null;
+}
+async function shopifyImport(storeDir, options = {}) {
+  const auth = requireActive();
+  const dir2 = resolve3(storeDir);
+  const catalog = readJson(join4(dir2, "catalog.json"), "catalog.json");
+  const { locations } = await gql(auth, `{ locations(first: 1) { nodes { id name } } }`);
+  const locationId = locations.nodes[0]?.id;
+  console.log(`Importing ${catalog.products.length} product(s) into the Shopify store connected to ` + `workspace "${auth.workspaceName}" (location: ${locations.nodes[0]?.name ?? "none"})`);
+  const productIds = [];
+  for (const p of catalog.products) {
+    const options_ = p.options ?? [];
+    const optionValues = options_.map((name, idx) => ({
+      name,
+      position: idx + 1,
+      values: [...new Set(p.variants.map((v) => v.options[idx]))].map((v) => ({ name: v }))
+    }));
+    const input = {
+      handle: p.handle,
+      title: p.title,
+      descriptionHtml: p.descriptionHtml ?? "",
+      vendor: p.vendor ?? catalog.vendor,
+      productType: p.type ?? "",
+      tags: p.tags ?? [],
+      status: "ACTIVE",
+      productOptions: optionValues.length ? optionValues : [{ name: "Title", position: 1, values: [{ name: "Default Title" }] }],
+      variants: p.variants.map((v) => ({
+        optionValues: options_.length ? options_.map((name, idx) => ({ optionName: name, name: v.options[idx] })) : [{ optionName: "Title", name: "Default Title" }],
+        price: v.price,
+        compareAtPrice: v.compareAtPrice ?? null,
+        inventoryItem: {
+          sku: v.sku ?? "",
+          tracked: true,
+          measurement: { weight: { value: v.grams ?? 0, unit: "GRAMS" } }
+        },
+        inventoryQuantities: locationId ? [{ locationId, name: "available", quantity: v.inventory ?? 25 }] : []
+      }))
+    };
+    const existingId = await findProductId(auth, p.handle);
+    if (existingId)
+      input.id = existingId;
+    const data = await gql(auth, PRODUCT_SET, { input });
+    const errs = data.productSet.userErrors;
+    if (errs.length) {
+      console.error(`  ✗ ${p.handle}: ${joinErrors(errs)}`);
+    } else if (data.productSet.product) {
+      productIds.push(data.productSet.product.id);
+      console.log(`  ✓ ${existingId ? "updated" : "created"} ${p.handle} (${p.variants.length} variants)`);
+    }
+  }
+  if (options.prune) {
+    const wanted = new Set(catalog.products.map((p) => p.handle));
+    const data = await gql(auth, `query($q: String!) { products(first: 100, query: $q) { nodes { id handle } } }`, { q: `vendor:${catalog.vendor}` });
+    for (const node of data.products.nodes) {
+      if (wanted.has(node.handle))
+        continue;
+      const del = await gql(auth, `mutation($input: ProductDeleteInput!) {
+          productDelete(input: $input) { deletedProductId userErrors { field message } }
+        }`, { input: { id: node.id } });
+      const errs = del.productDelete.userErrors;
+      if (errs.length)
+        console.error(`  ✗ prune ${node.handle}: ${joinErrors(errs)}`);
+      else
+        console.log(`  ✓ pruned ${node.handle}`);
+    }
+  }
+  for (const c of catalog.collections ?? []) {
+    const existing = await gql(auth, `query($q: String!) { collections(first: 1, query: $q) { nodes { id handle } } }`, { q: `handle:${c.handle}` });
+    if (existing.collections.nodes[0]?.handle === c.handle) {
+      console.log(`  - collection ${c.handle} exists, skipped`);
+      continue;
+    }
+    const data = await gql(auth, COLLECTION_CREATE, {
+      input: {
+        handle: c.handle,
+        title: c.title,
+        descriptionHtml: c.descriptionHtml ?? "",
+        ruleSet: {
+          appliedDisjunctively: false,
+          rules: [
+            {
+              column: "TAG",
+              relation: "EQUALS",
+              condition: c.rule?.tag ?? `collection:${c.handle}`
+            }
+          ]
+        }
+      }
+    });
+    const errs = data.collectionCreate.userErrors;
+    if (errs.length)
+      console.error(`  ✗ collection ${c.handle}: ${joinErrors(errs)}`);
+    else
+      console.log(`  ✓ collection ${c.handle}`);
+  }
+  try {
+    const pubs = await gql(auth, `{ publications(first: 10) { nodes { id name } } }`);
+    const online = pubs.publications.nodes.find((n) => n.name === "Online Store");
+    if (online) {
+      for (const id of productIds) {
+        await gql(auth, `mutation($id: ID!, $input: [PublicationInput!]!) {
+            publishablePublish(id: $id, input: $input) { userErrors { field message } }
+          }`, { id, input: [{ publicationId: online.id }] });
+      }
+      console.log(`  ✓ published ${productIds.length} products to Online Store`);
+    }
+  } catch (e) {
+    console.warn(`  ! could not publish to Online Store (write_publications scope missing?): ${e instanceof Error ? e.message : String(e)}`);
+  }
+  console.log("Done.");
+}
+async function shopifyUploadImages(storeDir) {
+  const auth = requireActive();
+  const dir2 = resolve3(storeDir);
+  const manifest = readJson(join4(dir2, "images", "manifest.json"), "images/manifest.json");
+  console.log(`Uploading images to the Shopify store connected to workspace "${auth.workspaceName}"`);
+  for (const entry of manifest.images) {
+    const filePath = join4(dir2, "images", entry.file);
+    if (!existsSync4(filePath)) {
+      console.log(`  - ${entry.handle}: ${entry.file} not generated yet, skipped`);
+      continue;
+    }
+    const found = await gql(auth, `query($q: String!) { products(first: 1, query: $q) { nodes { id handle
+        media(first: 50) { nodes { alt ... on MediaImage { image { url } } } } } } }`, { q: `handle:${entry.handle}` });
+    const product = found.products.nodes[0];
+    if (!product || product.handle !== entry.handle) {
+      console.error(`  ✗ ${entry.handle}: product not found in store`);
+      continue;
+    }
+    const stem = basename(entry.file, ".png");
+    const already = product.media.nodes.some((m) => m.image?.url?.includes(stem) || entry.alt && m.alt === entry.alt);
+    if (already) {
+      console.log(`  - ${entry.file}: already attached, skipped`);
+      continue;
+    }
+    const bytes = readFileSync4(filePath);
+    const staged = await gql(auth, `mutation($input: [StagedUploadInput!]!) {
+        stagedUploadsCreate(input: $input) {
+          stagedTargets { url resourceUrl parameters { name value } }
+          userErrors { field message }
+        }
+      }`, {
+      input: [
+        {
+          resource: "IMAGE",
+          filename: basename(entry.file),
+          mimeType: "image/png",
+          httpMethod: "PUT",
+          fileSize: String(bytes.length)
+        }
+      ]
+    });
+    const target = staged.stagedUploadsCreate.stagedTargets?.[0];
+    if (!target) {
+      console.error(`  ✗ ${entry.handle}: staged upload failed: ${JSON.stringify(staged.stagedUploadsCreate.userErrors)}`);
+      continue;
+    }
+    const headers = { "Content-Type": "image/png" };
+    for (const p of target.parameters)
+      headers[p.name] = p.value;
+    const up = await fetch(target.url, {
+      method: "PUT",
+      headers,
+      body: new Uint8Array(bytes)
+    });
+    if (!up.ok) {
+      console.error(`  ✗ ${entry.handle}: upload PUT failed (${up.status})`);
+      continue;
+    }
+    const media = await gql(auth, `mutation($productId: ID!, $media: [CreateMediaInput!]!) {
+        productCreateMedia(productId: $productId, media: $media) {
+          media { alt }
+          mediaUserErrors { field message }
+        }
+      }`, {
+      productId: product.id,
+      media: [
+        { originalSource: target.resourceUrl, alt: entry.alt ?? "", mediaContentType: "IMAGE" }
+      ]
+    });
+    const errs = media.productCreateMedia.mediaUserErrors;
+    if (errs.length)
+      console.error(`  ✗ ${entry.handle}: ${joinErrors(errs)}`);
+    else
+      console.log(`  ✓ ${entry.file}`);
+  }
+  console.log("Done.");
+}
+
 // src/cli.ts
 var __dirname4 = dirname(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join4(__dirname4, "..", "package.json"));
+var pkg = require2(join5(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -12107,6 +12357,13 @@ var images = program2.command("images").description("Generate images on Zalify i
 images.command("generate <store-dir>").description("Generate missing manifest images server-side (results land in the asset library and are downloaded locally)").action(async (storeDir) => {
   await imagesGenerate(storeDir);
 });
+var shopify = program2.command("shopify").description("Push catalogs and images to the workspace's connected Shopify store");
+shopify.command("import <store-dir>").description("Import <store-dir>/catalog.json into the connected Shopify store (products, smart collections, Online Store publish; idempotent by handle)").option("--prune", "delete store products (by catalog vendor) absent from catalog.json").action(async (storeDir, options) => {
+  await shopifyImport(storeDir, options);
+});
+shopify.command("upload-images <store-dir>").description("Upload <store-dir>/images/* to matching products per images/manifest.json (skips files already attached)").action(async (storeDir) => {
+  await shopifyUploadImages(storeDir);
+});
 var assets = program2.command("assets").description("Sync images with the Zalify asset library");
 assets.command("push <store-dir>").description("Upload <store-dir>/images/*.png (sha256 dedup, writes assets.json)").action(async (storeDir) => {
   await assetsPush(storeDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalify/cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",