@riverbankcms/sdk 0.78.0 → 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) {

package/dist/server/config-validation.mjs

@@ -1751,7 +1751,16 @@ var ENDPOINT_DEFINITIONS = {
     revalidate: 60,
     tags: ["site-{siteId}", "content-{siteId}-{type}"],
     auth: "user",
-    responseKind: "json"
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
+  },
+  reorderContentEntries: {
+    path: "/sites/{siteId}/content/{type}/order",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
   },
   getContentTemplate: {
     path: "/sites/{siteId}/content/types/{type}/template",
@@ -6495,14 +6504,14 @@ function rotateNormalizedPoint(point, rotation) {
   const x = point.x;
   const y = point.y;
   switch (rotation) {
+    case 0:
+      return { x, y };
     case 90:
       return { x: 1 - y, y: x };
     case 180:
       return { x: 1 - x, y: 1 - y };
     case 270:
       return { x: y, y: 1 - x };
-    default:
-      return { x, y };
   }
 }
 
@@ -6795,6 +6804,8 @@ var uiSchema = z4.object({
   mediaPickerAutoOpen: z4.boolean().optional(),
   showMediaPreview: z4.boolean().optional(),
   showMediaOverlayActions: z4.boolean().optional(),
+  mediaPreviewMaxWidth: z4.enum(["xs", "sm", "md", "none"]).optional(),
+  preventMediaPreviewUpscale: z4.boolean().optional(),
   mediaDelivery: mediaDeliverySchema.optional(),
   mediaDeliveryByVariant: z4.record(z4.string(), mediaDeliverySchema).optional(),
   // Optional input hints for validators/widgets
@@ -7044,6 +7055,9 @@ var repeaterFieldSchema = baseFieldSchema.extend({
   type: z4.literal("repeater"),
   itemLabel: z4.string().default("Item"),
   itemLabelSource: z4.string().optional(),
+  showSummary: z4.boolean().optional(),
+  summaryFields: z4.string().array().optional(),
+  summaryMaxChars: z4.number().int().positive().optional(),
   minItems: z4.number().int().min(0).default(0),
   maxItems: z4.number().int().positive().optional(),
   // Monomorphic mode
@@ -16088,47 +16102,48 @@ function validateFieldDefinitions(fields3, fragmentId) {
 function prefixFieldId(field, scope) {
   const cloned = cloneFieldDefinition2(field);
   cloned.id = `${scope}.${field.id}`;
-  cloned.defaultValue = cloneUnknown(cloned.defaultValue);
+  const defaultValue = cloned.defaultValue;
+  cloned.defaultValue = cloneUnknown(defaultValue);
   cloned.visibleRoles = cloned.visibleRoles ? [...cloned.visibleRoles] : void 0;
   cloned.ui = cloneUnknown(cloned.ui);
   return cloned;
 }
 function cloneFieldDefinition2(field) {
-  switch (field.type) {
-    case "repeater":
-      if (field.polymorphic && field.itemTypes) {
-        return {
-          ...field,
-          polymorphic: true,
-          itemTypes: Object.fromEntries(
-            Object.entries(field.itemTypes).map(([key, itemType]) => [
-              key,
-              {
-                ...itemType,
-                fields: itemType.fields.map(cloneFieldDefinition2)
-              }
-            ])
-          )
-        };
-      } else if (field.schema) {
-        return {
-          ...field,
-          schema: {
-            fields: field.schema.fields.map(cloneFieldDefinition2)
-          }
-        };
-      }
-      return { ...field };
-    case "group":
+  if (field.type === "repeater") {
+    if (field.polymorphic && field.itemTypes) {
+      return {
+        ...field,
+        polymorphic: true,
+        itemTypes: Object.fromEntries(
+          Object.entries(field.itemTypes).map(([key, itemType]) => [
+            key,
+            {
+              ...itemType,
+              fields: itemType.fields.map(cloneFieldDefinition2)
+            }
+          ])
+        )
+      };
+    }
+    if (field.schema) {
       return {
         ...field,
         schema: {
           fields: field.schema.fields.map(cloneFieldDefinition2)
         }
       };
-    default:
-      return { ...field };
+    }
+    return { ...field };
+  }
+  if (field.type === "group") {
+    return {
+      ...field,
+      schema: {
+        fields: field.schema.fields.map(cloneFieldDefinition2)
+      }
+    };
   }
+  return { ...field };
 }
 function cloneUnknown(value) {
   if (value == null || typeof value !== "object") {
@@ -18471,7 +18486,8 @@ function createBlockManifestWithContentShape(config, _contentShape) {
   return createBlockManifest(config);
 }
 function normalizeBlockLayout(layout) {
-  return Array.isArray(layout) ? [...layout] : layout;
+  const rawLayout = layout;
+  return Array.isArray(rawLayout) ? rawLayout : rawLayout;
 }
 function deriveComponentName(id) {
   const base = id.replace(/^block\./, "");
@@ -20017,16 +20033,20 @@ var marqueeLoopTransform = {
   summary: "Repeat an array to a minimum length, then duplicate it for seamless marquee looping",
   schema: marqueeLoopOptionsSchema,
   run: (value, options) => {
-    if (!Array.isArray(value) || value.length === 0) return [];
+    const items = toUnknownArray(value);
+    if (items.length === 0) return [];
     const minItems = options?.minItems ?? 10;
     const base = [];
     while (base.length < minItems) {
-      base.push(...value);
+      base.push(...items);
       if (base.length > 1e3) break;
     }
     return [...base, ...base];
   }
 };
+function toUnknownArray(value) {
+  return Array.isArray(value) ? value : [];
+}
 var formattingTransforms = [
   uppercaseTransform,
   fallbackTransform,
@@ -23693,8 +23713,8 @@ var eventSurfaceScopeValues = [
   "custom"
 ];
 var eventScheduleScopeValues = ["any", "recurring", "oneOff"];
-var asEventCategoryId = (value) => value;
-var asVenueId = (value) => value;
+var unsafeAsEventCategoryId = (value) => value;
+var unsafeAsVenueId = (value) => value;
 function normalizeEventBlockKind(value) {
   return value === "courses" || value === "events" ? value : "all";
 }
@@ -23720,10 +23740,10 @@ function normalizeEventCategoryIds(value) {
   if (Array.isArray(value)) {
     return normalizeIdList(
       value.filter((entry) => typeof entry === "string")
-    ).map(asEventCategoryId);
+    ).map(unsafeAsEventCategoryId);
   }
   if (typeof value === "string") {
-    return normalizeIdList(value.split(",")).map(asEventCategoryId);
+    return normalizeIdList(value.split(",")).map(unsafeAsEventCategoryId);
   }
   return [];
 }
@@ -23736,7 +23756,7 @@ function normalizeEventVenueId(value) {
     return null;
   }
   const trimmed = value.trim();
-  return trimmed ? asVenueId(trimmed) : null;
+  return trimmed ? unsafeAsVenueId(trimmed) : null;
 }
 function normalizeEventStaffMemberId(value) {
   if (typeof value !== "string") {
@@ -33221,10 +33241,16 @@ var dashboardConfigSchema = z61.object({
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
 var sdkLoaderEndpointSchema = z61.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderFallbackScalarSchema = z61.union([
+  z61.string(),
+  z61.number(),
+  z61.boolean(),
+  z61.null()
+]);
 var loaderParamBindingSchema = z61.object({
   $bind: z61.object({
     from: z61.string().min(1, "Binding path is required"),
-    fallback: z61.string().optional()
+    fallback: loaderFallbackScalarSchema.optional()
   })
 });
 var loaderParamValueSchema = z61.union([
@@ -33370,9 +33396,13 @@ var sdkBlockFieldOptionsMapSchema = z61.record(
 var sdkContentTypeTemplateConfigSchema = z61.object({
   blocks: z61.array(z61.unknown())
 }).passthrough();
+var sdkContentTypeOrderingConfigSchema = z61.object({
+  mode: z61.enum(["default", "manual"]).optional()
+}).optional();
 var sdkContentTypeConfigSchema = z61.object({
   key: z61.string().min(1),
   fields: z61.array(z61.unknown()),
+  ordering: sdkContentTypeOrderingConfigSchema,
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
 var sdkContentConfigSchema = z61.object({
@@ -34518,6 +34548,9 @@ var templateConfigSchemaForward = z67.object({
     })
   )
 }).optional();
+var contentTypeOrderingSchema = z67.object({
+  mode: z67.enum(["default", "manual"]).optional()
+}).optional();
 var contentTypeConfigSchema = z67.object({
   key: contentTypeKeySchema,
   name: z67.string().min(1),
@@ -34527,6 +34560,7 @@ var contentTypeConfigSchema = z67.object({
   // Fields are validated as unknown[] here - deep field validation happens in @riverbankcms/blocks
   fields: z67.array(z67.any()).min(1, "At least one field is required"),
   titleField: z67.string().optional(),
+  ordering: contentTypeOrderingSchema,
   isSingleton: z67.boolean().optional().default(false),
   template: templateConfigSchemaForward
 }).refine(
@@ -35058,7 +35092,7 @@ var loaderParamBindingSchema2 = z70.object({
     // Loader params are ultimately string-normalized for query strings, so fallbacks should
     // stay scalar. Use transforms (e.g. `value.jsonArray`) when you need to serialize
     // more complex values into a string.
-    fallback: z70.union([z70.string(), z70.number(), z70.boolean(), z70.null()]).optional(),
+    fallback: loaderFallbackScalarSchema.optional(),
     transforms: z70.array(loaderTransformStepSchema).default([]),
     pick: z70.enum(["value", "collection", "context"]).default("value"),
     coerce: z70.enum(["number", "boolean", "string"]).optional()