@riverbankcms/sdk 0.77.1 → 0.78.2

package/dist/server/config-template-validation.mjs

@@ -6,6 +6,24 @@ var TEMPLATE_BINDING_TRANSFORMS = {
 };
 
 // ../content-model/src/templates/bindingTypeCompatibility.ts
+var SCALAR_BLOCK_FIELD_TYPES = [
+  "text",
+  "number",
+  "slug",
+  "url",
+  "richText",
+  "media",
+  "file",
+  "boolean",
+  "select",
+  "reference",
+  "link",
+  "date",
+  "datetime"
+];
+function isScalarBlockFieldType(type) {
+  return SCALAR_BLOCK_FIELD_TYPES.includes(type);
+}
 var CONTENT_TO_BLOCK_COMPATIBILITY = {
   // Simple text fields
   text: ["text", "slug", "url"],
@@ -36,7 +54,7 @@ var CONTENT_TO_BLOCK_COMPATIBILITY = {
   // Group fields (nested structure - not directly bindable)
   group: [],
   // Repeater fields (list structure - not directly bindable)
-  repeater: [],
+  repeater: ["repeater"],
   // Datetime fields can map to datetime/date inputs or text display fields.
   datetime: ["datetime", "date", "text"]
 };
@@ -80,6 +98,9 @@ var NESTED_PATH_COMPATIBILITY = {
   "file.filename": ["text"]
 };
 function isCompatibleBinding(sourceType, targetType) {
+  if (targetType === "repeater") {
+    return sourceType === "repeater";
+  }
   const compatibleTypes = CONTENT_TO_BLOCK_COMPATIBILITY[sourceType];
   if (compatibleTypes) {
     return compatibleTypes.includes(targetType);
@@ -87,11 +108,13 @@ function isCompatibleBinding(sourceType, targetType) {
   return false;
 }
 function isCompatibleMetaBinding(metaFieldName, targetType) {
+  if (targetType === "repeater") return false;
   if (!isMetaFieldPath(metaFieldName)) return false;
   const compatibleTypes = META_FIELD_COMPATIBILITY[metaFieldName];
   return compatibleTypes.includes(targetType);
 }
 function isCompatibleNestedPath(parentType, nestedSuffix, targetType) {
+  if (targetType === "repeater") return false;
   const pathKey = `${parentType}.${nestedSuffix}`;
   const compatibleTypes = NESTED_PATH_COMPATIBILITY[pathKey];
   if (compatibleTypes) {
@@ -223,10 +246,76 @@ function nestedFields(field) {
   const record = field;
   return record.fields ?? record.schema?.fields ?? [];
 }
-function getFieldTypeFromPath(schema, path) {
+function getFieldDescriptorFromPath(schema, path) {
   const paths = getAvailableFieldPaths(schema);
   const match = paths.find((p) => p.path === path);
-  return match?.type ?? null;
+  if (match) return { kind: "scalar", type: match.type };
+  const field = findContentFieldByPath(schema.fields ?? [], path.split("."));
+  if (!field || field.type !== "repeater") return null;
+  return {
+    kind: "repeater",
+    shape: buildRepeaterFieldShape(field)
+  };
+}
+function findContentFieldByPath(fields, segments) {
+  if (segments.length === 0) return null;
+  const [head, ...tail] = segments;
+  const field = fields.find((candidate) => candidate.id === head);
+  if (!field) return null;
+  if (tail.length === 0) return field;
+  if (field.type !== "group") return null;
+  return findContentFieldByPath(nestedFields(field), tail);
+}
+function buildRepeaterFieldShape(field) {
+  const record = field;
+  if (record.polymorphic || record.itemTypes) {
+    return { kind: "unsupported", reason: "polymorphic_unsupported" };
+  }
+  const fields = nestedFields(field);
+  if (fields.length === 0) {
+    return { kind: "unsupported", reason: "missing_item_schema" };
+  }
+  const itemFields = [];
+  for (const child of fields) {
+    if (child.type === "repeater") {
+      return { kind: "unsupported", reason: "nested_repeater_unsupported" };
+    }
+    if (!isRepeaterItemScalarType(child.type)) {
+      return { kind: "unsupported", reason: "unsupported_item_field" };
+    }
+    itemFields.push({
+      id: child.id,
+      type: child.type,
+      required: Boolean(child.required)
+    });
+  }
+  return { kind: "supported", itemFields };
+}
+function isRepeaterItemScalarType(type) {
+  switch (type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "number":
+    case "date":
+    case "url":
+    case "media":
+    case "file":
+    case "boolean":
+    case "select":
+    case "reference":
+    case "link":
+    case "button":
+    case "datetime":
+      return true;
+    case "group":
+    case "repeater":
+      return false;
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
 }
 
 // ../content-model/src/templates/bindingValidation.ts
@@ -247,9 +336,6 @@ var TRANSFORM_IO = {
 function getTransformIO(name) {
   return name in TRANSFORM_IO ? TRANSFORM_IO[name] : void 0;
 }
-function resolveContentPathType(schema, path) {
-  return getFieldTypeFromPath(schema, path);
-}
 function resolveMetaPathType(path) {
   return resolveMetaFieldType(path);
 }
@@ -276,8 +362,8 @@ function isSourceCompatibleWithTarget(sourceType, targetType) {
   return isCompatibleBinding(sourceType, targetType);
 }
 function resolveFieldSource(path, context) {
-  const type = resolveContentPathType(context.schema, path);
-  if (type === null) {
+  const descriptor = getFieldDescriptorFromPath(context.schema, path);
+  if (descriptor === null) {
     return {
       kind: "invalidPath",
       error: {
@@ -288,7 +374,10 @@ function resolveFieldSource(path, context) {
       }
     };
   }
-  return { kind: "ok", type, path };
+  if (descriptor.kind === "repeater") {
+    return { kind: "ok", type: "repeater", path, shape: descriptor.shape };
+  }
+  return { kind: "ok", type: descriptor.type, path };
 }
 function resolveMetaSource(path, context) {
   const type = resolveMetaPathType(path);
@@ -318,6 +407,21 @@ function checkDirectCompatibility(resolved, context, isMetaSource) {
       via: "direct"
     };
   }
+  if (context.target.type === "repeater") {
+    const mismatch = checkRepeaterCompatibility(resolved, context);
+    return mismatch;
+  }
+  if (resolved.type === "repeater") {
+    return {
+      kind: "typeIncompatible",
+      blockIdentifier: context.blockIdentifier,
+      fieldKey: context.fieldKey,
+      sourceType: describeResolvedSourceType(resolved),
+      sourcePath: resolved.path,
+      targetType: context.target.type,
+      via: "direct"
+    };
+  }
   if (isSourceCompatibleWithTarget(resolved.type, context.target.type)) return null;
   return {
     kind: "typeIncompatible",
@@ -329,6 +433,51 @@ function checkDirectCompatibility(resolved, context, isMetaSource) {
     via: "direct"
   };
 }
+function describeResolvedSourceType(resolved) {
+  if (resolved.type !== "repeater") return resolved.type;
+  return resolved.shape?.kind === "unsupported" ? `repeater(${resolved.shape.reason})` : "repeater";
+}
+function describeTargetType(target) {
+  return target.type;
+}
+function checkRepeaterCompatibility(resolved, context) {
+  if (context.target.type !== "repeater") return null;
+  const incompatible = (sourceType) => ({
+    kind: "typeIncompatible",
+    blockIdentifier: context.blockIdentifier,
+    fieldKey: context.fieldKey,
+    sourceType,
+    sourcePath: resolved.path,
+    targetType: describeTargetType(context.target),
+    via: "direct"
+  });
+  if (resolved.type !== "repeater" || !resolved.shape) {
+    return incompatible(describeResolvedSourceType(resolved));
+  }
+  const sourceShape = resolved.shape;
+  const targetShape = context.target.shape;
+  if (sourceShape.kind === "unsupported") {
+    return incompatible(`repeater(${sourceShape.reason})`);
+  }
+  if (targetShape.kind === "unsupported") {
+    return incompatible(`target-repeater(${targetShape.reason})`);
+  }
+  const sourceById = new Map(sourceShape.itemFields.map((field) => [field.id, field]));
+  for (const targetField of targetShape.itemFields) {
+    const sourceField = sourceById.get(targetField.id);
+    if (!sourceField) {
+      if (targetField.required) return incompatible("repeater(missing_required_target_field)");
+      continue;
+    }
+    if (targetField.required && !sourceField.required) {
+      return incompatible("repeater(requiredness_mismatch)");
+    }
+    if (!isScalarBlockFieldType(targetField.type) || !isSourceCompatibleWithTarget(sourceField.type, targetField.type)) {
+      return incompatible(`repeater(type_mismatch:${sourceField.id})`);
+    }
+  }
+  return null;
+}
 function validateBinding(binding, context) {
   if (typeof binding === "string") {
     const resolved = resolveFieldSource(binding, context);
@@ -464,10 +613,13 @@ function validateTransform(binding, context) {
   }
   return errors;
 }
+function isTemplateBindingValueArray(value) {
+  return Array.isArray(value);
+}
 function readFallbackOptions(binding) {
-  if (Array.isArray(binding.options)) return binding.options;
+  if (isTemplateBindingValueArray(binding.options)) return binding.options;
   const legacy = binding.sources;
-  return Array.isArray(legacy) ? legacy : [];
+  return isTemplateBindingValueArray(legacy) ? legacy : [];
 }
 function resolveTransformInput(binding) {
   if (binding.input !== void 0) {
@@ -592,9 +744,8 @@ var FIELD_TYPE_CLASSIFICATION = {
   group: "composite",
   modal: "composite",
   tabGroup: "composite",
-  // Repeaters: monomorphic has a single inner shape we could walk, but the
-  // leaves would be bindings to repeated items, not to a fixed path. Skip.
-  repeater: "opaque",
+  // Whole-field containers.
+  repeater: "whole",
   // Opaque types — dashboard-only widgets without an underlying bindable leaf.
   presetOrCustom: "opaque",
   contentTypeSelect: "opaque",
@@ -620,6 +771,15 @@ function collectLeaves(fields, prefix, out) {
       });
       continue;
     }
+    if (cls === "whole") {
+      out.push({
+        id,
+        type: "repeater",
+        required: Boolean(field.required),
+        shape: buildManifestRepeaterShape(field)
+      });
+      continue;
+    }
     if (cls === "composite") {
       const groupChildren = field.schema?.fields;
       if (groupChildren) collectLeaves(groupChildren, id, out);
@@ -630,6 +790,31 @@ function collectLeaves(fields, prefix, out) {
     void leafToBlockFieldType;
   }
 }
+function buildManifestRepeaterShape(field) {
+  if (field.polymorphic || field.itemTypes) {
+    return { kind: "unsupported", reason: "polymorphic_unsupported" };
+  }
+  const fields = field.repeatedItem?.fields ?? field.schema?.fields;
+  if (!fields || fields.length === 0) {
+    return { kind: "unsupported", reason: "missing_item_schema" };
+  }
+  const itemFields = [];
+  for (const child of fields) {
+    if (child.type === "repeater") {
+      return { kind: "unsupported", reason: "nested_repeater_unsupported" };
+    }
+    const type = leafToBlockFieldType(child.type);
+    if (!type) {
+      return { kind: "unsupported", reason: "unsupported_item_field" };
+    }
+    itemFields.push({
+      id: child.id,
+      type,
+      required: Boolean(child.required)
+    });
+  }
+  return { kind: "supported", itemFields };
+}
 function manifestToValidationShape(manifest) {
   const fields = [];
   collectLeaves(manifest.fields, "", fields);
@@ -637,6 +822,9 @@ function manifestToValidationShape(manifest) {
 }
 
 // src/config/template-validation.ts
+function assertNeverField(field) {
+  throw new Error(`Unhandled field type while reading nested SDK fields: ${JSON.stringify(field)}`);
+}
 function toContentTypeSchema(fields) {
   return {
     version: 1,
@@ -662,8 +850,26 @@ function nestedSdkFields(field) {
       return field.schema?.fields;
     case "tabGroup":
       return field.tabs.flatMap((tab) => tab.fields);
-    default:
+    case "text":
+    case "richText":
+    case "media":
+    case "file":
+    case "boolean":
+    case "number":
+    case "date":
+    case "time":
+    case "datetime":
+    case "slug":
+    case "url":
+    case "link":
+    case "select":
+    case "reference":
+    case "presetOrCustom":
+    case "contentTypeSelect":
+    case "entryPicker":
       return void 0;
+    default:
+      return assertNeverField(field);
   }
 }
 function toContentFieldType(type) {