@sanity/schema 5.14.0-next.9 → 5.14.0

package/lib/_internal.js

@@ -14,6 +14,7 @@ import isPlainObject from "lodash-es/isPlainObject.js";
 import omit from "lodash-es/omit.js";
 import leven from "leven";
 import inspect from "object-inspect";
+import startCase from "lodash-es/startCase.js";
 import { createReferenceTypeNode } from "groq-js";
 const MAX_IDLE_WORK = 8.333333333333334;
 class IdleScheduler {
@@ -1821,6 +1822,14 @@ function validateField(field, visitorContext) {
       `The type "${field.type}" is a document type and should not be used as a field type directly. Use a "reference" if you want to create a link to the document, or use "object" if you want to embed fields inline.`,
       HELP_IDS.FIELD_TYPE_IS_DOCUMENT
     )
+  ), field.title && typeof field.title != "string" && problems.push(
+    warning(
+      `Field "${field.name}" has a non-string title. This is known to cause problems and will not be supported in future versions. Please use a string instead.`
+    )
+  ), field.description && typeof field.description != "string" && problems.push(
+    warning(
+      `Field "${field.name}" has a non-string description. This is known to cause problems and will not be supported in future versions. Please use a string instead.`
+    )
   ), problems;
 }
 function getDuplicateFields(array2) {
@@ -2350,6 +2359,405 @@ function stringToRegExp(str) {
   const match = str.match(/^\/(.*)\/([gimuy]*)$/);
   return match ? new RegExp(match[1], match[2]) : new RegExp(str);
 }
+const DEFAULT_IMAGE_FIELDS = ["asset", "hotspot", "crop", "media"], DEFAULT_FILE_FIELDS = ["asset", "media"], DEFAULT_GEOPOINT_FIELDS = ["lat", "lng", "alt"], DEFAULT_SLUG_FIELDS = ["current", "source"];
+function getCustomFields(type) {
+  const fields = type.fieldsets ? type.fieldsets.flatMap((fs) => fs.single ? fs.field : fs.fields.map((field) => ({
+    ...field,
+    fieldset: fs.name
+  }))) : type.fields;
+  return isType$1(type, "block") ? [] : isType$1(type, "slug") ? fields.filter((f) => !DEFAULT_SLUG_FIELDS.includes(f.name)) : isType$1(type, "geopoint") ? fields.filter((f) => !DEFAULT_GEOPOINT_FIELDS.includes(f.name)) : isType$1(type, "image") ? fields.filter((f) => !DEFAULT_IMAGE_FIELDS.includes(f.name)) : isType$1(type, "file") ? fields.filter((f) => !DEFAULT_FILE_FIELDS.includes(f.name)) : fields;
+}
+function isReference(type) {
+  return isType$1(type, "reference");
+}
+function isCrossDatasetReference(type) {
+  return isType$1(type, "crossDatasetReference");
+}
+function isGlobalDocumentReference(type) {
+  return isType$1(type, "globalDocumentReference");
+}
+function isObjectField(maybeOjectField) {
+  return typeof maybeOjectField == "object" && maybeOjectField !== null && "name" in maybeOjectField;
+}
+function isCustomized(maybeCustomized) {
+  const internalOwnProps = getSchemaTypeInternalOwnProps(maybeCustomized);
+  return isObjectField(maybeCustomized) && !isReference(maybeCustomized) && !isCrossDatasetReference(maybeCustomized) && !isGlobalDocumentReference(maybeCustomized) && "fields" in maybeCustomized && Array.isArray(maybeCustomized.fields) && // needed to differentiate inline, named array object types from globally defined types
+  // we only consider it customized if the _definition_ has fields declared
+  // this holds for all customizable object-like types: object, document, image and file
+  internalOwnProps?.fields ? !!getCustomFields(maybeCustomized).length : !1;
+}
+function isType$1(schemaType, typeName) {
+  return schemaType.name === typeName ? !0 : schemaType.type ? isType$1(schemaType.type, typeName) : !1;
+}
+function isDefined(value) {
+  return value != null;
+}
+function isRecord(value) {
+  return !!value && typeof value == "object";
+}
+function isPrimitive(value) {
+  return isString(value) || isBoolean(value) || isNumber(value);
+}
+function isString(value) {
+  return typeof value == "string";
+}
+function isNumber(value) {
+  return typeof value == "number";
+}
+function isBoolean(value) {
+  return typeof value == "boolean";
+}
+function getSchemaTypeInternalOwnProps(type) {
+  return type?._internal_ownProps;
+}
+function getDefinedTypeName(type) {
+  return getSchemaTypeInternalOwnProps(type)?.type;
+}
+const MAX_CUSTOM_PROPERTY_DEPTH = 5, noopIconResolver = () => {
+};
+async function extractCreateWorkspaceManifest(workspace, iconResolver = noopIconResolver) {
+  const serializedSchema = extractManifestSchemaTypes(workspace.schema), serializedTools = await extractManifestTools(workspace.tools, iconResolver);
+  return {
+    name: workspace.name,
+    title: workspace.title,
+    subtitle: workspace.subtitle,
+    basePath: workspace.basePath,
+    projectId: workspace.projectId,
+    dataset: workspace.dataset,
+    icon: await iconResolver({
+      icon: workspace.icon,
+      title: workspace.title ?? workspace.name,
+      subtitle: workspace.subtitle
+    }),
+    mediaLibrary: workspace.mediaLibrary,
+    schema: serializedSchema,
+    tools: serializedTools
+  };
+}
+function extractManifestSchemaTypes(schema) {
+  const typeNames = schema.getTypeNames(), studioDefaultTypeNames = Schema.compile({
+    name: "default",
+    types: builtinTypes
+  }).getTypeNames();
+  return typeNames.filter((typeName) => !studioDefaultTypeNames.includes(typeName)).map((typeName) => schema.get(typeName)).filter((type) => typeof type < "u").map((type) => transformType(type));
+}
+function transformCommonTypeFields(type, typeName, context) {
+  const arrayProps = typeName === "array" && type.jsonType === "array" ? transformArrayMember(type) : {}, referenceProps = isReference(type) ? transformReference(type) : {}, crossDatasetRefProps = isCrossDatasetReference(type) ? transformCrossDatasetReference(type) : {}, globalRefProps = isGlobalDocumentReference(type) ? transformGlobalDocumentReference(type) : {}, objectFields = type.jsonType === "object" && type.type && isCustomized(type) ? {
+    fields: getCustomFields(type).map((objectField) => transformField(objectField))
+  } : {};
+  return {
+    ...retainCustomTypeProps(type),
+    ...transformValidation(type.validation),
+    ...ensureString("description", type.description),
+    ...objectFields,
+    ...arrayProps,
+    ...referenceProps,
+    ...crossDatasetRefProps,
+    ...globalRefProps,
+    ...ensureConditional("readOnly", type.readOnly),
+    ...ensureConditional("hidden", type.hidden),
+    ...transformFieldsets(type),
+    // fieldset prop gets instrumented via getCustomFields
+    ...ensureString("fieldset", type.fieldset),
+    ...transformBlockType(type)
+  };
+}
+function transformFieldsets(type) {
+  if (type.jsonType !== "object")
+    return {};
+  const fieldsets = type.fieldsets?.filter((fs) => !fs.single).map((fs) => {
+    const options = isRecord(fs.options) ? { options: retainSerializableProps(fs.options) } : {};
+    return {
+      name: fs.name,
+      ...ensureCustomTitle(fs.name, fs.title),
+      ...ensureString("description", fs.description),
+      ...ensureConditional("readOnly", fs.readOnly),
+      ...ensureConditional("hidden", fs.hidden),
+      ...options
+    };
+  });
+  return fieldsets?.length ? { fieldsets } : {};
+}
+function transformType(type, context) {
+  const typeName = type.type ? type.type.name : type.jsonType;
+  return {
+    ...transformCommonTypeFields(type, typeName),
+    name: type.name,
+    type: typeName,
+    ...ensureCustomTitle(type.name, type.title)
+  };
+}
+function retainCustomTypeProps(type) {
+  const manuallySerializedFields = [
+    //explicitly added
+    "name",
+    "title",
+    "description",
+    "readOnly",
+    "hidden",
+    "validation",
+    "fieldsets",
+    "fields",
+    "to",
+    "of",
+    // not serialized
+    "type",
+    "jsonType",
+    "__experimental_actions",
+    "__experimental_formPreviewTitle",
+    "__experimental_omnisearch_visibility",
+    "__experimental_search",
+    "components",
+    "icon",
+    "orderings",
+    "preview",
+    "groups",
+    //only exists on fields
+    "group"
+    // we know about these, but let them be generically handled
+    // deprecated
+    // rows (from text)
+    // initialValue
+    // options
+    // crossDatasetReference props
+  ], typeWithoutManuallyHandledFields = Object.fromEntries(
+    Object.entries(type).filter(
+      ([key]) => !manuallySerializedFields.includes(key)
+    )
+  );
+  return retainSerializableProps(typeWithoutManuallyHandledFields);
+}
+function retainSerializableProps(maybeSerializable, depth = 0) {
+  if (!(depth > MAX_CUSTOM_PROPERTY_DEPTH) && isDefined(maybeSerializable)) {
+    if (isPrimitive(maybeSerializable))
+      return maybeSerializable === "" ? void 0 : maybeSerializable;
+    if (maybeSerializable instanceof RegExp)
+      return maybeSerializable.toString();
+    if (Array.isArray(maybeSerializable)) {
+      const arrayItems = maybeSerializable.map((item) => retainSerializableProps(item, depth + 1)).filter((item) => isDefined(item));
+      return arrayItems.length ? arrayItems : void 0;
+    }
+    if (isRecord(maybeSerializable)) {
+      const serializableEntries = Object.entries(maybeSerializable).map(([key, value]) => [key, retainSerializableProps(value, depth + 1)]).filter(([, value]) => isDefined(value));
+      return serializableEntries.length ? Object.fromEntries(serializableEntries) : void 0;
+    }
+  }
+}
+function transformField(field, context) {
+  const fieldType = field.type, typeName = getDefinedTypeName(fieldType) ?? fieldType.name;
+  return {
+    ...transformCommonTypeFields(fieldType, typeName),
+    name: field.name,
+    type: typeName,
+    ...ensureCustomTitle(field.name, fieldType.title),
+    // this prop gets added synthetically via getCustomFields
+    ...ensureString("fieldset", field.fieldset)
+  };
+}
+function transformArrayMember(arrayMember, context) {
+  return {
+    of: arrayMember.of.map((type) => {
+      const typeName = getDefinedTypeName(type) ?? type.name;
+      return {
+        ...transformCommonTypeFields(type, typeName),
+        type: typeName,
+        ...typeName === type.name ? {} : { name: type.name },
+        ...ensureCustomTitle(type.name, type.title)
+      };
+    })
+  };
+}
+function transformReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((type) => ({
+      ...retainCustomTypeProps(type),
+      type: type.name
+    }))
+  };
+}
+function transformCrossDatasetReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((crossDataset) => {
+      const preview = crossDataset.preview?.select ? { preview: { select: crossDataset.preview.select } } : {};
+      return {
+        type: crossDataset.type,
+        ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+        ...preview
+      };
+    })
+  };
+}
+function transformGlobalDocumentReference(reference2) {
+  return {
+    to: (reference2.to ?? []).map((crossDataset) => {
+      const preview = crossDataset.preview?.select ? { preview: { select: crossDataset.preview.select } } : {};
+      return {
+        type: crossDataset.type,
+        ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+        ...preview
+      };
+    })
+  };
+}
+const transformTypeValidationRule = (rule) => ({
+  ...rule,
+  constraint: "constraint" in rule && (typeof rule.constraint == "string" ? rule.constraint.toLowerCase() : retainSerializableProps(rule.constraint))
+}), validationRuleTransformers = {
+  type: transformTypeValidationRule
+};
+function transformValidation(validation) {
+  const validationArray = (Array.isArray(validation) ? validation : [validation]).filter(
+    (value) => typeof value == "object" && "_type" in value
+  ), disallowedFlags = ["type"], disallowedConstraintTypes = [Rule.FIELD_REF], serializedValidation = validationArray.map(({ _rules, _message, _level }) => {
+    const message = typeof _message == "string" ? { message: _message } : {};
+    return {
+      rules: _rules.filter((rule) => {
+        if (!("constraint" in rule))
+          return !1;
+        const { flag, constraint } = rule;
+        return disallowedFlags.includes(flag) ? !1 : !(typeof constraint == "object" && "type" in constraint && disallowedConstraintTypes.includes(constraint.type));
+      }).reduce((rules, rule) => {
+        const transformedRule = (validationRuleTransformers[rule.flag] ?? ((spec) => retainSerializableProps(spec)))(rule);
+        return transformedRule ? [...rules, transformedRule] : rules;
+      }, []),
+      level: _level,
+      ...message
+    };
+  }).filter((group) => !!group.rules.length);
+  return serializedValidation.length ? { validation: serializedValidation } : {};
+}
+function ensureCustomTitle(typeName, value) {
+  const titleObject = ensureString("title", value), defaultTitle = startCase(typeName);
+  return titleObject.title === defaultTitle ? {} : titleObject;
+}
+function ensureString(key, value) {
+  return typeof value == "string" ? {
+    [key]: value
+  } : {};
+}
+function ensureConditional(key, value) {
+  return typeof value == "boolean" ? {
+    [key]: value
+  } : typeof value == "function" ? {
+    [key]: "conditional"
+  } : {};
+}
+function transformBlockType(blockType, context) {
+  if (blockType.jsonType !== "object" || !isType$1(blockType, "block"))
+    return {};
+  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  if (!childrenField)
+    return {};
+  const ofType = childrenField.type.of;
+  if (!ofType)
+    return {};
+  const spanType = ofType.find((memberType) => memberType.name === "span");
+  if (!spanType)
+    return {};
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [];
+  return {
+    marks: {
+      annotations: spanType.annotations.map((t) => transformType(t)),
+      decorators: resolveEnabledDecorators(spanType)
+    },
+    lists: resolveEnabledListItems(blockType),
+    styles: resolveEnabledStyles(blockType),
+    of: inlineObjectTypes.map((t) => transformType(t))
+  };
+}
+function resolveEnabledStyles(blockType) {
+  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  return resolveTitleValueArray(styleField?.type?.options?.list);
+}
+function resolveEnabledDecorators(spanType) {
+  return "decorators" in spanType ? resolveTitleValueArray(spanType.decorators) : void 0;
+}
+function resolveEnabledListItems(blockType) {
+  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  return resolveTitleValueArray(listField?.type?.options?.list);
+}
+function resolveTitleValueArray(possibleArray) {
+  if (!possibleArray || !Array.isArray(possibleArray))
+    return;
+  const titledValues = possibleArray.filter(
+    (d) => isRecord(d) && !!d.value && isString(d.value)
+  ).map((item) => ({
+    value: item.value,
+    ...ensureString("title", item.title)
+  }));
+  if (titledValues?.length)
+    return titledValues;
+}
+const extractManifestTools = async (tools, iconResolver = noopIconResolver) => Promise.all(
+  tools.map(async (tool) => {
+    const { title, name, icon, __internalApplicationType: type } = tool;
+    return {
+      title,
+      name,
+      type: type || null,
+      icon: await iconResolver({
+        icon,
+        title
+      })
+    };
+  })
+), SANITY_WORKSPACE_SCHEMA_ID_PREFIX = "_.schemas", CURRENT_WORKSPACE_SCHEMA_VERSION = "2025-05-01", validForNamesChars = "a-zA-Z0-9_-", validForNamesPattern = new RegExp(`^[${validForNamesChars}]+$`, "g"), validForIdChars = "a-zA-Z0-9._-", validForIdPattern = new RegExp(`^[${validForIdChars}]+$`, "g"), requiredInId = SANITY_WORKSPACE_SCHEMA_ID_PREFIX.replace(/[.]/g, "\\."), idPatternString = `^${requiredInId}\\.([${validForNamesChars}]+)`, baseIdPattern = new RegExp(`${idPatternString}$`), taggedIdPattern = new RegExp(`${idPatternString}\\.tag\\.([${validForNamesChars}]+)$`);
+function getWorkspaceSchemaId(args) {
+  const { workspaceName: rawWorkspaceName, tag } = args;
+  let workspaceName = rawWorkspaceName, idWarning;
+  workspaceName.match(validForNamesPattern) || (workspaceName = workspaceName.replace(new RegExp(`[^${validForNamesChars}]`, "g"), "_"), idWarning = [
+    `Workspace "${rawWorkspaceName}" contains characters unsupported by schema _id [${validForNamesChars}], they will be replaced with _.`,
+    "This could lead duplicate schema ids: consider renaming your workspace."
+  ].join(`
+`));
+  const safeBaseId = `${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.${workspaceName}`;
+  return {
+    safeBaseId,
+    safeTaggedId: `${safeBaseId}${tag ? `.tag.${tag}` : ""}`,
+    idWarning
+  };
+}
+function parseWorkspaceSchemaId(id, errors) {
+  const trimmedId = id.trim();
+  if (!trimmedId.match(validForIdPattern)) {
+    errors.push(`id can only contain characters in [${validForIdChars}] but found: "${trimmedId}"`);
+    return;
+  }
+  if (trimmedId.startsWith("-")) {
+    errors.push(`id cannot start with - (dash) but found: "${trimmedId}"`);
+    return;
+  }
+  if (trimmedId.match(/\.\./g)) {
+    errors.push(`id cannot have consecutive . (period) characters, but found: "${trimmedId}"`);
+    return;
+  }
+  const [, workspace] = trimmedId.match(taggedIdPattern) ?? trimmedId.match(baseIdPattern) ?? [];
+  if (!workspace) {
+    errors.push(
+      [
+        `id must either match ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName> `,
+        `or ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName>.tag.<tag> but found: "${trimmedId}". `,
+        `Note that workspace name characters not in [${validForNamesChars}] has to be replaced with _ for schema id.`
+      ].join("")
+    );
+    return;
+  }
+  return {
+    schemaId: trimmedId,
+    workspace
+  };
+}
+function createStoredWorkspaceSchemaPayload(args) {
+  return {
+    version: CURRENT_WORKSPACE_SCHEMA_VERSION,
+    tag: args.tag,
+    workspace: {
+      name: args.workspace.name,
+      title: args.workspace.title
+    },
+    schema: args.schema
+  };
+}
 const documentDefaultFields = (typeName) => ({
   _id: {
     type: "objectAttribute",
@@ -2950,12 +3358,19 @@ export {
   ValidationError,
   builtinTypes,
   createSchemaFromManifestTypes,
+  createStoredWorkspaceSchemaPayload,
+  extractCreateWorkspaceManifest,
+  extractManifestSchemaTypes,
   extractSchema,
+  getWorkspaceSchemaId,
   groupProblems,
   isActionEnabled,
+  parseWorkspaceSchemaId,
   processSchemaSynchronization,
   resolveSearchConfig,
   resolveSearchConfigForBaseFieldPaths,
+  validForNamesChars,
+  validForNamesPattern,
   validateMediaLibraryAssetAspect,
   validateSchema
 };