API SPEC SEARCH

read -r -d '' CODE <<'JS'
async function() {
  return lightIndex.filter(r => r.menuPath.includes("bookings")).map(r => r.name);
}
JS
curl -sS -X POST 'https://mcp.wix.com/api/code-mode/search' \
  -H 'Content-Type: application/json' \
  --data "$(jq -n --arg code "$CODE" '{code:$code}')"     # or: python3 -c 'import json,sys;print(json.dumps({"code":sys.stdin.read()}))'

{ title, description, fqdn, docsUrl,
  methods: [ { summary, description, operationId, httpMethod, path, docsUrl,
               publicUrl, publicBaseUrl, requestBody, responses, parameters,
               permissions, queryMethodData, legacyExamples: [ { content: { title, request, response } } ] } ],
  components: { schemas: { …every referenced type… } } }

async function() {
  const words = ["stores", "query", "products"];
  return lightIndex.flatMap(resource =>
    resource.methods
      .filter(method => {
        const haystack = [
          resource.name, resource.docsUrl, resource.menuPath.join("/"),
          method.summary, method.operationId, method.description, method.path, method.docsUrl
        ].join(" ").toLowerCase();
        return words.every(word => haystack.includes(word));
      })
      .map(method => ({
        title: method.summary, resource: resource.name,
        httpMethod: method.httpMethod.toUpperCase(),
        docsUrl: method.docsUrl, publicUrl: method.publicUrl
      }))
  );
}

async function() {
  const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products";
  const schema = await getResourceSchemaByUrl(methodUrl);   // scoped: one method
  const method = schema.methods[0];
  return {
    title: method.summary,
    publicUrl: method.publicUrl,
    httpMethod: method.httpMethod.toUpperCase(),
    operationId: method.operationId,
    permissions: method.permissions,
    parameters: method.parameters,
    requestBody: method.requestBody,
    responses: method.responses,
    queryFieldsCapabilities: method.queryMethodData?.queryFieldsCapabilitiesMap,
    curlExamples: method.legacyExamples?.map(e => e.content)
  };
}

async function() {
  const schema = await getResourceSchemaByUrl("https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3");  // resource URL → every method
  return {
    resource: schema.title,
    description: schema.description,
    methods: schema.methods.map(m => ({ title: m.summary, httpMethod: m.httpMethod.toUpperCase(), docsUrl: m.docsUrl, publicUrl: m.publicUrl, operationId: m.operationId }))
  };
}

async function() {
  const partial = "stores/catalog-v3/products-v3/query-products";
  const resource = lightIndex.find(r =>
    r.docsUrl.includes(partial) || r.methods.some(m => m.docsUrl?.includes(partial)));
  if (!resource) return "No API resource found for this partial URL";
  const methodDocsUrl = resource.methods.find(m => m.docsUrl?.includes(partial))?.docsUrl;
  if (!methodDocsUrl) return { message: "Resource found, no matching method", methods: resource.methods.map(m => m.docsUrl) };
  const method = (await getResourceSchemaByUrl(methodDocsUrl)).methods[0];  // canonical method URL → scoped
  return { title: method.summary, publicUrl: method.publicUrl, httpMethod: method.httpMethod.toUpperCase(), requestBody: method.requestBody, responses: method.responses };
}

async function() {
  const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products";
  const schema = await getResourceSchemaByUrl(methodUrl);
  const method = schema.methods[0];   // method URL → scoped result
  return {
    requestBody: method.requestBody,
    selectedNestedTypes: {
      product: schema.components.schemas["com.wix.stores.catalog.product.api.v3.Product"],
      cursorPaging: schema.components.schemas["wix.stores.catalog.v3.upstream.wix.common.CursorPaging"]
    }
  };
}

async function() {
  const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products";
  const schema = await getResourceSchemaByUrl(methodUrl);
  const method = schema.methods[0];   // method URL → scoped result
  function expand(value, depth = 0, seen = []) {
    if (depth > 3) return value;
    if (Array.isArray(value)) return value.map(v => expand(v, depth, seen));
    if (!value || typeof value !== "object") return value;
    if (value.$circular) {
      const name = value.$circular;
      if (seen.includes(name)) return { $ref: name, circular: true };
      const target = schema.components?.schemas?.[name];
      return target ? { $ref: name, schema: expand(target, depth + 1, seen.concat(name)) } : { $ref: name, missing: true };
    }
    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, expand(v, depth, seen)]));
  }
  return { title: method.summary, publicUrl: method.publicUrl, requestBody: expand(method.requestBody), responses: expand(method.responses) };
}