@fmaplabs/meta-manifest 0.2.0 → 0.3.0

package/dist/cli/index.cjs

@@ -41,12 +41,14 @@ var PULL_DEFINITION_QUERY = `query PullMetaobjectDefinition($type: String!) {
       required
       type { name }
       validations { name value }
+      capabilities { adminFilterable { enabled } }
     }
-    access { admin storefront }
+    access { admin storefront customerAccount }
     capabilities {
       publishable { enabled }
       translatable { enabled }
-      renderable { enabled }
+      renderable { enabled data { metaTitleKey metaDescriptionKey } }
+      onlineStore { enabled data { urlHandle } }
     }
   }
 }`;
@@ -56,6 +58,8 @@ var LIST_DEFINITIONS_QUERY = `query ListMetaobjectDefinitions($after: String) {
       id
       name
       type
+      description
+      displayNameKey
       fieldDefinitions {
         key
         name
@@ -63,6 +67,14 @@ var LIST_DEFINITIONS_QUERY = `query ListMetaobjectDefinitions($after: String) {
         required
         type { name }
         validations { name value }
+        capabilities { adminFilterable { enabled } }
+      }
+      access { admin storefront customerAccount }
+      capabilities {
+        publishable { enabled }
+        translatable { enabled }
+        renderable { enabled data { metaTitleKey metaDescriptionKey } }
+        onlineStore { enabled data { urlHandle } }
       }
     }
     pageInfo { hasNextPage endCursor }
@@ -205,6 +217,12 @@ async function runInit(opts = {}) {
 
 // src/codegen.ts
 var APP_PREFIX = "$app:";
+function isMerchant(type) {
+  return !type.startsWith(APP_PREFIX);
+}
+function filterableEntry(field) {
+  return field.filterable ? ["filterable: true"] : [];
+}
 var SIMPLE = {
   single_line_text_field: "text",
   multi_line_text_field: "multilineText",
@@ -286,8 +304,8 @@ function scalarEntries(field, warnings, builder) {
   jsonArr("file_type_options", "accept");
   return e;
 }
-function scalarCall(builder, field, warnings) {
-  const lit = optsLiteral(scalarEntries(field, warnings, builder));
+function scalarCall(builder, field, warnings, extra = []) {
+  const lit = optsLiteral([...scalarEntries(field, warnings, builder), ...extra]);
   return lit ? `m.${builder}(${lit})` : `m.${builder}()`;
 }
 function fieldCall(field, typeToIdent, warnings) {
@@ -297,6 +315,7 @@ function fieldCall(field, typeToIdent, warnings) {
     const max = v(field.validations, "max");
     const e = [`min: ${Number(min ?? 1)}`, `max: ${Number(max ?? 5)}`];
     if (field.required) e.unshift("required: true");
+    e.push(...filterableEntry(field));
     if (min === void 0 || max === void 0) warnings.push(`rating field "${field.key}" missing min/max`);
     return `m.rating(${optsLiteral(e)})`;
   }
@@ -307,7 +326,11 @@ function fieldCall(field, typeToIdent, warnings) {
       warnings.push(`unresolved reference on field "${field.key}"`);
       return `m.json() /* TODO: unmapped reference */`;
     }
-    return field.required ? `m.ref(() => ${ident}, { required: true })` : `m.ref(() => ${ident})`;
+    const refEntries = [];
+    if (field.required) refEntries.push("required: true");
+    refEntries.push(...filterableEntry(field));
+    const opts = optsLiteral(refEntries);
+    return opts ? `m.ref(() => ${ident}, ${opts})` : `m.ref(() => ${ident})`;
   }
   if (type.startsWith("list.")) {
     const inner = type.slice("list.".length);
@@ -317,6 +340,7 @@ function fieldCall(field, typeToIdent, warnings) {
     const max = v(field.validations, "list.max");
     if (min !== void 0) listEntries.push(`min: ${Number(min)}`);
     if (max !== void 0) listEntries.push(`max: ${Number(max)}`);
+    listEntries.push(...filterableEntry(field));
     const listOpts = optsLiteral(listEntries);
     let innerCall;
     if (inner === "metaobject_reference") {
@@ -335,17 +359,53 @@ function fieldCall(field, typeToIdent, warnings) {
     }
     return listOpts ? `m.list(${innerCall}, ${listOpts})` : `m.list(${innerCall})`;
   }
-  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings);
+  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings, filterableEntry(field));
   warnings.push(`unmapped field type "${type}" on field "${field.key}"`);
   return `m.json() /* TODO: unmapped type ${type} */`;
 }
+function accessSource(access) {
+  if (!access) return "";
+  const parts = [];
+  if (access.admin === "MERCHANT_READ_WRITE") parts.push(`admin: "merchant_read_write"`);
+  if (access.storefront === "PUBLIC_READ") parts.push(`storefront: "public_read"`);
+  if (access.customerAccount === "READ") parts.push(`customerAccount: "read"`);
+  return parts.length ? `{ ${parts.join(", ")} }` : "";
+}
+function capabilitiesSource(caps) {
+  if (!caps) return "";
+  const parts = [];
+  if (caps.publishable?.enabled) parts.push(`publishable: true`);
+  if (caps.translatable?.enabled) parts.push(`translatable: true`);
+  if (caps.renderable?.enabled) {
+    const d = caps.renderable.data;
+    const dparts = [];
+    if (d?.metaTitleKey != null) dparts.push(`metaTitleKey: ${JSON.stringify(d.metaTitleKey)}`);
+    if (d?.metaDescriptionKey != null) dparts.push(`metaDescriptionKey: ${JSON.stringify(d.metaDescriptionKey)}`);
+    parts.push(dparts.length ? `renderable: { ${dparts.join(", ")} }` : `renderable: true`);
+  }
+  if (caps.onlineStore?.enabled && caps.onlineStore.data?.urlHandle != null) {
+    parts.push(`onlineStore: { urlHandle: ${JSON.stringify(caps.onlineStore.data.urlHandle)} }`);
+  }
+  return parts.length ? `{ ${parts.join(", ")} }` : "";
+}
+function defConfigLines(def) {
+  const lines = [];
+  if (isMerchant(def.type)) lines.push(`  scope: "merchant",`);
+  if (def.name) lines.push(`  name: ${JSON.stringify(def.name)},`);
+  if (def.description != null) lines.push(`  description: ${JSON.stringify(def.description)},`);
+  if (def.displayNameKey != null) lines.push(`  displayName: ${JSON.stringify(def.displayNameKey)},`);
+  const access = accessSource(def.access);
+  if (access) lines.push(`  access: ${access},`);
+  const caps = capabilitiesSource(def.capabilities);
+  if (caps) lines.push(`  capabilities: ${caps},`);
+  return lines.length ? `
+${lines.join("\n")}` : "";
+}
 function defSource(def, typeToIdent, warnings) {
   const ident = typeToIdent.get(def.type);
   const handle = handleOf(def.type);
   const fields = def.fields.map((f) => `    ${f.key}: ${fieldCall(f, typeToIdent, warnings)},`).join("\n");
-  const name = def.name ? `
-  name: ${JSON.stringify(def.name)},` : "";
-  return `export const ${ident} = defineMetaobject(${JSON.stringify(handle)}, {${name}
+  return `export const ${ident} = defineMetaobject(${JSON.stringify(handle)}, {${defConfigLines(def)}
   fields: {
 ${fields}
   },
@@ -405,6 +465,42 @@ function sameValidations(a, b) {
   const norm = (v2) => JSON.stringify([...v2].sort((x, y) => x.name.localeCompare(y.name)));
   return norm(a) === norm(b);
 }
+var CAP_KEYS = ["publishable", "translatable", "renderable", "onlineStore"];
+function accessChanged(local, remote) {
+  for (const key of ["admin", "storefront", "customerAccount"]) {
+    const lv = local[key];
+    if (lv != null && remote?.[key] !== lv) return true;
+  }
+  return false;
+}
+function capabilitiesChanged(local, remote) {
+  for (const key of CAP_KEYS) {
+    const lc = local[key];
+    if (!lc) continue;
+    const rc = remote?.[key];
+    if ((rc?.enabled ?? false) !== lc.enabled) return true;
+    const ldata = lc.data;
+    if (ldata) {
+      const rdata = rc?.data;
+      for (const [k, v2] of Object.entries(ldata)) {
+        if (v2 != null && rdata?.[k] !== v2) return true;
+      }
+    }
+  }
+  return false;
+}
+function disablesOnlineStore(local, remote) {
+  return local.onlineStore?.enabled === false && remote?.onlineStore?.enabled === true;
+}
+function definitionChanges(local, remote) {
+  const changes = [];
+  if (local.name != null && local.name !== remote.name) changes.push("name");
+  if (local.description != null && local.description !== remote.description) changes.push("description");
+  if (local.displayNameKey != null && local.displayNameKey !== remote.displayNameKey) changes.push("displayNameKey");
+  if (local.access && accessChanged(local.access, remote.access)) changes.push("access");
+  if (local.capabilities && capabilitiesChanged(local.capabilities, remote.capabilities)) changes.push("capabilities");
+  return changes;
+}
 function diff(local, remote) {
   const ops = [];
   const remoteByType = new Map(remote.map((d) => [d.type, d]));
@@ -428,6 +524,7 @@ function diff(local, remote) {
       }
       const changes = {};
       if (rf.required !== lf.required) changes.required = lf.required;
+      if (rf.filterable !== lf.filterable) changes.filterable = lf.filterable;
       if (!sameValidations(rf.validations, lf.validations)) changes.validations = lf.validations;
       if (Object.keys(changes).length) {
         ops.push({ kind: "updateField", type: localDef.type, key: lf.key, changes });
@@ -438,49 +535,176 @@ function diff(local, remote) {
         ops.push({ kind: "removeField", type: localDef.type, key: rf.key, destructive: true });
       }
     }
+    const metaChanges = definitionChanges(localDef, remoteDef);
+    if (metaChanges.length) {
+      const destructive = localDef.capabilities ? disablesOnlineStore(localDef.capabilities, remoteDef.capabilities) : false;
+      ops.push({
+        kind: "updateDefinition",
+        type: localDef.type,
+        changes: metaChanges,
+        ...destructive ? { destructive: true } : {}
+      });
+    }
   }
   return ops;
 }
 
 // src/sync/normalize.ts
-function normalizeLocal(schema) {
-  const def = schema.toDefinitionInput();
-  return {
+function localCapabilities(caps) {
+  const out = {};
+  if (caps?.publishable) out.publishable = { enabled: caps.publishable.enabled };
+  if (caps?.translatable) out.translatable = { enabled: caps.translatable.enabled };
+  if (caps?.renderable) {
+    out.renderable = { enabled: caps.renderable.enabled };
+    if (caps.renderable.data) out.renderable.data = { ...caps.renderable.data };
+  }
+  out.onlineStore = caps?.onlineStore ? { enabled: caps.onlineStore.enabled, data: { urlHandle: caps.onlineStore.data?.urlHandle } } : { enabled: false };
+  return out;
+}
+function normalizeDefinition(def) {
+  const out = {
     type: def.type,
     name: def.name,
+    capabilities: localCapabilities(def.capabilities),
     fields: def.fieldDefinitions.map((f) => ({
       key: f.key,
       type: f.type,
       required: f.required,
+      filterable: f.capabilities?.adminFilterable?.enabled ?? false,
       validations: f.validations
     }))
   };
+  if (def.description != null) out.description = def.description;
+  if (def.displayNameKey != null) out.displayNameKey = def.displayNameKey;
+  if (def.access) out.access = { ...def.access };
+  return out;
+}
+function remoteAccess(access) {
+  if (!access) return void 0;
+  const out = {};
+  if (access.admin != null) out.admin = access.admin;
+  if (access.storefront != null) out.storefront = access.storefront;
+  if (access.customerAccount != null) out.customerAccount = access.customerAccount;
+  return out;
+}
+function remoteCapabilities(caps) {
+  const out = {};
+  if (!caps) return out;
+  if (caps.publishable) out.publishable = { enabled: !!caps.publishable.enabled };
+  if (caps.translatable) out.translatable = { enabled: !!caps.translatable.enabled };
+  if (caps.renderable) {
+    out.renderable = { enabled: !!caps.renderable.enabled };
+    const d = caps.renderable.data;
+    if (d) {
+      const data = {};
+      if (d.metaTitleKey != null) data.metaTitleKey = d.metaTitleKey;
+      if (d.metaDescriptionKey != null) data.metaDescriptionKey = d.metaDescriptionKey;
+      if (Object.keys(data).length) out.renderable.data = data;
+    }
+  }
+  if (caps.onlineStore) {
+    out.onlineStore = { enabled: !!caps.onlineStore.enabled };
+    if (caps.onlineStore.data?.urlHandle != null) out.onlineStore.data = { urlHandle: caps.onlineStore.data.urlHandle };
+  }
+  return out;
 }
 function normalizeRemote(def) {
-  return {
+  const out = {
     type: def.type,
     name: def.name,
+    capabilities: remoteCapabilities(def.capabilities),
     fields: def.fieldDefinitions.map((f) => ({
       key: f.key,
       type: typeof f.type === "string" ? f.type : f.type.name,
       required: f.required,
+      filterable: f.capabilities?.adminFilterable?.enabled ?? false,
       validations: f.validations ?? []
     }))
   };
+  if (def.description != null) out.description = def.description;
+  if (def.displayNameKey != null) out.displayNameKey = def.displayNameKey;
+  const access = remoteAccess(def.access);
+  if (access) out.access = access;
+  return out;
+}
+
+// src/sync/resolve.ts
+var APP_PREFIX2 = "$app:";
+function effectiveScope(schema, config) {
+  return schema.config.scope ?? config.scope ?? "app";
+}
+function effectiveType(handle, scope) {
+  return scope === "merchant" ? handle : `${APP_PREFIX2}${handle}`;
+}
+function rewriteReference(v2, effByCanonical) {
+  if (v2.name === "metaobject_definition_type") {
+    const mapped = effByCanonical.get(v2.value);
+    return mapped ? { ...v2, value: mapped } : v2;
+  }
+  if (v2.name === "metaobject_definition_types") {
+    try {
+      const parsed = JSON.parse(v2.value);
+      if (Array.isArray(parsed)) {
+        const rewritten = parsed.map((t) => typeof t === "string" ? effByCanonical.get(t) ?? t : t);
+        return { ...v2, value: JSON.stringify(rewritten) };
+      }
+    } catch {
+    }
+  }
+  return v2;
+}
+function resolveAdmin(out, handle, scope, config) {
+  const explicitAdmin = out.access?.admin;
+  if (scope === "merchant") {
+    if (explicitAdmin != null) {
+      throw new Error(
+        `"${handle}" is merchant-scoped but sets access.admin; admin access is only valid on app-scoped metaobjects.`
+      );
+    }
+    return;
+  }
+  if (explicitAdmin == null) {
+    const admin = config.merchantEditable ? "MERCHANT_READ_WRITE" : "MERCHANT_READ";
+    out.access = { ...out.access, admin };
+  }
+}
+function resolveDefinitions(schemas, config = {}) {
+  const effByCanonical = /* @__PURE__ */ new Map();
+  for (const s of schemas) {
+    effByCanonical.set(`${APP_PREFIX2}${s.handle}`, effectiveType(s.handle, effectiveScope(s, config)));
+  }
+  return schemas.map((s) => {
+    const scope = effectiveScope(s, config);
+    const base = s.toDefinitionInput();
+    const fieldDefinitions = base.fieldDefinitions.map((f) => ({
+      ...f,
+      validations: f.validations.map((v2) => rewriteReference(v2, effByCanonical))
+    }));
+    const out = { ...base, type: effectiveType(s.handle, scope), fieldDefinitions };
+    resolveAdmin(out, s.handle, scope, config);
+    return out;
+  });
 }
 
 // src/sync/pull.ts
+function toDefinition(type, node) {
+  return {
+    type,
+    name: node.name,
+    description: node.description,
+    displayNameKey: node.displayNameKey,
+    access: node.access,
+    capabilities: node.capabilities,
+    fieldDefinitions: node.fieldDefinitions
+  };
+}
 async function pull(client, types) {
   const out = [];
   for (const type of types) {
     const data = await execute(client, PULL_DEFINITION_QUERY, { type });
     const node = data.metaobjectDefinitionByType;
     if (!node) continue;
-    out.push({
-      id: node.id,
-      type,
-      definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions }
-    });
+    out.push({ id: node.id, type, definition: toDefinition(type, node) });
   }
   return out;
 }
@@ -498,7 +722,7 @@ async function pullAll(client, opts = {}) {
       const canonical = toCanonicalType(node.type);
       if (appOwnedOnly && !canonical) continue;
       const type = canonical ?? node.type;
-      out.push({ id: node.id, type, definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions } });
+      out.push({ id: node.id, type, definition: toDefinition(type, node) });
     }
     after = data.metaobjectDefinitions.pageInfo.hasNextPage ? data.metaobjectDefinitions.pageInfo.endCursor : null;
   } while (after !== null);
@@ -506,6 +730,25 @@ async function pullAll(client, opts = {}) {
 }
 
 // src/sync/push.ts
+function definitionUpdateFor(def, changes) {
+  const out = {};
+  for (const c of changes) {
+    if (c === "name") out.name = def.name;
+    else if (c === "description") out.description = def.description;
+    else if (c === "displayNameKey") out.displayNameKey = def.displayNameKey;
+    else if (c === "access") out.access = def.access;
+    else if (c === "capabilities") {
+      const caps = def.capabilities;
+      const payload = {};
+      if (caps?.publishable) payload.publishable = caps.publishable;
+      if (caps?.translatable) payload.translatable = caps.translatable;
+      if (caps?.renderable) payload.renderable = caps.renderable;
+      payload.onlineStore = caps?.onlineStore ?? { enabled: false };
+      out.capabilities = payload;
+    }
+  }
+  return out;
+}
 function fieldInputFor(defByType, type, key) {
   return defByType.get(type)?.fieldDefinitions.find((f) => f.key === key);
 }
@@ -606,14 +849,22 @@ async function push(client, plan, sources, options) {
       if (id2) idByType.set(op.type, id2);
       return { op, status: "applied", id: id2 };
     }
-    const destructive = op.kind === "removeField" || op.kind === "changeFieldType";
+    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` };
     const id = idByType.get(op.type);
     if (id == null) return { op, status: "blocked", reason: `no definition id for "${op.type}"` };
-    const fieldDefinitions = fieldOpsFor(op);
-    if (!fieldDefinitions) return { op, status: "blocked", reason: `no field input for "${op.type}"` };
-    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition: { fieldDefinitions } });
+    let definition;
+    if (op.kind === "updateDefinition") {
+      const def = defByType.get(op.type);
+      if (!def) return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      definition = definitionUpdateFor(def, op.changes);
+    } else {
+      const fieldDefinitions = fieldOpsFor(op);
+      if (!fieldDefinitions) return { op, status: "blocked", reason: `no field input for "${op.type}"` };
+      definition = { fieldDefinitions };
+    }
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition });
     const payload = data.metaobjectDefinitionUpdate;
     if (payload.userErrors.length) return { op, status: "failed", userErrors: payload.userErrors };
     return { op, status: "applied", id: payload.metaobjectDefinition?.id ?? id };
@@ -634,6 +885,9 @@ async function push(client, plan, sources, options) {
           validations: field.validations
         };
         if (field.description != null) update.description = field.description;
+        if ("filterable" in op.changes) {
+          update.capabilities = { adminFilterable: { enabled: op.changes.filterable ?? false } };
+        }
         return [{ update }];
       }
       case "removeField":
@@ -654,12 +908,31 @@ async function push(client, plan, sources, options) {
 }
 
 // src/cli/plan.ts
-async function planFor(client, schemas) {
-  const types = schemas.map((s) => s.type);
-  const localDefs = schemas.map(normalizeLocal);
+var APP_PREFIX3 = "$app:";
+async function detectScopeFlips(client, definitions, plan) {
+  const merchant = definitions.filter((d) => !d.type.startsWith(APP_PREFIX3));
+  if (merchant.length === 0) return [];
+  const created = new Set(plan.filter((op) => op.kind === "createDefinition").map((op) => op.type));
+  const shadows = await pull(client, merchant.map((d) => `${APP_PREFIX3}${d.type}`));
+  const shadowTypes = new Set(shadows.map((s) => s.type));
+  const warnings = [];
+  for (const d of merchant) {
+    if (created.has(d.type) && shadowTypes.has(`${APP_PREFIX3}${d.type}`)) {
+      warnings.push(
+        `"${d.type}" is merchant-scoped but an app-owned "${APP_PREFIX3}${d.type}" already exists remotely. Scope changes are not migrated (type is immutable): a new merchant-owned definition will be created and the app-owned one left orphaned. Migrate manually \u2014 see docs/SYNC.md.`
+      );
+    }
+  }
+  return warnings;
+}
+async function planFor(client, schemas, config = {}) {
+  const definitions = resolveDefinitions(schemas, config);
+  const types = definitions.map((d) => d.type);
+  const localDefs = definitions.map(normalizeDefinition);
   const remote = await pull(client, types);
   const plan = diff(localDefs, remote.map((r) => normalizeRemote(r.definition)));
-  return { plan, remote };
+  const warnings = await detectScopeFlips(client, definitions, plan);
+  return { plan, remote, definitions, warnings };
 }
 
 // src/cli/format.ts
@@ -690,7 +963,8 @@ function describeResult(r) {
 
 // src/cli/diff.ts
 async function runDiff(args) {
-  const { plan } = await planFor(args.client, args.schemas);
+  const { plan, warnings } = await planFor(args.client, args.schemas, args.config);
+  for (const w of warnings) console.warn(`Warning: ${w}`);
   if (plan.length === 0) {
     console.log("Everything is in sync \u2014 nothing to apply.");
   } else {
@@ -702,8 +976,8 @@ async function runDiff(args) {
 
 // src/cli/push.ts
 async function runPush(args) {
-  const { plan, remote } = await planFor(args.client, args.schemas);
-  const definitions = args.schemas.map((s) => s.toDefinitionInput());
+  const { plan, remote, definitions, warnings } = await planFor(args.client, args.schemas, args.config);
+  for (const w of warnings) console.warn(`Warning: ${w}`);
   const result = await push(args.client, plan, { definitions, remote }, { allowDestructive: args.allowDestructive });
   for (const r of result.results) console.log(`  ${describeResult(r)}`);
   console.log(
@@ -789,11 +1063,11 @@ async function main(argv) {
     }
     const schemas = await loadSchemas(config.schema);
     if (args.command === "diff") {
-      await runDiff({ client, schemas });
+      await runDiff({ client, schemas, config });
       return 0;
     }
     if (args.command === "push") {
-      const result = await runPush({ client, schemas, allowDestructive: args.allowDestructive });
+      const result = await runPush({ client, schemas, config, allowDestructive: args.allowDestructive });
       return result.ok ? 0 : 2;
     }
     console.error(`Unknown command: ${args.command}`);