@fmaplabs/meta-manifest 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -415,6 +415,17 @@ var MetaobjectRefField = class extends GidField {
     return [{ name: "metaobject_definition_type", value: resolveType(this.target) }];
   }
 };
+var MixedRefField = class extends GidField {
+  constructor(targets, opts) {
+    super(opts);
+    this.targets = targets;
+  }
+  targets;
+  shopifyType = "mixed_reference";
+  validations() {
+    return [{ name: "metaobject_definition_types", value: JSON.stringify(this.targets.map(resolveType)) }];
+  }
+};
 function product(opts = {}) {
   return new SimpleRefField(opts, "product_reference");
 }
@@ -433,6 +444,9 @@ function file(opts = {}) {
 function ref(target, opts = {}) {
   return new MetaobjectRefField(target, opts);
 }
+function mixedRef(targets, opts = {}) {
+  return new MixedRefField(targets, opts);
+}
 
 // src/fields/scalar.ts
 var StringScalarField = class extends Field {
@@ -581,6 +595,7 @@ var m = {
   page,
   file,
   ref,
+  mixedRef,
   list
 };
 
@@ -759,6 +774,27 @@ function refTarget(field) {
   }
   return void 0;
 }
+function refTargets(field) {
+  const many = v(field.validations, "metaobject_definition_types");
+  if (many) {
+    try {
+      const arr = JSON.parse(many);
+      if (Array.isArray(arr)) return arr.map(String);
+    } catch {
+    }
+  }
+  const single = v(field.validations, "metaobject_definition_type");
+  return single ? [single] : [];
+}
+function mixedTargetsLiteral(field, typeToIdent, warnings) {
+  const targets = refTargets(field);
+  const idents = targets.map((t) => typeToIdent.get(t));
+  if (!targets.length || idents.some((i) => !i)) {
+    warnings.push(`unresolved mixed reference on field "${field.key}"`);
+    return void 0;
+  }
+  return `[${idents.map((i) => `() => ${i}`).join(", ")}]`;
+}
 function optsLiteral(entries) {
   return entries.length ? `{ ${entries.join(", ")} }` : "";
 }
@@ -825,6 +861,15 @@ function fieldCall(field, typeToIdent, warnings) {
     const opts = optsLiteral(refEntries);
     return opts ? `m.ref(() => ${ident}, ${opts})` : `m.ref(() => ${ident})`;
   }
+  if (type === "mixed_reference") {
+    const arr = mixedTargetsLiteral(field, typeToIdent, warnings);
+    if (!arr) return `m.json() /* TODO: unmapped mixed reference */`;
+    const refEntries = [];
+    if (field.required) refEntries.push("required: true");
+    refEntries.push(...filterableEntry(field));
+    const opts = optsLiteral(refEntries);
+    return opts ? `m.mixedRef(${arr}, ${opts})` : `m.mixedRef(${arr})`;
+  }
   if (type.startsWith("list.")) {
     const inner = type.slice("list.".length);
     const listEntries = [];
@@ -844,6 +889,10 @@ function fieldCall(field, typeToIdent, warnings) {
         return `m.json() /* TODO: unmapped list reference */`;
       }
       innerCall = `m.ref(() => ${ident})`;
+    } else if (inner === "mixed_reference") {
+      const arr = mixedTargetsLiteral(field, typeToIdent, warnings);
+      if (!arr) return `m.json() /* TODO: unmapped list mixed reference */`;
+      innerCall = `m.mixedRef(${arr})`;
     } else if (SIMPLE[inner]) {
       innerCall = scalarCall(SIMPLE[inner], { ...field, required: false }, warnings);
     } else {
@@ -910,6 +959,8 @@ function referencedTypes(def) {
     if (f.type === "metaobject_reference" || f.type === "list.metaobject_reference") {
       const t = refTarget(f);
       if (t) out.add(t);
+    } else if (f.type === "mixed_reference" || f.type === "list.mixed_reference") {
+      for (const t of refTargets(f)) out.add(t);
     }
   }
   return out;
@@ -1330,25 +1381,35 @@ function definitionUpdateFor(def, changes) {
 function fieldInputFor(defByType, type, key) {
   return defByType.get(type)?.fieldDefinitions.find((f) => f.key === key);
 }
-function referenceEdges(def) {
+function fieldRefTargets(field) {
   const out = [];
-  for (const field of def.fieldDefinitions) {
-    for (const v2 of field.validations) {
-      if (v2.name === "metaobject_definition_type") {
-        out.push(v2.value);
-      } else if (v2.name === "metaobject_definition_types") {
-        try {
-          const parsed = JSON.parse(v2.value);
-          if (Array.isArray(parsed)) {
-            for (const t of parsed) if (typeof t === "string") out.push(t);
-          }
-        } catch {
+  for (const v2 of field.validations) {
+    if (v2.name === "metaobject_definition_type") {
+      out.push(v2.value);
+    } else if (v2.name === "metaobject_definition_types") {
+      try {
+        const parsed = JSON.parse(v2.value);
+        if (Array.isArray(parsed)) {
+          for (const t of parsed) if (typeof t === "string") out.push(t);
         }
+      } catch {
       }
     }
   }
   return out;
 }
+function referenceEdges(def) {
+  return def.fieldDefinitions.flatMap(fieldRefTargets);
+}
+function splitCyclicFields(def, cyclicTypes) {
+  const pass1 = [];
+  const deferred = [];
+  for (const f of def.fieldDefinitions) {
+    const breaksCycle = fieldRefTargets(f).some((t) => cyclicTypes.has(t) && t !== def.type);
+    (breaksCycle ? deferred : pass1).push(f);
+  }
+  return { pass1, deferred };
+}
 function topoSortCreates(types, deps) {
   const remaining = /* @__PURE__ */ new Map();
   const dependents = /* @__PURE__ */ new Map();
@@ -1391,42 +1452,35 @@ async function push(client, plan, sources, options) {
     deps.set(op.type, new Set(targets.filter((t) => createTypes.has(t) && t !== op.type)));
   }
   const { ordered, unordered } = topoSortCreates(createTypes, deps);
-  const orderedSet = new Set(ordered);
   const cyclicTypes = new Set(unordered);
   const createByType = new Map(createOps.map((x) => [x.op.type, x]));
-  const execOrder = [
-    ...ordered.map((t) => createByType.get(t)),
-    ...createOps.filter((x) => !orderedSet.has(x.op.type)),
-    ...otherOps
-  ];
   const failedTypes = /* @__PURE__ */ new Set();
-  async function applyOp(op) {
-    if (op.kind === "createDefinition") {
-      if (cyclicTypes.has(op.type)) {
-        failedTypes.add(op.type);
-        return { op, status: "blocked", reason: "reference cycle \u2014 two-pass create deferred" };
-      }
-      for (const dep of deps.get(op.type) ?? []) {
-        if (failedTypes.has(dep)) {
-          failedTypes.add(op.type);
-          return { op, status: "blocked", reason: `blocked: dependency "${dep}" was not created` };
-        }
-      }
-      const def = defByType.get(op.type);
-      if (!def) {
-        failedTypes.add(op.type);
-        return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
-      }
-      const data2 = await execute(client, CREATE_DEFINITION_MUTATION, { definition: def });
-      const payload2 = data2.metaobjectDefinitionCreate;
-      if (payload2.userErrors.length) {
+  async function createDefinition(op, definition) {
+    const data = await execute(client, CREATE_DEFINITION_MUTATION, { definition });
+    const payload = data.metaobjectDefinitionCreate;
+    if (payload.userErrors.length) {
+      failedTypes.add(op.type);
+      return { op, status: "failed", userErrors: payload.userErrors };
+    }
+    const id = payload.metaobjectDefinition?.id;
+    if (id) idByType.set(op.type, id);
+    return { op, status: "applied", id };
+  }
+  async function applyAcyclicCreate(op) {
+    for (const dep of deps.get(op.type) ?? []) {
+      if (failedTypes.has(dep)) {
         failedTypes.add(op.type);
-        return { op, status: "failed", userErrors: payload2.userErrors };
+        return { op, status: "blocked", reason: `blocked: dependency "${dep}" was not created` };
       }
-      const id2 = payload2.metaobjectDefinition?.id;
-      if (id2) idByType.set(op.type, id2);
-      return { op, status: "applied", id: id2 };
     }
+    const def = defByType.get(op.type);
+    if (!def) {
+      failedTypes.add(op.type);
+      return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+    }
+    return createDefinition(op, def);
+  }
+  async function applyFieldOp(op) {
     const destructive = "destructive" in op && op.destructive === true;
     if (destructive && !allowDestructive) return { op, status: "skipped", reason: "destructive" };
     if (failedTypes.has(op.type)) return { op, status: "blocked", reason: `blocked: definition "${op.type}" was not created` };
@@ -1479,7 +1533,53 @@ async function push(client, plan, sources, options) {
     }
   }
   const results = new Array(plan.length);
-  for (const { op, index } of execOrder) results[index] = await applyOp(op);
+  for (const type of ordered) {
+    const entry = createByType.get(type);
+    results[entry.index] = await applyAcyclicCreate(entry.op);
+  }
+  const cyclicCreates = createOps.filter((x) => cyclicTypes.has(x.op.type));
+  const deferredByType = /* @__PURE__ */ new Map();
+  for (const { op, index } of cyclicCreates) {
+    const def = defByType.get(op.type);
+    if (!def) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      continue;
+    }
+    const failedDep = [...deps.get(op.type) ?? []].find((d) => !cyclicTypes.has(d) && failedTypes.has(d));
+    if (failedDep) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `blocked: dependency "${failedDep}" was not created` };
+      continue;
+    }
+    const { pass1, deferred } = splitCyclicFields(def, cyclicTypes);
+    deferredByType.set(op.type, deferred);
+    results[index] = await createDefinition(op, { ...def, fieldDefinitions: pass1 });
+  }
+  for (const { op, index } of cyclicCreates) {
+    if (results[index]?.status !== "applied") continue;
+    const deferred = deferredByType.get(op.type) ?? [];
+    if (!deferred.length) continue;
+    const failedTarget = deferred.flatMap(fieldRefTargets).find((t) => failedTypes.has(t));
+    if (failedTarget) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "blocked", reason: `blocked: dependency "${failedTarget}" was not created` };
+      continue;
+    }
+    const id = idByType.get(op.type);
+    if (id == null) {
+      results[index] = { op, status: "blocked", reason: `no definition id for "${op.type}"` };
+      continue;
+    }
+    const definition = { fieldDefinitions: deferred.map((f) => ({ create: f })) };
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition });
+    const payload = data.metaobjectDefinitionUpdate;
+    if (payload.userErrors.length) {
+      failedTypes.add(op.type);
+      results[index] = { op, status: "failed", userErrors: payload.userErrors };
+    }
+  }
+  for (const { op, index } of otherOps) results[index] = await applyFieldOp(op);
   const counts = { applied: 0, skipped: 0, blocked: 0, failed: 0 };
   for (const r of results) counts[r.status]++;
   return { results, counts, ok: counts.failed === 0 && counts.blocked === 0 };