@takeshape/cli 11.113.1 → 11.113.5

package/dist/index.js

@@ -206930,7 +206930,7 @@ var engines = {
 };
 var package_default = {
   name: "@takeshape/cli",
-  version: "11.113.1",
+  version: "11.113.5",
   description: "TakeShape CLI",
   homepage: "https://www.takeshape.io",
   repository: {
@@ -219695,6 +219695,9 @@ var scalars = ["string", "boolean", "integer", "number"];
 // ../schema/dist/services/util.js
 var import_isEmpty2 = __toESM(require_isEmpty(), 1);
 var import_uniq2 = __toESM(require_uniq(), 1);
+function getStoredServiceConfig(projectSchema, serviceKey) {
+  return projectSchema.services?.[serviceKey];
+}
 function getServiceNamespaces(context) {
   const namespaces = /* @__PURE__ */ new Map();
   const { services } = context;
@@ -397423,6 +397426,9 @@ var allProjectSchemas = [
 function isBasicResolver(resolver) {
   return isRecord(resolver) && (0, import_isString3.default)(resolver.name);
 }
+function isServiceResolver(resolver) {
+  return isRecord(resolver) && (0, import_isString3.default)(resolver.name) && (0, import_isString3.default)(resolver.service);
+}
 function isComposeResolver(resolver) {
   return Boolean((0, import_isArray.default)(resolver?.compose) && resolver.compose.length && resolver.compose.every(isBasicResolver));
 }
@@ -397456,6 +397462,15 @@ function isArraySchema(propertySchema2) {
 function isObjectSchema(propertySchema2) {
   return isRecord(propertySchema2) && propertySchema2.type === "object" && isRecord(propertySchema2.properties);
 }
+function isAnyServiceConfig(maybeConfig) {
+  return maybeConfig && (0, import_isString3.default)(maybeConfig.title) && (0, import_isString3.default)(maybeConfig.id) && (0, import_isString3.default)(maybeConfig.provider) && (0, import_isString3.default)(maybeConfig.serviceType) && (0, import_isString3.default)(maybeConfig.authenticationType);
+}
+function isServiceAuthentication(maybeAuthentication) {
+  return maybeAuthentication?.type;
+}
+function isSearchParamsAuthentication(authentication) {
+  return authentication?.type === "searchParams";
+}
 var getArgsType = (argsSchema) => {
   if ((0, import_has.default)(argsSchema, "@args")) {
     return ArgsType["@args"];
@@ -397817,6 +397832,9 @@ function propertyRefItemToPath(getNamespace2, item2) {
   }
   return ["shapes", applyNamespace(namespace, shapeName14), "schema", "properties", propertyName];
 }
+function normalizeRefExpression(context, refExpression) {
+  return serializeRef(parseRef(context, refExpression));
+}
 function getToolRef(tool) {
   return typeof tool === "string" ? tool : tool.ref;
 }
@@ -398016,9 +398034,59 @@ var nonStructuralSchemaKeys = [
   "minItems",
   "uniqueItems"
 ];
+function getServiceIdFieldName(serviceFieldName) {
+  return `${serviceFieldName}Id`;
+}
 var generatorVersions = {
   [SERVICE_OBJECT_PATTERN_NAME]: "1"
 };
+function getGeneratorVersion(generator) {
+  return generatorVersions[generator];
+}
+function pathBetween(fromShape, toShape, projectSchema, depthLimit = 4) {
+  if (fromShape.name === toShape.name) {
+    return [];
+  }
+  const toShapeName = toShape.name;
+  let shortestPath;
+  let shortestPathLength = Number.MAX_SAFE_INTEGER;
+  const pathBetweenHelper = (schema22, pathSoFar, seen, depth) => {
+    if (depth > depthLimit) {
+      return;
+    }
+    if (schema22.items) {
+      pathBetweenHelper(schema22.items, pathSoFar, seen, depth);
+      return;
+    }
+    const refItem = getRef(projectSchema, schema22);
+    if (refItem) {
+      const referenced = refItemToShape(projectSchema, refItem);
+      if (referenced) {
+        if (referenced.name === toShapeName && pathSoFar.length < shortestPathLength) {
+          shortestPath = pathSoFar;
+          shortestPathLength = pathSoFar.length;
+        } else if (!seen.has(referenced.name)) {
+          pathBetweenHelper(referenced.schema, pathSoFar, /* @__PURE__ */ new Set([...seen, referenced.name]), depth);
+        }
+      }
+    } else if (pathSoFar.length + 1 < shortestPathLength && (schema22.oneOf ?? schema22.allOf ?? schema22.properties)) {
+      if (schema22.oneOf) {
+        for (const itemSchema of schema22.oneOf) {
+          pathBetweenHelper(itemSchema, pathSoFar, seen, depth);
+        }
+      } else {
+        for (const [propName, propSchema] of createSchemaPropertyList(projectSchema, schema22).getNodes()) {
+          pathBetweenHelper(propSchema, pathSoFar.concat(String(propName)), seen, depth + 1);
+        }
+      }
+    }
+  };
+  pathBetweenHelper(fromShape.schema, [], /* @__PURE__ */ new Set([fromShape.name]), 0);
+  if (!shortestPath) {
+    throw new Error(`No path between ${fromShape.name} and ${toShape.name}`);
+  }
+  return shortestPath;
+}
 function getShapeQueriesAndMutations(shapes) {
   const queries = {};
   const mutations = {};
@@ -398796,59 +398864,1001 @@ var import_keyBy3 = __toESM(require_keyBy(), 1);
 var import_forEach4 = __toESM(require_forEach(), 1);
 var import_pick2 = __toESM(require_pick(), 1);
 
+// ../schema/dist/migration/utils.js
+function formatDate(timestamp) {
+  return (timestamp ? new Date(timestamp) : /* @__PURE__ */ new Date()).toISOString();
+}
+
+// ../schema/dist/migration/to/v3.0.0.js
+var annotationMap = {
+  l10n: "@l10n",
+  sensitive: "@sensitive",
+  syncLocaleStructure: "@syncLocaleStructure"
+};
+function isColor(schema22) {
+  const { type, properties } = schema22;
+  return Boolean(type === "object" && properties?.hsl && properties.hsv && properties.rgb && properties.hex);
+}
+function getModelType(contentType) {
+  if (contentType.single) {
+    return "single";
+  }
+  if (contentType.taxonomy) {
+    return "taxonomy";
+  }
+  return "multiple";
+}
+function getRelationshipSchema(relationship) {
+  const itemSchema = {
+    $ref: "#/shapes/TSRelationship/schema"
+  };
+  if (relationship.type === "multiple") {
+    return {
+      type: "array",
+      items: itemSchema,
+      "@relationship": relationship
+    };
+  }
+  return {
+    ...itemSchema,
+    "@relationship": relationship
+  };
+}
+function migrateToContentSchemaV3(params) {
+  const { schema: schema22, service, name, key, setSource, omitAllSources } = params;
+  const { type } = schema22;
+  const mapping = !omitAllSources && key && setSource !== false && name !== key ? `${service}.${key}` : void 0;
+  (0, import_forEach4.default)(schema22, (value2, key2) => {
+    if (annotationMap[key2]) {
+      const newAnnotation = annotationMap[key2];
+      schema22[newAnnotation] = value2;
+      delete schema22[key2];
+    }
+  });
+  if (type === "string" || type === "boolean" || type === "number" || type === "integer") {
+    return {
+      schema: { ...(0, import_pick2.default)(schema22, scalarSchemaKeys), "@mapping": mapping }
+    };
+  }
+  const { relationship } = schema22;
+  if (relationship) {
+    const { contentTypeIds, type: relationshipType, relatedName } = relationship;
+    return {
+      schema: {
+        ...(0, import_pick2.default)(schema22, relationshipType === "multiple" ? multipleRelationshipSchemaKeys : schemaMetadataKeys),
+        "@mapping": mapping,
+        ...getRelationshipSchema({
+          shapeIds: contentTypeIds,
+          type: relationshipType ?? "single",
+          // Type is optional on assets
+          relatedName
+        })
+      }
+    };
+  }
+  if (type === "object" && schema22.draftjs) {
+    return {
+      schema: {
+        ...(0, import_pick2.default)(schema22, scalarSchemaKeys),
+        "@mapping": mapping,
+        "@tag": "draftjs"
+      }
+    };
+  }
+  if (isColor(schema22)) {
+    return {
+      schema: {
+        ...(0, import_pick2.default)(schema22, scalarSchemaKeys),
+        $ref: "#/shapes/TSColor/schema",
+        "@mapping": mapping
+      }
+    };
+  }
+  if (type === "object" && schema22.properties) {
+    const properties = {};
+    const shapes = {};
+    const shapeTitle = [params.shapeTitle, pascalCase(schema22.title ?? params.name)].filter(Boolean).join(" ");
+    const shapeName14 = `${params.shapeName}${pascalCase(params.name)}`;
+    const contentSourceId = `takeshape:local:${shapeName14}`;
+    (0, import_forEach4.default)(schema22.properties, (propSchema, name2) => {
+      const { schema: migratedPropSchema, hoistedShapes } = migrateToContentSchemaV3({
+        ...params,
+        shapeName: shapeName14,
+        shapeTitle,
+        depth: params.depth + 1,
+        schema: propSchema,
+        parentSchema: schema22,
+        service: contentSourceId,
+        key: propSchema.key ?? name2,
+        name: name2,
+        setSource: true
+      });
+      properties[name2] = migratedPropSchema;
+      Object.assign(shapes, hoistedShapes);
+    });
+    if (params.depth > 0) {
+      const { title, description, ...rest } = schema22;
+      return {
+        schema: {
+          title,
+          description,
+          "@mapping": mapping,
+          $ref: `#/shapes/${shapeName14}/schema`
+        },
+        hoistedShapes: {
+          ...shapes,
+          [shapeName14]: {
+            id: name === key ? shapeName14 : key,
+            name: shapeName14,
+            title: shapeTitle,
+            schema: {
+              ...(0, import_pick2.default)(rest, objectSchemaKeys),
+              type: "object",
+              properties
+            }
+          }
+        }
+      };
+    }
+    return {
+      schema: {
+        ...(0, import_pick2.default)(schema22, objectSchemaKeys),
+        properties,
+        "@mapping": mapping
+      },
+      hoistedShapes: shapes
+    };
+  }
+  if (schema22.type === "array" && schema22.items) {
+    const { schema: itemSchema, hoistedShapes } = migrateToContentSchemaV3({
+      ...params,
+      schema: schema22.items,
+      parentSchema: schema22,
+      service: "parent",
+      setSource: false
+    });
+    return {
+      schema: {
+        ...(0, import_pick2.default)(schema22, arraySchemaKeys),
+        items: itemSchema,
+        "@mapping": mapping
+      },
+      hoistedShapes
+    };
+  }
+  throw new Error(`Unknown schema type "${type}"`);
+}
+function contentTypeToShape(contentType, contentTypeId) {
+  const title = contentType.title ?? contentType.name;
+  const name = pascalCase(contentType.name);
+  const contentSourceId = `takeshape:local:${name}`;
+  const { schema: schema22, hoistedShapes } = migrateToContentSchemaV3({
+    shapeName: name,
+    shapeTitle: title,
+    schema: contentType.schema,
+    service: contentSourceId,
+    name: "",
+    key: "",
+    depth: 0
+  });
+  return {
+    [name]: {
+      id: contentTypeId,
+      name,
+      title,
+      model: {
+        type: getModelType(contentType)
+      },
+      workflow: contentType.workflow,
+      schema: schema22
+    },
+    ...hoistedShapes
+  };
+}
+var migrate = async (_, projectSchema) => {
+  const { contentTypes, created, updated, ...rest } = projectSchema;
+  const shapes = {};
+  const forms = {};
+  for (const contentTypeId of Object.keys(contentTypes)) {
+    const contentType = contentTypes[contentTypeId];
+    Object.assign(shapes, contentTypeToShape(contentType, contentTypeId));
+    forms[pascalCase(contentType.name)] = contentType.forms;
+  }
+  return deepClone({
+    ...rest,
+    ...getShapeQueriesAndMutations(Object.values(shapes)),
+    schemaVersion: "3",
+    created: formatDate(created),
+    updated: formatDate(updated),
+    shapes,
+    forms
+  });
+};
+var v3_0_0_default2 = migrate;
+
 // ../schema/dist/migration/to/v3.1.0.js
 var import_isObject2 = __toESM(require_isObject(), 1);
 var import_isString6 = __toESM(require_isString(), 1);
 var import_isUndefined2 = __toESM(require_isUndefined(), 1);
 var import_p_reduce = __toESM(require_p_reduce(), 1);
+function parseV3ServiceStr(service) {
+  const parts = service.split(":");
+  return {
+    provider: parts.length > 1 ? parts[0] : void 0,
+    id: parts.length > 1 ? parts[1] : parts[0]
+  };
+}
+function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
+  if (isAnyServiceConfig(serviceConfig)) {
+    if ((0, import_isString6.default)(serviceConfig.authentication) || (0, import_isUndefined2.default)(serviceConfig.authentication)) {
+      return serviceConfig;
+    }
+    return serviceConfig;
+  }
+  const { auth } = serviceConfig;
+  const serviceParams = serviceConfig.params || {};
+  let { provider: serviceKeyProvider, id: serviceKeyId } = parseV3ServiceStr(serviceKey);
+  const authType = serviceParams.authType || void 0;
+  const title = serviceParams.name || serviceKeyId;
+  if (serviceKeyId === "vercel") {
+    serviceKeyProvider = "vercel";
+  } else if (serviceKeyId === "netlify") {
+    serviceKeyProvider = "netlify";
+  }
+  if (serviceParams.type === "rest") {
+    serviceKeyProvider = "rest";
+  } else if (serviceParams.type === "graphql" && serviceKeyProvider !== "shopify") {
+    serviceKeyProvider = "graphql";
+  }
+  let provider;
+  let authenticationType;
+  let serviceType;
+  let namespace;
+  if (serviceKeyProvider === "shopify") {
+    provider = "shopify";
+    authenticationType = "oauth2Bearer";
+    serviceType = "graphql";
+    namespace = serviceParams.namespace ?? "Shopify";
+  } else if (serviceKeyProvider === "takeshape") {
+    provider = "takeshape";
+    authenticationType = "none";
+    serviceType = "takeshape";
+    namespace = serviceParams.namespace ?? "TakeShape";
+  } else if (serviceKeyProvider === "bigcommerce") {
+    provider = "bigcommerce";
+    authenticationType = "bearer";
+    serviceType = "graphql";
+    namespace = serviceParams.namespace ?? "BigCommerce";
+  } else if (serviceKeyProvider === "rest") {
+    provider = "generic";
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = "rest";
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  } else if (serviceKeyProvider === "graphql") {
+    provider = "generic";
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = "graphql";
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  } else if (serviceKeyProvider === "vercel") {
+    provider = "vercel";
+    authenticationType = "oauth2Bearer";
+    serviceType = "deployment";
+  } else if (serviceKeyProvider === "netlify") {
+    provider = "netlify";
+    authenticationType = "oauth2Bearer";
+    serviceType = "deployment";
+  } else {
+    provider = "generic";
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = "unknown";
+    namespace = serviceParams.namespace ?? pascalCase(title);
+  }
+  const updatedServiceConfig = {
+    title,
+    id: serviceKey,
+    provider,
+    namespace,
+    serviceType,
+    authenticationType,
+    options: {
+      ...serviceParams
+    }
+  };
+  if (serviceConfig.auth && (0, import_isObject2.default)(serviceConfig.auth)) {
+    const authentication = updateServiceAuthentication(updatedServiceConfig.authenticationType, serviceConfig.auth, serviceParams);
+    return {
+      ...updatedServiceConfig,
+      authentication
+    };
+  }
+  return updatedServiceConfig;
+}
+function updateServiceAuthentication(authenticationType, legacyAuth, legacyParams) {
+  if (authenticationType === "oauth2Bearer") {
+    return {
+      token: legacyAuth.accessToken,
+      scope: legacyAuth.scope,
+      header: legacyParams.authHeader
+    };
+  }
+  if (authenticationType === "searchParams" && legacyParams.authProp) {
+    return [
+      {
+        name: legacyParams.authProp,
+        value: legacyAuth.accessToken
+      }
+    ];
+  }
+  if (authenticationType === "basic") {
+    const [username, password] = Buffer.from(legacyAuth.accessToken, "base64").toString("utf-8").split(":");
+    return {
+      username,
+      password
+    };
+  }
+  if (authenticationType === "bearer") {
+    return {
+      token: legacyAuth.accessToken,
+      header: legacyParams.authHeader
+    };
+  }
+}
+function mapAuthType(authType, auth) {
+  if (authType === "none") {
+    return "none";
+  }
+  if (authType === "searchParams") {
+    return "searchParams";
+  }
+  if (authType === "bearer") {
+    return "bearer";
+  }
+  if (authType === "bearer") {
+    return "basic";
+  }
+  if (!auth) {
+    return "none";
+  }
+  if (auth) {
+    return "bearer";
+  }
+  return "unknown";
+}
+var migrate2 = async (context, projectSchema) => {
+  const { encryptFn, decryptFn } = context;
+  let services;
+  if (projectSchema.services) {
+    services = await (0, import_p_reduce.default)(Object.entries(projectSchema.services), async (serviceMap, [serviceKey, serviceConfig]) => {
+      const auth = serviceConfig.auth && decryptFn(serviceConfig.auth);
+      const updatedServiceConfig = updateServiceConfigV3ToV3_1({ ...serviceConfig, auth }, serviceKey);
+      const authentication = updatedServiceConfig?.authentication;
+      serviceMap[serviceKey] = {
+        ...updatedServiceConfig,
+        authentication: authentication && (0, import_isObject2.default)(authentication) ? encryptFn(authentication) : authentication
+      };
+      return serviceMap;
+    }, {});
+  }
+  return deepClone({
+    ...projectSchema,
+    services,
+    schemaVersion: "3.1.0"
+  });
+};
+var v3_1_0_default2 = migrate2;
+
+// ../schema/dist/migration/to/v3.3.0.js
+var migrate3 = async (context, projectSchema) => {
+  const { generateDataKeyFn } = context;
+  const dataKey = projectSchema.dataKey ? projectSchema.dataKey : await generateDataKeyFn();
+  return {
+    ...projectSchema,
+    schemaVersion: "3.3.0",
+    dataKey
+  };
+};
+var v3_3_0_default2 = migrate3;
 
 // ../schema/dist/migration/to/v3.9.0.js
 var import_isEmpty3 = __toESM(require_isEmpty(), 1);
 var import_omit8 = __toESM(require_omit(), 1);
+function omitOptions(resolver, names) {
+  if (resolver.options) {
+    const newOptions = (0, import_omit8.default)(resolver.options, names);
+    if ((0, import_isEmpty3.default)(newOptions)) {
+      resolver.options = void 0;
+    } else {
+      resolver.options = newOptions;
+    }
+  }
+}
+var migrate4 = async (_, projectSchema) => {
+  const ensureResolverOptions = (resolver) => {
+    if (resolver.name.startsWith("takeshape")) {
+      if (!resolver.shapeName) {
+        resolver.shapeName = resolver.options?.model ?? resolver.options?.indexedShape ?? "";
+        omitOptions(resolver, ["model", "indexedShape"]);
+      }
+    }
+    if (resolver.name.startsWith("graphql")) {
+      if (!resolver.fieldName) {
+        resolver.fieldName = resolver.options?.fieldName ?? "";
+        omitOptions(resolver, ["fieldName"]);
+      }
+    }
+    if (resolver.name.startsWith("awsLambda")) {
+      if (!resolver.functionName) {
+        resolver.functionName = resolver.options?.functionName ?? "";
+        omitOptions(resolver, ["functionName"]);
+      }
+    }
+    if (resolver.name.startsWith("rest")) {
+      if (!resolver.path) {
+        if (resolver.pathParams) {
+          resolver.path = {
+            ...resolver.pathParams,
+            serialize: {
+              ...resolver.pathParams.serialize,
+              template: resolver.options?.path
+            }
+          };
+        } else {
+          resolver.path = resolver.options?.path ?? "";
+        }
+        omitOptions(resolver, ["path"]);
+      }
+    }
+    return resolver;
+  };
+  visit3(projectSchema, ["resolver", "@resolver"], (resolver) => {
+    if (resolver.compose) {
+      resolver.compose.forEach(ensureResolverOptions);
+    } else {
+      ensureResolverOptions(resolver);
+    }
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.9.0"
+  };
+};
+var v3_9_0_default2 = migrate4;
 
 // ../schema/dist/migration/to/v3.10.0.js
 var import_set3 = __toESM(require_set3(), 1);
 var import_mapValues2 = __toESM(require_mapValues(), 1);
+function $refToPath2(ref) {
+  return ref.substr(2).split("/");
+}
+function $refToShapeName2(ref) {
+  return $refToPath2(ref)[1];
+}
+function findServiceIdForNamespace(projectSchema, namespace) {
+  if (projectSchema.services) {
+    for (const [serviceId, service] of Object.entries(projectSchema.services)) {
+      if (service.namespace === namespace) {
+        return serviceId;
+      }
+    }
+  }
+  return "local";
+}
+function updateRefSyntax(projectSchema, $ref) {
+  const shapeName14 = $refToShapeName2($ref);
+  const parts = shapeName14.split("_");
+  const serviceId = parts.length === 1 ? "local" : findServiceIdForNamespace(projectSchema, parts[0]);
+  return `${serviceId}:${parts[parts.length - 1]}`;
+}
+function migrateQueryToV3_10(projectSchema) {
+  return (query, queryName) => {
+    const { args, shape } = query;
+    if (typeof args === "object" && ("oneOf" in args || "allOf" in args || "$ref" in args || "@ref" in args)) {
+      throw new Error(`Query "${queryName}" contains an unsupported arg schema ${JSON.stringify(args)}. Please contact support`);
+    }
+    if (typeof shape === "object") {
+      if (shape.items.$ref) {
+        return (0, import_set3.default)("shape.items", { "@ref": updateRefSyntax(projectSchema, shape.items.$ref) }, query);
+      }
+      if (!shape.items["@ref"]) {
+        throw new Error(`Query "${queryName}" contains an unsupported shape schema ${JSON.stringify(shape)}. Please contact support`);
+      }
+    }
+    return query;
+  };
+}
+function migrateShapeToV3_10(shape) {
+  const { schema: schema22, ...rest } = shape;
+  if ("type" in schema22 && schema22.type === "array") {
+    throw new Error(`Shape ${shape.name} uses an unsupported array schema. Please contact support`);
+  }
+  const newSchema = "$ref" in schema22 || "@ref" in schema22 ? { allOf: [schema22] } : schema22;
+  return {
+    ...rest,
+    schema: newSchema
+  };
+}
+var migrate5 = async (_, projectSchema) => {
+  const { queries, mutations, shapes, schemaVersion, ...rest } = projectSchema;
+  const migrate25 = migrateQueryToV3_10(projectSchema);
+  return {
+    ...rest,
+    queries: (0, import_mapValues2.default)(queries, migrate25),
+    mutations: (0, import_mapValues2.default)(mutations, migrate25),
+    shapes: (0, import_mapValues2.default)(shapes, migrateShapeToV3_10),
+    schemaVersion: "3.10.0"
+  };
+};
+var v3_10_0_default2 = migrate5;
 
 // ../schema/dist/migration/to/v3.11.0.js
 var import_fromPairs = __toESM(require_fromPairs(), 1);
+var migrate6 = async (context, projectSchema) => {
+  const { decryptFn, encryptFn } = context;
+  const migratedServices = [];
+  for (const [serviceKey, serviceConfig] of Object.entries(projectSchema.services ?? {})) {
+    const { authenticationType, authentication } = serviceConfig;
+    if (authentication && authenticationType !== "unknown" && authenticationType !== "none") {
+      const decrypted = decryptFn(authentication);
+      if (!decrypted) {
+        throw new Error(`Service "${serviceKey}" authentication could not be decrypted. Please contact support.`);
+      }
+      let migrated;
+      if (authenticationType === "searchParams") {
+        migrated = {
+          params: decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "basic") {
+        migrated = {
+          username: "",
+          password: "",
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "bearer") {
+        migrated = {
+          token: "",
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "oauth2Bearer") {
+        migrated = {
+          token: "",
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "oauth2") {
+        migrated = {
+          grantType: "clientCredentials",
+          clientId: "",
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "aws") {
+        migrated = {
+          awsAccessKeyId: "",
+          awsSecretAccessKey: "",
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (authenticationType === "custom") {
+        migrated = {
+          ...decrypted,
+          type: authenticationType
+        };
+      }
+      if (migrated) {
+        const migratedServiceConfig = {
+          ...serviceConfig,
+          authentication: encryptFn(migrated)
+        };
+        migratedServices.push([serviceKey, migratedServiceConfig]);
+      } else {
+        migratedServices.push([serviceKey, serviceConfig]);
+      }
+    } else {
+      migratedServices.push([serviceKey, serviceConfig]);
+    }
+  }
+  return {
+    ...projectSchema,
+    services: (0, import_fromPairs.default)(migratedServices),
+    schemaVersion: "3.11.0"
+  };
+};
+var v3_11_0_default2 = migrate6;
 
 // ../schema/dist/migration/to/v3.12.3.js
 var import_omit9 = __toESM(require_omit(), 1);
+function hasWebhook(projectSchema, config) {
+  const queryName = config.queries?.single?.name;
+  if (!queryName) {
+    return false;
+  }
+  const resolver = projectSchema?.queries[queryName]?.resolver;
+  return resolver && "service" in resolver && projectSchema?.services?.[resolver.service].provider === "shopify";
+}
+var migrate7 = async (_, { indexedShapes: oldIndexedShapes, ...projectSchema }) => {
+  if (!oldIndexedShapes) {
+    return {
+      ...projectSchema,
+      schemaVersion: "3.12.3"
+    };
+  }
+  const indexedShapes = Object.fromEntries(Object.entries(oldIndexedShapes).map(([shapeName14, config]) => {
+    const queries = {};
+    const triggers = [];
+    if (!config.queries) {
+      return [
+        shapeName14,
+        {
+          ...config,
+          queries,
+          triggers
+        }
+      ];
+    }
+    if (hasWebhook(projectSchema, config)) {
+      queries.get = config.queries.single;
+      triggers.push({
+        type: "webhook",
+        query: "get",
+        service: "shopify",
+        events: ["products/create", "products/update", "products/delete"]
+      });
+    }
+    const oldPagination = config.queries.all?.pagination;
+    const pagination = oldPagination === void 0 ? void 0 : oldPagination.type === "cursor" ? {
+      ...oldPagination,
+      itemsToIndexPath: oldPagination.itemsPath,
+      pageSize: oldPagination.size,
+      pageSizeArg: oldPagination.sizeArg
+    } : oldPagination.type === "offset" ? {
+      ...oldPagination,
+      itemsToIndexPath: oldPagination.itemsPath,
+      itemTotalPath: oldPagination.totalPath,
+      offsetArg: oldPagination.offsetParam
+    } : {
+      ...oldPagination,
+      itemsToIndexPath: oldPagination.itemsPath,
+      pageTotalPath: oldPagination.totalPagesPath
+    };
+    queries.list = pagination ? {
+      ...(0, import_omit9.default)(config.queries.all, "interval"),
+      pagination
+    } : (0, import_omit9.default)(config.queries.all, "interval", "pagination");
+    triggers.push({
+      type: "schedule",
+      query: "list",
+      interval: config.queries.all.interval ?? 60 * 24
+    });
+    return [
+      shapeName14,
+      {
+        ...config,
+        queries,
+        triggers
+      }
+    ];
+  }));
+  return {
+    ...projectSchema,
+    schemaVersion: "3.12.3",
+    indexedShapes
+  };
+};
+var v3_12_3_default2 = migrate7;
 
 // ../schema/dist/migration/to/v3.13.0.js
 var import_get8 = __toESM(require_get(), 1);
+var migrate8 = async (_, projectSchema) => {
+  visit3(projectSchema, ["@relationship"], (relationship, path16) => {
+    const parent = (0, import_get8.default)(projectSchema, path16.slice(0, -1));
+    parent["@backreference"] = { enabled: true };
+    if (relationship.relatedName) {
+      parent["@backreference"].name = relationship.relatedName;
+      relationship.relatedName = void 0;
+    }
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.13.0"
+  };
+};
+var v3_13_0_default2 = migrate8;
 
 // ../schema/dist/migration/to/v3.17.0.js
 var import_get9 = __toESM(require_get(), 1);
 var import_omit10 = __toESM(require_omit(), 1);
 var import_set4 = __toESM(require_set2(), 1);
+var migrate9 = async (_, projectSchema) => {
+  visit3(projectSchema, ["@user"], (_2, path16) => {
+    const parentPath = path16.slice(0, -1);
+    const oldSchema = (0, import_get9.default)(projectSchema, parentPath);
+    const newSchema = {
+      ...(0, import_omit10.default)(oldSchema, ["@user", "type"]),
+      "@ref": "local:TSUser",
+      "@input": { type: "string" },
+      "@resolver": { name: "takeshape:getUser", service: "takeshape:local" }
+    };
+    (0, import_set4.default)(projectSchema, parentPath, newSchema);
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.17.0"
+  };
+};
+var v3_17_0_default2 = migrate9;
 
 // ../schema/dist/migration/to/v3.18.0.js
 var import_get10 = __toESM(require_get(), 1);
 var import_omit11 = __toESM(require_omit(), 1);
 var import_set5 = __toESM(require_set2(), 1);
+var migrate10 = async (_, projectSchema) => {
+  visit3(projectSchema, ["@relationship"], (relationship, path16) => {
+    const propertyPath = path16.slice(0, -1);
+    const originalPropertySchema = (0, import_get10.default)(projectSchema, propertyPath);
+    const propertySchema2 = (0, import_omit11.default)(originalPropertySchema, ["@relationship", "type", "$ref"]);
+    const shapeIdMap = new Map(Object.values(projectSchema.shapes).map((shape) => [shape.id, shape]));
+    const shapeIdsToShapeRefs = (shapeIds) => {
+      return shapeIds.map((shapeId5) => {
+        let shape;
+        if (shapeId5 === "ASSET") {
+          shape = { name: "Asset" };
+        } else {
+          shape = shapeIdMap.get(shapeId5);
+        }
+        if (!shape) {
+          return;
+        }
+        return {
+          "@ref": `local:${shape.name}`
+        };
+      }).filter(isDefined);
+    };
+    const shapeRefs = shapeIdsToShapeRefs(relationship.shapeIds);
+    const shapeRefsSchema = shapeRefs.length === 1 ? shapeRefs[0] : { oneOf: shapeRefs };
+    if (relationship.type === "multiple") {
+      propertySchema2.type = "array";
+      propertySchema2.items = shapeRefsSchema;
+      propertySchema2["@input"] = {
+        type: "array",
+        items: {
+          "@ref": "local:TSRelationship"
+        }
+      };
+    } else {
+      propertySchema2.type = void 0;
+      Object.assign(propertySchema2, shapeRefsSchema);
+      propertySchema2["@input"] = {
+        "@ref": "local:TSRelationship"
+      };
+    }
+    propertySchema2["@args"] = "TSRelationshipArgs";
+    propertySchema2["@resolver"] = {
+      name: "takeshape:getRelated",
+      service: "takeshape:local",
+      options: {
+        nullable: true
+      }
+    };
+    (0, import_set5.default)(projectSchema, propertyPath, propertySchema2);
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.18.0"
+  };
+};
+var v3_18_0_default2 = migrate10;
 
 // ../schema/dist/migration/to/v3.18.1.js
 var import_pick3 = __toESM(require_pick2(), 1);
 var import_mapValues3 = __toESM(require_mapValues(), 1);
 var pruneQuery = (0, import_pick3.default)(["args", "resolver", "shape", "description"]);
+var migrate11 = async (_, projectSchema) => {
+  return {
+    ...projectSchema,
+    queries: (0, import_mapValues3.default)(projectSchema.queries, pruneQuery),
+    mutations: (0, import_mapValues3.default)(projectSchema.mutations, pruneQuery),
+    schemaVersion: "3.18.1"
+  };
+};
+var v3_18_1_default2 = migrate11;
 
 // ../schema/dist/migration/to/v3.18.2.js
 var import_mapValues4 = __toESM(require_mapValues(), 1);
+function updateGenericServices(projectSchema) {
+  if (projectSchema.services) {
+    return {
+      ...projectSchema,
+      services: (0, import_mapValues4.default)(projectSchema.services, (serviceConfig) => (
+        // generic provider has been renamed to match service type
+        serviceConfig.provider === "generic" ? { ...serviceConfig, provider: serviceConfig.serviceType } : serviceConfig
+      ))
+    };
+  }
+  return projectSchema;
+}
+var migrate12 = async (_, projectSchema) => {
+  return {
+    ...updateGenericServices(projectSchema),
+    schemaVersion: "3.18.2"
+  };
+};
+var v3_18_2_default2 = migrate12;
 
 // ../schema/dist/migration/to/v3.20.0.js
 var import_mapValues5 = __toESM(require_mapValues(), 1);
+function updateGenericServices2(projectSchema) {
+  if (projectSchema.services) {
+    return {
+      ...projectSchema,
+      services: (0, import_mapValues5.default)(projectSchema.services, (serviceConfig) => (
+        // generic provider has been renamed to match service type
+        serviceConfig.provider === "shopify" ? {
+          ...serviceConfig,
+          options: { ...serviceConfig.options, legacyApp: true }
+        } : serviceConfig
+      ))
+    };
+  }
+  return projectSchema;
+}
+var migrate13 = async (_, projectSchema) => {
+  return {
+    ...updateGenericServices2(projectSchema),
+    schemaVersion: "3.20.0"
+  };
+};
+var v3_20_0_default2 = migrate13;
 
 // ../schema/dist/migration/to/v3.22.0.js
 var import_mapValues6 = __toESM(require_mapValues(), 1);
 var import_omit12 = __toESM(require_omit(), 1);
+var migrate14 = async (_, projectSchema) => {
+  const { indexedShapes, ...rest } = projectSchema;
+  const migrated = {
+    ...rest,
+    schemaVersion: "3.22.0"
+  };
+  if (indexedShapes) {
+    migrated.indexedShapes = (0, import_mapValues6.default)(indexedShapes, (indexedShape) => {
+      const { ignoreFields, objectDepthLimit } = indexedShape.queries.list ?? indexedShape.queries.get ?? {};
+      return {
+        ...indexedShape,
+        query: {
+          ignoreFields,
+          maxDepth: objectDepthLimit
+        },
+        queries: (0, import_mapValues6.default)(indexedShape.queries, (config) => config && (0, import_omit12.default)(config, ["ignoreFields", "objectDepthLimit"]))
+      };
+    });
+  }
+  return migrated;
+};
+var v3_22_0_default2 = migrate14;
+
+// ../schema/dist/migration/to/v3.24.0.js
+var migrate15 = async (_, projectSchema) => {
+  const { updated, created, version, ...migrated } = projectSchema;
+  return {
+    ...migrated,
+    schemaVersion: "3.24.0"
+  };
+};
+var v3_24_0_default2 = migrate15;
+
+// ../schema/dist/migration/to/v3.25.0.js
+var migrate16 = async (_, projectSchema) => {
+  const { dataKey, ...migrated } = projectSchema;
+  return {
+    ...migrated,
+    schemaVersion: "3.25.0"
+  };
+};
+var v3_25_0_default2 = migrate16;
 
 // ../schema/dist/migration/to/v3.31.0.js
 var import_isString7 = __toESM(require_isString(), 1);
 var import_last2 = __toESM(require_last(), 1);
 var import_set6 = __toESM(require_set2(), 1);
 var import_unset3 = __toESM(require_unset(), 1);
+var TAKESHAPE_RESOLVERS = ["takeshape:getUser", "takeshape:search", "takeshape:queryApiIndex", "util:wrap"];
+function getServicePath(path16) {
+  const servicePath = [...path16];
+  servicePath.splice(-1, 1, "service");
+  return servicePath;
+}
+var migrate17 = async (_, projectSchema) => {
+  visit3(projectSchema, ["@ref", "@mapping", "name"], (value2, path16) => {
+    if ((0, import_isString7.default)(value2)) {
+      const name = (0, import_last2.default)(path16);
+      if (name === "name" && value2 === "debug:noop") {
+        (0, import_set6.default)(projectSchema, path16, "util:noop");
+        (0, import_unset3.default)(projectSchema, getServicePath(path16));
+      } else if (name === "name" && value2 === "util:wrap") {
+        (0, import_unset3.default)(projectSchema, getServicePath(path16));
+      } else if (name === "name" && value2.startsWith("takeshape:")) {
+        const serviceName = TAKESHAPE_RESOLVERS.includes(value2) ? "takeshape" : "shapedb";
+        (0, import_set6.default)(projectSchema, getServicePath(path16), serviceName);
+        (0, import_set6.default)(projectSchema, path16, value2.replace("takeshape:", `${serviceName}:`));
+      } else {
+        (0, import_set6.default)(projectSchema, path16, value2.replace("takeshape:local", "shapedb"));
+      }
+    }
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.31.0"
+  };
+};
+var v3_31_0_default2 = migrate17;
+
+// ../schema/dist/migration/to/v3.32.0.js
+function migrateListQuery(listConfig) {
+  const { pagination, name, ...restConfig } = listConfig;
+  const result = { ...restConfig, query: name };
+  if (pagination) {
+    const { itemsToIndexPath, ...restPagination } = pagination;
+    result.pagination = { ...restPagination, itemsPath: itemsToIndexPath };
+  }
+  return result;
+}
+function queriesToLoaders(queries) {
+  if (queries.list) {
+    const loaders = {
+      list: Array.isArray(queries.list) ? queries.list.map(migrateListQuery) : migrateListQuery(queries.list)
+    };
+    if (queries.get) {
+      const { name, ...restGet } = queries.get;
+      loaders.get = { ...restGet, query: name };
+    }
+    return loaders;
+  }
+}
+function migrateTrigger(trigger) {
+  const { query, ...rest } = trigger;
+  return { ...rest, loader: query };
+}
+var migrate18 = async (_, projectSchema) => {
+  const updatedShapes = { ...projectSchema.shapes };
+  const { indexedShapes, ...rest } = projectSchema;
+  if (indexedShapes) {
+    for (const [name, config] of Object.entries(indexedShapes)) {
+      let shape = updatedShapes[name];
+      shape ||= {
+        name,
+        id: name,
+        title: name,
+        schema: {
+          extends: [{ "@ref": normalizeRefExpression(projectSchema, name) }]
+        }
+      };
+      const loaders = queriesToLoaders(config.queries);
+      if (loaders) {
+        shape.loaders = loaders;
+      }
+      shape.cache = {
+        enabled: true,
+        fragment: config.query,
+        triggers: config.triggers.map(migrateTrigger)
+      };
+      updatedShapes[name] = shape;
+    }
+  }
+  return {
+    ...rest,
+    shapes: updatedShapes,
+    schemaVersion: "3.32.0"
+  };
+};
+var v3_32_0_default2 = migrate18;
 
 // ../schema/dist/migration/to/v3.34.0.js
 var import_set7 = __toESM(require_set3(), 1);
@@ -398892,12 +399902,271 @@ function createServiceConfigValidator() {
   });
 }
 var serviceConfigValidator = createServiceConfigValidator();
+function getServiceObjectFields(projectSchema, shape, provider) {
+  return (getServiceInfo(projectSchema, shape)[provider] ?? []).filter((serviceInfo) => serviceInfo.generators[SERVICE_OBJECT_PATTERN_NAME]);
+}
+function getServiceInfo(projectSchema, shape) {
+  const result = {};
+  const inlineDepShapes = getShapeDependencies(projectSchema, shape, (prop) => !prop["@resolver"]).map((name) => projectSchema.shapes[name]);
+  const shapesToCheck = [shape, ...inlineDepShapes];
+  for (const thisShape of shapesToCheck) {
+    createSchemaPropertyList(projectSchema, thisShape).forEach(([key, value2]) => {
+      const resolver = value2["@resolver"];
+      if (!isServiceResolver(resolver)) {
+        return;
+      }
+      const serviceConfig = getStoredServiceConfig(projectSchema, resolver.service);
+      if (!serviceConfig) {
+        return;
+      }
+      const { provider } = serviceConfig;
+      const generators = {};
+      const tag3 = value2["@tag"];
+      if (tag3?.startsWith(SERVICE_OBJECT_PATTERN_NAME)) {
+        const idFieldName = getServiceIdFieldName(key);
+        const version = tag3.substr(Number(tag3.lastIndexOf(":")) + 1);
+        generators[SERVICE_OBJECT_PATTERN_NAME] = {
+          version,
+          currentVersion: getGeneratorVersion(SERVICE_OBJECT_PATTERN_NAME),
+          idFieldName,
+          serviceObjectType: resolver.fieldName
+        };
+      }
+      const serviceInfo = {
+        service: resolver.service,
+        fieldName: key,
+        path: pathBetween(shape, thisShape, projectSchema),
+        generators
+      };
+      if (Array.isArray(result[provider])) {
+        if (!result[provider].find((existingServiceInfo) => (0, import_isEqual2.default)(existingServiceInfo, serviceInfo))) {
+          result[provider].push(serviceInfo);
+        }
+      } else {
+        result[provider] = [serviceInfo];
+      }
+    });
+  }
+  return result;
+}
+
+// ../schema/dist/migration/to/v3.34.0.js
+var widgetMigrations = {
+  object: "shapeObject",
+  repeater: "shapeArray"
+};
+function normalizeForms(projectSchema) {
+  const normalizedForms = {};
+  const { forms = {} } = projectSchema;
+  const storeSourceForm = (shapeName14, formConfig, propName) => {
+    normalizedForms[shapeName14] ||= { default: deepClone(formConfig) };
+    const propConfig = normalizedForms[shapeName14].default.properties[propName];
+    propConfig.properties = void 0;
+    propConfig.order = void 0;
+    propConfig.widget = widgetMigrations[propConfig.widget] ?? propConfig.widget;
+  };
+  const normalizeNested = (shapeName14, formConfig) => {
+    const shape = projectSchema.shapes[shapeName14];
+    if (!shape || !formConfig.properties) {
+      return;
+    }
+    const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
+    for (const propName of Object.keys(formConfig.properties)) {
+      const propConfig = formConfig.properties[propName];
+      const propSchema = propertyAccessor.getValue(propName);
+      if (propSchema) {
+        const ref = getRefOrItemsRef(projectSchema, propSchema);
+        if (ref && propConfig.properties && propConfig.widget !== "shopify") {
+          const nestedShapeName = refItemToNamespacedShapeName(projectSchema, ref);
+          normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
+          storeSourceForm(shapeName14, formConfig, propName);
+          normalizeNested(nestedShapeName, propConfig);
+        }
+      }
+    }
+  };
+  if (forms) {
+    for (const shapeName14 of Object.keys(forms)) {
+      normalizeNested(shapeName14, forms[shapeName14].default);
+      normalizedForms[shapeName14] ||= forms[shapeName14];
+    }
+  }
+  return normalizedForms;
+}
+function migrateInterfaceShapes(projectSchema) {
+  let updatedProjectSchema = projectSchema;
+  for (const shape of Object.values(projectSchema.shapes)) {
+    if (!shape.model) {
+      continue;
+    }
+    const serviceObjectFields = getServiceObjectFields({ ...projectSchema, schemaVersion: CURRENT_SCHEMA_VERSION }, shape, "shopify");
+    for (const field of serviceObjectFields) {
+      const { fieldName, service } = field;
+      const { serviceObjectType } = field.generators[SERVICE_OBJECT_PATTERN_NAME];
+      const serviceShapeName = (0, import_upperFirst3.default)(serviceObjectType);
+      const interfaceShapeName = `${serviceShapeName}Interface`;
+      updatedProjectSchema = (0, import_unset4.default)(["shapes", interfaceShapeName], updatedProjectSchema);
+      if ("type" in shape.schema && shape.schema.type === "object") {
+        const prop = shape.schema.properties[fieldName];
+        if (prop) {
+          updatedProjectSchema = (0, import_set7.default)(["shapes", shape.name, "schema", "properties", fieldName, "@input"], { "@ref": `${service}:${serviceShapeName}Input` }, updatedProjectSchema);
+        }
+      }
+      for (const [mutationName, mutation] of Object.entries(projectSchema.mutations)) {
+        if (!mutation || typeof mutation.args !== "string") {
+          continue;
+        }
+        for (const template of ["CreateArgs", "UpdateArgs"]) {
+          if (mutation.args === `${template}<${interfaceShapeName}>`) {
+            updatedProjectSchema = (0, import_set7.default)(["mutations", mutationName], { ...mutation, args: `${template}<${serviceShapeName}>` }, updatedProjectSchema);
+          }
+        }
+      }
+    }
+  }
+  return updatedProjectSchema;
+}
+var migrate19 = async (_, projectSchema) => {
+  let normalized = projectSchema;
+  try {
+    normalized = {
+      ...projectSchema,
+      forms: normalizeForms(projectSchema)
+    };
+  } catch (e2) {
+    console.info("v3.34.0 migration warning: Failed to normalize forms", e2.message);
+  }
+  try {
+    normalized = migrateInterfaceShapes(normalized);
+  } catch (e2) {
+    console.info("v3.34.0 migration warning: Failed to migrate interface shapes", e2.message);
+  }
+  return {
+    ...normalized,
+    schemaVersion: "3.34.0"
+  };
+};
+var v3_34_0_default2 = migrate19;
 
 // ../schema/dist/migration/to/v3.36.0.js
 var import_mapValues7 = __toESM(require_mapValues(), 1);
+var migrate20 = async (_, projectSchema) => {
+  const result = {
+    ...projectSchema,
+    schemaVersion: "3.36.0"
+  };
+  result.services &&= (0, import_mapValues7.default)(result.services, (config) => {
+    if (config.serviceType === "openapi") {
+      return {
+        ...config,
+        options: {
+          ...config.options,
+          transformVersion: "1.0.0"
+        }
+      };
+    }
+    return config;
+  });
+  return result;
+};
+var v3_36_0_default2 = migrate20;
+
+// ../schema/dist/migration/to/v3.39.0.js
+var migrate21 = async ({ decryptFn, encryptFn }, projectSchema) => {
+  for (const serviceConfig of Object.values(projectSchema.services ?? {})) {
+    if (serviceConfig.authentication) {
+      const authentication = decryptFn(serviceConfig.authentication);
+      if (isServiceAuthentication(authentication) && isSearchParamsAuthentication(authentication)) {
+        if (serviceConfig.provider === "judgeMe") {
+          const shopDomain = authentication.params.find((param) => param.name === "shop_domain");
+          if (shopDomain) {
+            serviceConfig.options = {
+              ...serviceConfig.options,
+              searchParams: {
+                shop_domain: shopDomain.value
+              }
+            };
+            serviceConfig.options.shopDomain = void 0;
+          }
+          authentication.params = authentication.params.filter((param) => param.name !== "shop_domain");
+        }
+        if (serviceConfig.provider === "reviewsIo") {
+          const storeId = authentication.params.find((param) => param.name === "store");
+          if (storeId) {
+            serviceConfig.options = {
+              ...serviceConfig.options,
+              searchParams: {
+                store: storeId.value
+              }
+            };
+            serviceConfig.options.storeId = void 0;
+          }
+          authentication.params = authentication.params.filter((param) => param.name !== "store");
+        }
+        serviceConfig.authentication = encryptFn(authentication);
+      }
+    }
+  }
+  return {
+    ...projectSchema,
+    schemaVersion: "3.39.0"
+  };
+};
+var v3_39_0_default2 = migrate21;
 
 // ../schema/dist/migration/to/v3.40.0.js
 var import_mapValues8 = __toESM(require_mapValues(), 1);
+var migrate22 = async (_, projectSchema) => {
+  const newShapes = (0, import_mapValues8.default)(projectSchema.shapes, (shape) => {
+    if (shape.cache?.fragment?.maxDepth !== void 0) {
+      const newShape = {
+        ...shape,
+        cache: {
+          ...shape.cache,
+          fragment: {
+            ...shape.cache.fragment,
+            includeDeprecated: true
+          }
+        }
+      };
+      return newShape;
+    }
+    return shape;
+  });
+  return {
+    ...projectSchema,
+    shapes: newShapes,
+    schemaVersion: "3.40.0"
+  };
+};
+var v3_40_0_default2 = migrate22;
+
+// ../schema/dist/migration/to/v3.46.0.js
+function isBasicResolver2(resolver) {
+  return isRecord(resolver) && typeof resolver.name === "string";
+}
+function isComposeResolver2(resolver) {
+  return Boolean(isRecord(resolver) && Array.isArray(resolver.compose) && resolver.compose.length && resolver.compose.every(isBasicResolver2));
+}
+function renameResolver(resolver) {
+  if (resolver.name === "ai:generateText" && (resolver.options?.history ?? true)) {
+    resolver.name = "ai:chat";
+  }
+}
+var migrate23 = async (_, projectSchema) => {
+  visit3(projectSchema, ["resolver", "@resolver"], (maybeResolver) => {
+    if (isComposeResolver2(maybeResolver)) {
+      maybeResolver.compose.forEach(renameResolver);
+    } else if (isBasicResolver2(maybeResolver)) {
+      renameResolver(maybeResolver);
+    }
+  });
+  return {
+    ...projectSchema,
+    schemaVersion: "3.46.0"
+  };
+};
+var v3_46_0_default2 = migrate23;
 
 // ../../node_modules/.pnpm/jsonpath-plus@10.0.1/node_modules/jsonpath-plus/dist/index-node-esm.js
 var import_vm = __toESM(require("vm"), 1);
@@ -403477,7 +404746,103 @@ function validateProjectSchemaImport(maybeSchema) {
   });
 }
 
+// ../schema/dist/migration/to/v3.57.0.js
+var migrate24 = async (context, projectSchema) => {
+  const { ["ai-experimental"]: ai, ...rest } = projectSchema;
+  const migrated = {
+    ...rest,
+    schemaVersion: "3.57.0"
+  };
+  if (ai) {
+    const migratedWithAi = Object.assign({ ...migrated }, ai);
+    const { valid } = await validateSchema({ ignoreEntitlements: true, structureOnly: true }, migratedWithAi);
+    if (valid) {
+      return migratedWithAi;
+    }
+    context.logger.warn(`Dropping "ai-experimental" properties schema for project "${projectSchema.projectId}".`);
+  }
+  return migrated;
+};
+var v3_57_0_default2 = migrate24;
+
 // ../schema/dist/migration/index.js
+function getNoopMigration(_from, to) {
+  return async (_context, projectSchema) => {
+    return {
+      ...projectSchema,
+      schemaVersion: to
+    };
+  };
+}
+var migrateTo = {
+  "v3.0.0": v3_0_0_default2,
+  "v3.1.0": v3_1_0_default2,
+  "v3.2.0": getNoopMigration("3.1.0", "3.2.0"),
+  "v3.3.0": v3_3_0_default2,
+  "v3.4.0": getNoopMigration("3.3.0", "3.4.0"),
+  "v3.5.0": getNoopMigration("3.4.0", "3.5.0"),
+  "v3.5.1": getNoopMigration("3.5.0", "3.5.1"),
+  "v3.6.0": getNoopMigration("3.5.1", "3.6.0"),
+  "v3.7.0": getNoopMigration("3.6.0", "3.7.0"),
+  "v3.8.0": getNoopMigration("3.7.0", "3.8.0"),
+  "v3.9.0": v3_9_0_default2,
+  "v3.10.0": v3_10_0_default2,
+  "v3.11.0": v3_11_0_default2,
+  "v3.12.0": getNoopMigration("3.11.0", "3.12.0"),
+  "v3.12.1": getNoopMigration("3.12.0", "3.12.1"),
+  "v3.12.2": getNoopMigration("3.12.1", "3.12.2"),
+  "v3.12.3": v3_12_3_default2,
+  "v3.13.0": v3_13_0_default2,
+  "v3.14.0": getNoopMigration("3.13.0", "3.14.0"),
+  "v3.15.0": getNoopMigration("3.14.0", "3.15.0"),
+  "v3.16.0": getNoopMigration("3.15.0", "3.16.0"),
+  "v3.17.0": v3_17_0_default2,
+  "v3.17.1": getNoopMigration("3.17.0", "3.17.1"),
+  "v3.18.0": v3_18_0_default2,
+  "v3.18.1": v3_18_1_default2,
+  "v3.18.2": v3_18_2_default2,
+  "v3.19.0": getNoopMigration("3.18.2", "3.19.0"),
+  "v3.20.0": v3_20_0_default2,
+  "v3.21.0": getNoopMigration("3.20.0", "3.21.0"),
+  "v3.22.0": v3_22_0_default2,
+  "v3.23.0": getNoopMigration("3.22.0", "3.23.0"),
+  "v3.24.0": v3_24_0_default2,
+  "v3.25.0": v3_25_0_default2,
+  "v3.26.0": getNoopMigration("3.25.0", "3.26.0"),
+  "v3.27.0": getNoopMigration("3.26.0", "3.27.0"),
+  "v3.28.0": getNoopMigration("3.27.0", "3.28.0"),
+  "v3.29.0": getNoopMigration("3.28.0", "3.29.0"),
+  "v3.30.0": getNoopMigration("3.29.0", "3.30.0"),
+  "v3.31.0": v3_31_0_default2,
+  "v3.32.0": v3_32_0_default2,
+  "v3.33.0": getNoopMigration("3.32.0", "3.33.0"),
+  "v3.34.0": v3_34_0_default2,
+  "v3.35.0": getNoopMigration("3.34.0", "3.35.0"),
+  "v3.36.0": v3_36_0_default2,
+  "v3.37.0": getNoopMigration("3.36.0", "3.37.0"),
+  "v3.38.0": getNoopMigration("3.37.0", "3.38.0"),
+  "v3.39.0": v3_39_0_default2,
+  "v3.40.0": v3_40_0_default2,
+  "v3.41.0": getNoopMigration("3.40.0", "3.41.0"),
+  "v3.42.0": getNoopMigration("3.41.0", "3.42.0"),
+  "v3.43.0": getNoopMigration("3.42.0", "3.43.0"),
+  "v3.44.0": getNoopMigration("3.43.0", "3.44.0"),
+  "v3.45.0": getNoopMigration("3.44.0", "3.45.0"),
+  "v3.46.0": v3_46_0_default2,
+  "v3.47.0": getNoopMigration("3.46.0", "3.47.0"),
+  "v3.48.0": getNoopMigration("3.47.0", "3.48.0"),
+  "v3.49.0": getNoopMigration("3.48.0", "3.49.0"),
+  "v3.50.0": getNoopMigration("3.49.0", "3.50.0"),
+  "v3.51.0": getNoopMigration("3.50.0", "3.51.0"),
+  "v3.52.0": getNoopMigration("3.51.0", "3.52.0"),
+  "v3.53.0": getNoopMigration("3.52.0", "3.53.0"),
+  "v3.54.0": getNoopMigration("3.53.0", "3.54.0"),
+  "v3.55.0": getNoopMigration("3.54.0", "3.55.0"),
+  "v3.56.0": getNoopMigration("3.55.0", "3.56.0"),
+  "v3.57.0": v3_57_0_default2,
+  "v3.58.0": getNoopMigration("3.57.0", "3.58.0"),
+  "v3.59.0": getNoopMigration("3.58.0", "3.59.0")
+};
 var listTypePrefix = "PaginatedList";
 
 // ../schema/dist/template-shapes/types.js