strapi-relation-names 1.2.1 → 1.3.0

package/dist/server/index.mjs

@@ -2,9 +2,9 @@ const bootstrap = ({ strapi }) => {
 };
 const destroy = ({ strapi }) => {
 };
-const PLUGIN_ID$1 = "strapi-relation-names";
+const PLUGIN_ID = "strapi-relation-names";
 const register = ({ strapi }) => {
-  const relationLabels2 = strapi.plugin(PLUGIN_ID$1).service("relation-labels");
+  const relationLabels2 = strapi.plugin(PLUGIN_ID).service("relation-labels");
   const controllers2 = strapi.get("controllers");
   controllers2.extend("plugin::content-manager.relations", (controller) => ({
     ...controller,
@@ -56,6 +56,7 @@ const register = ({ strapi }) => {
       await decorateConfiguration(ctx, ctx.params.uid);
     },
     async updateContentTypeConfiguration(ctx, next) {
+      ctx.request.body = relationLabels2.sanitizeConfigurationUpdate(ctx.request.body);
       await controller.updateContentTypeConfiguration(ctx, next);
       await decorateConfiguration(ctx, ctx.params.uid);
     }
@@ -72,12 +73,28 @@ const register = ({ strapi }) => {
     }
   }));
 };
+const isOptionalString = (value) => value === void 0 || typeof value === "string";
 const validateConfig = (config2) => {
-  if (!config2 || typeof config2 !== "object" || Array.isArray(config2) || !Array.isArray(config2.collections) || !config2.collections.every(
-    (collection) => typeof collection === "string"
-  )) {
+  if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) {
+    throw new Error("The collections config must be an array of strings");
+  }
+  const typedConfig = config2;
+  if (!Array.isArray(typedConfig.collections) || !typedConfig.collections.every((collection) => typeof collection === "string")) {
     throw new Error("The collections config must be an array of strings");
   }
+  if (!isOptionalString(typedConfig.locale)) {
+    throw new Error("The locale config must be a string");
+  }
+  if (!isOptionalString(typedConfig.timeZone)) {
+    throw new Error("The timeZone config must be a string");
+  }
+  if (typedConfig.timeZone) {
+    try {
+      new Intl.DateTimeFormat(void 0, { timeZone: typedConfig.timeZone });
+    } catch {
+      throw new Error("The timeZone config must be a valid IANA timezone");
+    }
+  }
 };
 const config = {
   default: {
@@ -88,7 +105,7 @@ const config = {
 const contentTypes = {};
 const settings$1 = ({ strapi }) => ({
   async find(ctx) {
-    const data = await strapi.plugin("strapi-relation-names").service("settings").get();
+    const data = await strapi.plugin(PLUGIN_ID).service("settings").get();
     ctx.body = { data };
   },
   async update(ctx) {
@@ -96,7 +113,7 @@ const settings$1 = ({ strapi }) => ({
     if (!body || typeof body !== "object" || Array.isArray(body)) {
       return ctx.badRequest("Settings must be an object");
     }
-    const data = await strapi.plugin("strapi-relation-names").service("settings").set(body);
+    const data = await strapi.plugin(PLUGIN_ID).service("settings").set(body);
     ctx.body = { data };
   }
 });
@@ -134,7 +151,8 @@ const routes = {
   "content-api": contentAPIRoutes,
   admin: adminAPIRoutes
 };
-const SCALAR_TYPES = /* @__PURE__ */ new Set([
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const FIELD_TYPES = /* @__PURE__ */ new Set([
   "string",
   "text",
   "email",
@@ -149,30 +167,81 @@ const SCALAR_TYPES = /* @__PURE__ */ new Set([
   "time",
   "boolean"
 ]);
-const SYSTEM_SCALAR_FIELDS = /* @__PURE__ */ new Set([
-  "id",
-  "documentId",
-  "createdAt",
-  "updatedAt",
-  "publishedAt",
-  "locale",
-  "status"
-]);
-const PLACEHOLDER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
-const isRecord$1 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const DATE_TYPES = /* @__PURE__ */ new Set(["date", "datetime"]);
+const SYSTEM_SCALAR_TYPES = {
+  id: "integer",
+  documentId: "string",
+  createdAt: "datetime",
+  updatedAt: "datetime",
+  publishedAt: "datetime",
+  locale: "string",
+  status: "string"
+};
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PATH_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+const getNestedSchemaUid = (attribute) => {
+  if (attribute.type === "component") {
+    return attribute.component;
+  }
+  if (attribute.type === "relation") {
+    return attribute.targetModel ?? attribute.target;
+  }
+  return void 0;
+};
+const getDate = (value) => {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? void 0 : value;
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    return void 0;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+};
+const isDateOnly = (value) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+const formatDate = (value, options, context, preserveDateOnly) => {
+  const date = getDate(value);
+  if (!date) {
+    return "";
+  }
+  const timeZone = preserveDateOnly && isDateOnly(value) ? "UTC" : context.timeZone;
+  return new Intl.DateTimeFormat(context.locale, {
+    ...options,
+    ...timeZone ? { timeZone } : {}
+  }).format(date);
+};
+const TRANSFORMS = {
+  toLocalDate: {
+    accepts: (fieldType) => DATE_TYPES.has(fieldType ?? ""),
+    apply: (value, context) => formatDate(value, { dateStyle: "short" }, context, true)
+  },
+  toLocalDateTime: {
+    accepts: (fieldType) => fieldType === "datetime",
+    apply: (value, context) => formatDate(value, { dateStyle: "short", timeStyle: "short" }, context, false)
+  }
+};
 const getPathValue = (value, path) => {
   return path.split(".").reduce((current, segment) => {
     if (Array.isArray(current)) {
-      return current.map((item) => isRecord$1(item) ? item[segment] : void 0).filter((item) => item !== void 0);
+      return current.map((item) => isRecord(item) ? item[segment] : void 0).filter((item) => item !== void 0);
     }
-    return isRecord$1(current) ? current[segment] : void 0;
+    return isRecord(current) ? current[segment] : void 0;
   }, value);
 };
-const parseTemplate = (template) => {
+const parseExpression = (value) => {
+  const parts = value.split("|").map((part) => part.trim());
+  const [path, ...transforms] = parts;
+  if (!path || !PATH_PATTERN.test(path) || transforms.some((name) => !IDENTIFIER_PATTERN.test(name))) {
+    return null;
+  }
+  return { path, transforms };
+};
+const parseTemplateAst = (template) => {
   if (!template.trim()) {
     return null;
   }
-  const placeholders = [];
+  const tokens = [];
+  const expressions = [];
   let cursor = 0;
   while (cursor < template.length) {
     const openingBrace = template.indexOf("{", cursor);
@@ -181,69 +250,98 @@ const parseTemplate = (template) => {
       return null;
     }
     if (openingBrace === -1) {
+      tokens.push({ type: "text", value: template.slice(cursor) });
       break;
     }
+    if (openingBrace > cursor) {
+      tokens.push({ type: "text", value: template.slice(cursor, openingBrace) });
+    }
     const end = template.indexOf("}", openingBrace + 1);
     if (end === -1) {
       return null;
     }
-    const name = template.slice(openingBrace + 1, end);
-    if (!PLACEHOLDER_PATTERN.test(name)) {
+    const expression = parseExpression(template.slice(openingBrace + 1, end));
+    if (!expression) {
       return null;
     }
-    placeholders.push(name);
+    tokens.push({ type: "expression", expression });
+    expressions.push(expression);
     cursor = end + 1;
   }
-  return placeholders.length > 0 ? placeholders : null;
+  return expressions.length > 0 ? { tokens, expressions } : null;
+};
+const parseTemplate = (template) => {
+  const ast = parseTemplateAst(template);
+  return ast?.expressions.map(({ path }) => path) ?? null;
+};
+const resolvePathType = (path, targetSchema, resolveSchema) => {
+  const segments = path.split(".");
+  let schema = targetSchema;
+  for (const [index2, segment] of segments.entries()) {
+    const isLastSegment = index2 === segments.length - 1;
+    if (index2 === 0 && isLastSegment && SYSTEM_SCALAR_TYPES[segment]) {
+      return SYSTEM_SCALAR_TYPES[segment];
+    }
+    const attribute = schema.attributes?.[segment];
+    if (!attribute || attribute.private === true) {
+      return void 0;
+    }
+    if (isLastSegment) {
+      return FIELD_TYPES.has(attribute.type ?? "") ? attribute.type : void 0;
+    }
+    const nestedSchemaUid = getNestedSchemaUid(attribute);
+    if (!nestedSchemaUid || !resolveSchema) {
+      return void 0;
+    }
+    const nestedSchema = resolveSchema(nestedSchemaUid);
+    if (!nestedSchema) {
+      return void 0;
+    }
+    schema = nestedSchema;
+  }
+  return void 0;
 };
 const compileTemplate = (template, targetSchema, resolveSchema) => {
-  const placeholders = parseTemplate(template);
-  if (!placeholders || !targetSchema) {
+  const ast = parseTemplateAst(template);
+  if (!ast || !targetSchema) {
     return null;
   }
-  const valid = placeholders.every((path) => {
-    const segments = path.split(".");
-    let schema = targetSchema;
-    for (const [index2, segment] of segments.entries()) {
-      const attribute = schema.attributes?.[segment];
-      const isLastSegment = index2 === segments.length - 1;
-      if (index2 === 0 && isLastSegment && SYSTEM_SCALAR_FIELDS.has(segment)) {
-        return true;
-      }
-      if (!attribute || attribute.private === true) {
-        return false;
-      }
-      if (isLastSegment) {
-        return SCALAR_TYPES.has(attribute.type ?? "");
-      }
-      const nestedSchemaUid = attribute.type === "component" ? attribute.component : attribute.type === "relation" ? attribute.target : void 0;
-      if (!nestedSchemaUid || !resolveSchema) {
-        return false;
-      }
-      schema = resolveSchema(nestedSchemaUid);
-      if (!schema) {
-        return false;
-      }
-    }
-    return false;
+  const valid = ast.expressions.every(({ path, transforms }) => {
+    const fieldType = resolvePathType(path, targetSchema, resolveSchema);
+    return Boolean(fieldType && transforms.every((name) => TRANSFORMS[name]?.accepts(fieldType)));
   });
   if (!valid) {
     return null;
   }
   return {
+    ...ast,
     template,
-    placeholders,
-    displayField: placeholders[0].split(".").slice(-1)[0] ?? placeholders[0]
+    placeholders: ast.expressions.map(({ path }) => path),
+    displayField: ast.expressions[0].path.split(".").slice(-1)[0] ?? ast.expressions[0].path
   };
 };
-const renderTemplate = (compiled, values) => {
-  const rendered = compiled.template.replace(
-    /\{([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\}/g,
-    (_match, name) => {
-      const value = getPathValue(values, name);
-      return value === null || value === void 0 ? "" : String(value);
-    }
-  );
+const applyTransform = (value, name, context) => {
+  const transform = TRANSFORMS[name];
+  if (!transform) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => applyTransform(item, name, context));
+  }
+  return transform.apply(value, context);
+};
+const renderTemplate = (compiled, values, context = compiled.transformContext ?? {}) => {
+  const tokens = compiled.tokens ?? parseTemplateAst(compiled.template)?.tokens ?? [];
+  const rendered = tokens.map((token) => {
+    if (token.type === "text") {
+      return token.value;
+    }
+    const expressionValue = token.expression.transforms.reduce(
+      (value, name) => applyTransform(value, name, context),
+      getPathValue(values, token.expression.path)
+    );
+    return expressionValue === null || expressionValue === void 0 ? "" : String(expressionValue);
+  }).join("");
   return rendered.trim();
 };
 const getIdentity = (value, modelType) => modelType === "component" ? value.id : value.documentId ?? value.id;
@@ -265,6 +363,11 @@ const matchesRelation = (source, candidate, targetModelType) => {
 const applyLabel = (value, hydrated, runtime) => {
   const label = renderTemplate(runtime, hydrated);
   if (label) {
+    const isNestedTemplate = runtime.placeholders.some((placeholder) => placeholder.includes("."));
+    const isIdentityField = runtime.displayField === "id" || runtime.displayField === "documentId";
+    if (isNestedTemplate && isIdentityField) {
+      return { ...value, label };
+    }
     return { ...value, [runtime.displayField]: label };
   }
   if (runtime.displayField === runtime.originalMainField) {
@@ -276,60 +379,15 @@ const applyLabel = (value, hydrated, runtime) => {
 };
 const relationValues = (value) => {
   if (Array.isArray(value)) {
-    return value.filter(isRecord$1);
+    return value.filter(isRecord);
   }
-  return isRecord$1(value) ? [value] : [];
+  return isRecord(value) ? [value] : [];
 };
 const replaceRelationValue = (original, values, hydrated, runtime) => {
   const decorated = values.map((value) => applyLabel(value, hydrated.get(value) ?? value, runtime));
   return Array.isArray(original) ? decorated : decorated[0] ?? original;
 };
 const isCollectionEnabled = (collections, uid) => collections.length === 0 || collections.includes(uid);
-const getOriginalMainField = async (strapi, sourceSchema, targetSchema, targetField, userAbility) => {
-  const serviceName = sourceSchema.modelType === "component" ? "components" : "content-types";
-  const configuration = await strapi.plugin("content-manager").service(serviceName).findConfiguration(sourceSchema);
-  const configuredMainField = configuration?.metadatas?.[targetField]?.edit?.mainField;
-  if (typeof configuredMainField !== "string" || configuredMainField === "documentId" || configuredMainField === "id") {
-    return configuredMainField === "documentId" ? "documentId" : "id";
-  }
-  const permissionChecker = strapi.plugin("content-manager").service("permission-checker").create({ userAbility, model: targetSchema.uid });
-  const attribute = targetSchema.attributes?.[configuredMainField];
-  if (!attribute || attribute.private === true || permissionChecker.cannot.read(null, configuredMainField)) {
-    return "documentId";
-  }
-  return configuredMainField;
-};
-const getRuntime = async (strapi, settings2, sourceUid, targetField, userAbility) => {
-  const sourceSchema = strapi.getModel(sourceUid);
-  const attribute = sourceSchema?.attributes?.[targetField];
-  if (!sourceSchema || !attribute || attribute.type !== "relation" || !attribute.target) {
-    return null;
-  }
-  const template = settings2.relations[sourceUid]?.[targetField];
-  const targetSchema = strapi.getModel(attribute.target);
-  const compiled = typeof template === "string" ? compileTemplate(
-    template,
-    targetSchema,
-    (uid) => strapi.getModel(uid)
-  ) : null;
-  if (!compiled || !targetSchema) {
-    return null;
-  }
-  const originalMainField = await getOriginalMainField(
-    strapi,
-    sourceSchema,
-    targetSchema,
-    targetField,
-    userAbility
-  );
-  return {
-    ...compiled,
-    displayField: compiled.placeholders.some((placeholder) => placeholder.includes(".")) ? originalMainField : compiled.displayField,
-    sourceUid,
-    targetUid: targetSchema.uid,
-    originalMainField
-  };
-};
 const buildPopulate = (placeholders) => {
   const populate = {};
   for (const placeholder of placeholders) {
@@ -402,8 +460,61 @@ const hydrateValues = async (strapi, ctx, runtime, values) => {
     return new Map(values.map((value) => [value, value]));
   }
 };
+const getOriginalMainField = async (strapi, sourceSchema, targetSchema, targetField, userAbility) => {
+  const serviceName = sourceSchema.modelType === "component" ? "components" : "content-types";
+  const configuration = await strapi.plugin("content-manager").service(serviceName).findConfiguration(sourceSchema);
+  const configuredMainField = configuration?.metadatas?.[targetField]?.edit?.mainField;
+  if (typeof configuredMainField !== "string" || configuredMainField === "documentId" || configuredMainField === "id") {
+    return configuredMainField === "documentId" ? "documentId" : "id";
+  }
+  const permissionChecker = strapi.plugin("content-manager").service("permission-checker").create({ userAbility, model: targetSchema.uid });
+  const attribute = targetSchema.attributes?.[configuredMainField];
+  if (!attribute || attribute.private === true || permissionChecker.cannot.read(null, configuredMainField)) {
+    return "documentId";
+  }
+  return configuredMainField;
+};
+const getRuntime = async (strapi, settings2, sourceUid, targetField, userAbility, transformContext) => {
+  const sourceSchema = strapi.getModel(sourceUid);
+  const attribute = sourceSchema?.attributes?.[targetField];
+  if (!sourceSchema || !attribute || attribute.type !== "relation" || !attribute.target) {
+    return null;
+  }
+  const template = settings2.relations[sourceUid]?.[targetField];
+  const targetSchema = strapi.getModel(attribute.target);
+  const compiled = typeof template === "string" ? compileTemplate(
+    template,
+    targetSchema,
+    (uid) => strapi.getModel(uid)
+  ) : null;
+  if (!compiled || !targetSchema) {
+    return null;
+  }
+  const originalMainField = await getOriginalMainField(
+    strapi,
+    sourceSchema,
+    targetSchema,
+    targetField,
+    userAbility
+  );
+  return {
+    ...compiled,
+    transformContext,
+    displayField: compiled.placeholders.some((placeholder) => placeholder.includes(".")) ? originalMainField : compiled.displayField,
+    sourceUid,
+    targetUid: targetSchema.uid,
+    originalMainField
+  };
+};
+const getTransformContext = (strapi) => {
+  const config2 = strapi.config.get("plugin::strapi-relation-names");
+  return {
+    locale: typeof config2?.locale === "string" ? config2.locale : void 0,
+    timeZone: typeof config2?.timeZone === "string" ? config2.timeZone : void 0
+  };
+};
 const relationLabels = ({ strapi }) => {
-  const getSettings = () => strapi.plugin("strapi-relation-names").service("settings").get();
+  const getSettings = () => strapi.plugin(PLUGIN_ID).service("settings").get();
   const decorateRelationResults = async (ctx, sourceUid, targetField, results) => {
     const settings2 = await getSettings();
     if (!isCollectionEnabled(settings2.collections, sourceUid)) {
@@ -414,26 +525,27 @@ const relationLabels = ({ strapi }) => {
       settings2,
       sourceUid,
       targetField,
-      ctx.state.userAbility
+      ctx.state.userAbility,
+      getTransformContext(strapi)
     );
     if (!runtime) {
       return results;
     }
-    const values = results.filter(isRecord$1);
+    const values = results.filter(isRecord);
     const hydrated = await hydrateValues(strapi, ctx, runtime, values);
     return results.map(
-      (result) => isRecord$1(result) ? applyLabel(result, hydrated.get(result) ?? result, runtime) : result
+      (result) => isRecord(result) ? applyLabel(result, hydrated.get(result) ?? result, runtime) : result
     );
   };
   const decorateConfiguration = async (configuration, sourceUid) => {
-    if (!configuration || !isRecord$1(configuration.metadatas)) {
+    if (!configuration || !isRecord(configuration.metadatas)) {
       return configuration;
     }
     const settings2 = await getSettings();
     const metadatas = { ...configuration.metadatas };
     const relationNames = {};
+    const sourceSchema = strapi.getModel(sourceUid);
     for (const [fieldName, metadata] of Object.entries(metadatas)) {
-      const sourceSchema = strapi.getModel(sourceUid);
       const attribute = sourceSchema?.attributes?.[fieldName];
       if (!attribute || attribute.type !== "relation" || !attribute.target) {
         continue;
@@ -444,12 +556,16 @@ const relationLabels = ({ strapi }) => {
         targetSchema,
         (uid) => strapi.getModel(uid)
       );
-      if (!compiled || !isRecord$1(metadata)) {
+      if (!compiled || !isRecord(metadata)) {
         continue;
       }
-      const editMetadata = isRecord$1(metadata.edit) ? metadata.edit : {};
+      const editMetadata = isRecord(metadata.edit) ? metadata.edit : {};
       const configuredMainField = typeof editMetadata.mainField === "string" ? editMetadata.mainField : "id";
-      const displayField = compiled.placeholders.some((placeholder) => placeholder.includes(".")) ? configuredMainField : compiled.displayField;
+      const isNestedTemplate = compiled.placeholders.some(
+        (placeholder) => placeholder.includes(".")
+      );
+      const isIdentityField = configuredMainField === "id" || configuredMainField === "documentId";
+      const displayField = isNestedTemplate && isIdentityField ? "label" : isNestedTemplate ? configuredMainField : compiled.displayField;
       metadatas[fieldName] = {
         ...metadata,
         edit: {
@@ -457,7 +573,7 @@ const relationLabels = ({ strapi }) => {
           mainField: displayField
         },
         list: {
-          ...isRecord$1(metadata.list) ? metadata.list : {},
+          ...isRecord(metadata.list) ? metadata.list : {},
           mainField: displayField
         }
       };
@@ -467,13 +583,13 @@ const relationLabels = ({ strapi }) => {
       ...configuration,
       metadatas,
       settings: {
-        ...isRecord$1(configuration.settings) ? configuration.settings : {},
+        ...isRecord(configuration.settings) ? configuration.settings : {},
         relationNames
       }
     };
   };
   const decorateContentManagerConfiguration = async (data, sourceUid) => {
-    if (!isRecord$1(data)) {
+    if (!isRecord(data)) {
       return data;
     }
     const settings2 = await getSettings();
@@ -487,7 +603,7 @@ const relationLabels = ({ strapi }) => {
     if (next.component) {
       next.component = await decorateConfiguration(next.component, sourceUid);
     }
-    if (isRecord$1(next.components)) {
+    if (isRecord(next.components)) {
       const components = { ...next.components };
       for (const [uid, configuration] of Object.entries(components)) {
         components[uid] = await decorateConfiguration(configuration, uid);
@@ -496,6 +612,33 @@ const relationLabels = ({ strapi }) => {
     }
     return next;
   };
+  const sanitizeConfigurationUpdate = (configuration) => {
+    if (!isRecord(configuration) || !isRecord(configuration.metadatas)) {
+      return configuration;
+    }
+    const configurationSettings = isRecord(configuration.settings) ? configuration.settings : {};
+    const relationNames = isRecord(configurationSettings.relationNames) ? configurationSettings.relationNames : {};
+    const { relationNames: _relationNames, ...sanitizedSettings } = configurationSettings;
+    const metadatas = { ...configuration.metadatas };
+    for (const [fieldName, metadata] of Object.entries(metadatas)) {
+      const relationName = relationNames[fieldName];
+      if (!isRecord(relationName) || relationName.mainField !== "label" || !isRecord(metadata) || !isRecord(metadata.edit) || metadata.edit.mainField !== "label") {
+        continue;
+      }
+      metadatas[fieldName] = {
+        ...metadata,
+        edit: {
+          ...metadata.edit,
+          mainField: "id"
+        },
+        list: {
+          ...isRecord(metadata.list) ? metadata.list : {},
+          mainField: "id"
+        }
+      };
+    }
+    return { ...configuration, settings: sanitizedSettings, metadatas };
+  };
   const decorateCollectionResults = async (ctx, sourceUid, results) => {
     const settings2 = await getSettings();
     if (!isCollectionEnabled(settings2.collections, sourceUid)) {
@@ -503,6 +646,7 @@ const relationLabels = ({ strapi }) => {
     }
     const runtimeCache = /* @__PURE__ */ new Map();
     const sourceSchemas = /* @__PURE__ */ new Map();
+    const transformContext = getTransformContext(strapi);
     const getSchema = (uid) => {
       if (!sourceSchemas.has(uid)) {
         sourceSchemas.set(uid, strapi.getModel(uid));
@@ -516,7 +660,7 @@ const relationLabels = ({ strapi }) => {
         }
         return;
       }
-      if (!isRecord$1(value)) {
+      if (!isRecord(value)) {
         return;
       }
       const schema = getSchema(uid);
@@ -526,7 +670,14 @@ const relationLabels = ({ strapi }) => {
           if (!runtimeCache.has(cacheKey)) {
             runtimeCache.set(
               cacheKey,
-              await getRuntime(strapi, settings2, uid, fieldName, ctx.state.userAbility)
+              await getRuntime(
+                strapi,
+                settings2,
+                uid,
+                fieldName,
+                ctx.state.userAbility,
+                transformContext
+              )
             );
           }
           const runtime = runtimeCache.get(cacheKey);
@@ -562,6 +713,7 @@ const relationLabels = ({ strapi }) => {
   return {
     decorateCollectionResults,
     decorateConfiguration: decorateContentManagerConfiguration,
+    sanitizeConfigurationUpdate,
     decorateRelationResults,
     compileTemplate,
     parseTemplate,
@@ -572,9 +724,7 @@ const EMPTY_SETTINGS = {
   collections: [],
   relations: {}
 };
-const PLUGIN_ID = "strapi-relation-names";
 const STORE_KEY = "settings";
-const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const normalizeSettings = (value, collections = []) => {
   if (!isRecord(value) || !isRecord(value.relations)) {
     return { collections, relations: {} };

package/dist/server/src/bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { Core } from '@strapi/strapi';
+import type { Core } from '@strapi/strapi';
 declare const bootstrap: ({ strapi }: {
     strapi: Core.Strapi;
 }) => void;

package/dist/server/src/config/index.d.ts

@@ -1,5 +1,7 @@
 type RelationNamesConfig = {
     collections: string[];
+    locale?: string;
+    timeZone?: string;
 };
 declare const validateConfig: (config: unknown) => asserts config is RelationNamesConfig;
 declare const config: {

package/dist/server/src/controllers/index.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     settings: ({ strapi }: {
-        strapi: import('@strapi/types/dist/core').Strapi;
+        strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
         find(ctx: any): Promise<void>;
         update(ctx: any): Promise<any>;

package/dist/server/src/controllers/settings.d.ts

@@ -1,4 +1,4 @@
-import { Core } from '@strapi/strapi';
+import type { Core } from '@strapi/strapi';
 declare const settings: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {

package/dist/server/src/destroy.d.ts

@@ -1,4 +1,4 @@
-import { Core } from '@strapi/strapi';
+import type { Core } from '@strapi/strapi';
 declare const destroy: ({ strapi }: {
     strapi: Core.Strapi;
 }) => void;