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

package/lib/_internal.d.ts

@@ -233,6 +233,19 @@ 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,15 +2314,32 @@ 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 = sortByDependencies(schemaDef);
-  sortedSchemaTypeNames.forEach((typeName) => {
+  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 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++) {
@@ -2395,10 +2412,19 @@ function extractSchema(schemaDef, extractOptions = {}) {
   function createObject(schemaType) {
     const attributes = {}, fields = gatherFields(schemaType);
     for (const field of fields) {
-      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 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 optional = extractOptions.enforceRequiredFields ? fieldIsRequired === !1 : !0;
       attributes[field.name] = {
         type: "objectAttribute",
@@ -2576,8 +2602,16 @@ function lastType(typeDef) {
   }
 }
 function sortByDependencies(compiledSchema) {
-  const seen = /* @__PURE__ */ new Set();
-  function walkDependencies(schemaType, dependencies) {
+  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) {
     if (!seen.has(schemaType)) {
       if (seen.add(schemaType), "fields" in schemaType)
         for (const field of gatherFields(schemaType)) {
@@ -2587,11 +2621,19 @@ function sortByDependencies(compiledSchema) {
             continue;
           }
           let schemaTypeName;
-          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);
+          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]));
         }
       else if ("of" in schemaType)
         for (const item of schemaType.of)
-          walkDependencies(item, dependencies);
+          walkDependencies(item, dependencies, path.concat(item.name), !isReferenceType(schemaType));
     }
   }
   const dependencyMap = /* @__PURE__ */ new Map(), schemaTypeNames = compiledSchema.getTypeNames(), validSchemaNames = /* @__PURE__ */ new Set();
@@ -2601,7 +2643,7 @@ function sortByDependencies(compiledSchema) {
       return;
     validSchemaNames.add(typeName);
     const dependencies = /* @__PURE__ */ new Set();
-    walkDependencies(schemaType, dependencies), dependencyMap.set(schemaType, dependencies), seen.clear();
+    walkDependencies(schemaType, dependencies, [typeName]), dependencyMap.set(schemaType, dependencies), seen.clear();
   });
   const typeNames = [], currentlyVisiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
   function visit(type) {
@@ -2613,7 +2655,10 @@ function sortByDependencies(compiledSchema) {
   }
   for (const [type] of dependencyMap)
     visit(type);
-  return typeNames.filter((typeName) => validSchemaNames.has(typeName));
+  return {
+    sortedSchemaTypeNames: typeNames.filter((typeName) => validSchemaNames.has(typeName)),
+    repeated
+  };
 }
 function validateNoCallbacks(typeDef) {
   const problems = [];