@sanity/schema 5.0.0-next-major.20251216101132 → 5.0.0-next-major.20251216102111

package/lib/_internal.d.ts

@@ -233,19 +233,6 @@ export declare class DescriptorConverter {
   ): Promise<SetSynchronization<RegistryType>>
 }
 
-/**
- * Extracts a GROQ-compatible schema from a Sanity schema definition. The extraction happens in three passes:
- *
- * 1. **Dependency analysis & hoisting detection** (`sortByDependencies`): Walks the entire schema to sort
- *    types topologically and identifies inline object fields that are used multiple times (candidates
- *    for "hoisting").
- *
- * 2. **Hoisted type creation**: For any repeated inline fields, we create top-level named type definitions
- *    first, so they exist before being referenced.
- *
- * 3. **Main type conversion**: Processes each schema type in dependency order. When a field was marked for
- *    hoisting, we emit an `inline` reference to the hoisted type instead of duplicating the structure.
- */
 export declare function extractSchema(
   schemaDef: Schema,
   extractOptions?: ExtractSchemaOptions,

package/lib/_internal.js

@@ -2314,32 +2314,15 @@ const documentDefaultFields = (typeName) => ({
   ["email", { type: "string" }]
 ]);
 function extractSchema(schemaDef, extractOptions = {}) {
-  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], generatedTypes = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
-  repeated.forEach((key, objectField) => {
-    const base = convertSchemaType(objectField.type);
-    if (base !== null) {
-      if (base.type === "inline") {
-        repeated.delete(objectField);
-        return;
-      }
-      if (base.type === "unknown") {
-        repeated.delete(objectField);
-        return;
-      }
-      schema.push({
-        type: "type",
-        name: getGeneratedTypeName(key),
-        value: base
-      });
-    }
-  }), sortedSchemaTypeNames.forEach((typeName) => {
+  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], generatedTypes = /* @__PURE__ */ new Map(), sortedSchemaTypeNames = sortByDependencies(schemaDef);
+  sortedSchemaTypeNames.forEach((typeName) => {
     const schemaType = schemaDef.get(typeName);
     if (schemaType === void 0)
       return;
     const base = convertBaseType(schemaType);
     base !== null && (base.type === "type" && inlineFields.add(schemaType), base.type === "document" && documentTypes.set(typeName, base), schema.push(base));
   });
-  function getGeneratedTypeName(typeName, suffix = "") {
+  function getGeneratedTypeName(typeName, suffix) {
     const name = generatedTypes.get(typeName);
     if (name) return name;
     for (let i = 0; i < 5; i++) {
@@ -2412,19 +2395,10 @@ function extractSchema(schemaDef, extractOptions = {}) {
   function createObject(schemaType) {
     const attributes = {}, fields = gatherFields(schemaType);
     for (const field of fields) {
-      const fieldIsRequired = isFieldRequired(field?.type?.validation);
-      let value;
-      const hoisted = repeated.get(field), isTopLevelSchemaType = sortedSchemaTypeNames.includes(field.type.name);
-      if (hoisted && !isTopLevelSchemaType)
-        value = {
-          type: "inline",
-          name: getGeneratedTypeName(hoisted)
-        };
-      else {
-        if (value = convertSchemaType(field.type), value === null)
-          continue;
-        hasAssetRequired(field?.type?.validation) && value.type === "object" && (value.attributes.asset.optional = !1);
-      }
+      const fieldIsRequired = isFieldRequired(field?.type?.validation), value = convertSchemaType(field.type);
+      if (value === null)
+        continue;
+      hasAssetRequired(field?.type?.validation) && value.type === "object" && (value.attributes.asset.optional = !1);
       const optional = extractOptions.enforceRequiredFields ? fieldIsRequired === !1 : !0;
       attributes[field.name] = {
         type: "objectAttribute",
@@ -2602,16 +2576,8 @@ function lastType(typeDef) {
   }
 }
 function sortByDependencies(compiledSchema) {
-  const seen = /* @__PURE__ */ new Set(), objectMap = /* @__PURE__ */ new Set(), repeated = /* @__PURE__ */ new Map(), repeatedNames = /* @__PURE__ */ new Set();
-  function pickRepeatedName(path) {
-    for (let idx = path.length - 1; idx >= 0; idx--) {
-      const name = path.slice(idx).join(".");
-      if (!repeatedNames.has(name))
-        return repeatedNames.add(name), name;
-    }
-    throw new Error(`Unable to pick repeated name: ${path.join(".")}`);
-  }
-  function walkDependencies(schemaType, dependencies, path, hoistRepetitions = !0) {
+  const seen = /* @__PURE__ */ new Set();
+  function walkDependencies(schemaType, dependencies) {
     if (!seen.has(schemaType)) {
       if (seen.add(schemaType), "fields" in schemaType)
         for (const field of gatherFields(schemaType)) {
@@ -2621,19 +2587,11 @@ function sortByDependencies(compiledSchema) {
             continue;
           }
           let schemaTypeName;
-          if (schemaType.type.type ? schemaTypeName = field.type.type.name : "jsonType" in schemaType.type && (schemaTypeName = field.type.jsonType), schemaTypeName === "object" || schemaTypeName === "block") {
-            if (isReferenceType(field.type))
-              field.type.to.forEach((ref) => dependencies.add(ref.type));
-            else if (dependencies.add(field.type), hoistRepetitions && !validSchemaNames.has(field.type.name)) {
-              const fieldPath = path.concat([field.name]);
-              !repeated.has(field) && objectMap.has(field) && repeated.set(field, pickRepeatedName(fieldPath)), objectMap.add(field);
-            }
-          } else field.type && dependencies.add(field.type);
-          walkDependencies(field.type, dependencies, path.concat([field.name]));
+          schemaType.type.type ? schemaTypeName = field.type.type.name : "jsonType" in schemaType.type && (schemaTypeName = field.type.jsonType), schemaTypeName === "object" || schemaTypeName === "block" ? isReferenceType(field.type) ? field.type.to.forEach((ref) => dependencies.add(ref.type)) : dependencies.add(field.type) : field.type && dependencies.add(field.type), walkDependencies(field.type, dependencies);
         }
       else if ("of" in schemaType)
         for (const item of schemaType.of)
-          walkDependencies(item, dependencies, path.concat(item.name), !isReferenceType(schemaType));
+          walkDependencies(item, dependencies);
     }
   }
   const dependencyMap = /* @__PURE__ */ new Map(), schemaTypeNames = compiledSchema.getTypeNames(), validSchemaNames = /* @__PURE__ */ new Set();
@@ -2643,7 +2601,7 @@ function sortByDependencies(compiledSchema) {
       return;
     validSchemaNames.add(typeName);
     const dependencies = /* @__PURE__ */ new Set();
-    walkDependencies(schemaType, dependencies, [typeName]), dependencyMap.set(schemaType, dependencies), seen.clear();
+    walkDependencies(schemaType, dependencies), dependencyMap.set(schemaType, dependencies), seen.clear();
   });
   const typeNames = [], currentlyVisiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
   function visit(type) {
@@ -2655,10 +2613,7 @@ function sortByDependencies(compiledSchema) {
   }
   for (const [type] of dependencyMap)
     visit(type);
-  return {
-    sortedSchemaTypeNames: typeNames.filter((typeName) => validSchemaNames.has(typeName)),
-    repeated
-  };
+  return typeNames.filter((typeName) => validSchemaNames.has(typeName));
 }
 function validateNoCallbacks(typeDef) {
   const problems = [];