strapi-relation-names 0.0.0

package/dist/server/index.mjs

@@ -0,0 +1,564 @@
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const PLUGIN_ID$1 = "strapi-relation-names";
+const register = ({ strapi }) => {
+  const relationLabels2 = strapi.plugin(PLUGIN_ID$1).service("relation-labels");
+  const controllers2 = strapi.get("controllers");
+  controllers2.extend("plugin::content-manager.relations", (controller) => ({
+    ...controller,
+    async findAvailable(ctx, next) {
+      await controller.findAvailable(ctx, next);
+      if (Array.isArray(ctx.body?.results)) {
+        ctx.body.results = await relationLabels2.decorateRelationResults(
+          ctx,
+          ctx.params.model,
+          ctx.params.targetField,
+          ctx.body.results
+        );
+      }
+    },
+    async findExisting(ctx, next) {
+      await controller.findExisting(ctx, next);
+      if (Array.isArray(ctx.body?.results)) {
+        ctx.body.results = await relationLabels2.decorateRelationResults(
+          ctx,
+          ctx.params.model,
+          ctx.params.targetField,
+          ctx.body.results
+        );
+      }
+    }
+  }));
+  controllers2.extend("plugin::content-manager.collection-types", (controller) => ({
+    ...controller,
+    async find(ctx, next) {
+      await controller.find(ctx, next);
+      if (Array.isArray(ctx.body?.results)) {
+        ctx.body.results = await relationLabels2.decorateCollectionResults(
+          ctx,
+          ctx.params.model,
+          ctx.body.results
+        );
+      }
+    }
+  }));
+  const decorateConfiguration = async (ctx, sourceUid) => {
+    if (ctx.body?.data) {
+      ctx.body.data = await relationLabels2.decorateConfiguration(ctx.body.data, sourceUid);
+    }
+  };
+  controllers2.extend("plugin::content-manager.content-types", (controller) => ({
+    ...controller,
+    async findContentTypeConfiguration(ctx, next) {
+      await controller.findContentTypeConfiguration(ctx, next);
+      await decorateConfiguration(ctx, ctx.params.uid);
+    },
+    async updateContentTypeConfiguration(ctx, next) {
+      await controller.updateContentTypeConfiguration(ctx, next);
+      await decorateConfiguration(ctx, ctx.params.uid);
+    }
+  }));
+  controllers2.extend("plugin::content-manager.components", (controller) => ({
+    ...controller,
+    async findComponentConfiguration(ctx, next) {
+      await controller.findComponentConfiguration(ctx, next);
+      await decorateConfiguration(ctx, ctx.params.uid);
+    },
+    async updateComponentConfiguration(ctx, next) {
+      await controller.updateComponentConfiguration(ctx, next);
+      await decorateConfiguration(ctx, ctx.params.uid);
+    }
+  }));
+};
+const validateConfig = (config2) => {
+  if (!config2 || typeof config2 !== "object" || Array.isArray(config2) || !Array.isArray(config2.collections) || !config2.collections.every(
+    (collection) => typeof collection === "string"
+  )) {
+    throw new Error("The collections config must be an array of strings");
+  }
+};
+const config = {
+  default: {
+    collections: []
+  },
+  validator: validateConfig
+};
+const contentTypes = {};
+const settings$1 = ({ strapi }) => ({
+  async find(ctx) {
+    const data = await strapi.plugin("strapi-relation-names").service("settings").get();
+    ctx.body = { data };
+  },
+  async update(ctx) {
+    const body = ctx.request.body;
+    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);
+    ctx.body = { data };
+  }
+});
+const controllers = {
+  settings: settings$1
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: []
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.find",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.update",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "email",
+  "uid",
+  "enumeration",
+  "integer",
+  "biginteger",
+  "decimal",
+  "float",
+  "date",
+  "datetime",
+  "time",
+  "boolean"
+]);
+const isRecord$1 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const parseTemplate = (template) => {
+  if (!template.trim()) {
+    return null;
+  }
+  const placeholders = [];
+  let cursor = 0;
+  while (cursor < template.length) {
+    const openingBrace = template.indexOf("{", cursor);
+    const closingBrace = template.indexOf("}", cursor);
+    if (closingBrace !== -1 && (openingBrace === -1 || closingBrace < openingBrace)) {
+      return null;
+    }
+    if (openingBrace === -1) {
+      break;
+    }
+    const end = template.indexOf("}", openingBrace + 1);
+    if (end === -1) {
+      return null;
+    }
+    const name = template.slice(openingBrace + 1, end);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      return null;
+    }
+    placeholders.push(name);
+    cursor = end + 1;
+  }
+  return placeholders.length > 0 ? placeholders : null;
+};
+const compileTemplate = (template, targetSchema) => {
+  const placeholders = parseTemplate(template);
+  const attributes = targetSchema?.attributes ?? {};
+  if (!placeholders || !targetSchema) {
+    return null;
+  }
+  const valid = placeholders.every((name) => {
+    const attribute = attributes[name];
+    return Boolean(
+      attribute && attribute.private !== true && SCALAR_TYPES.has(attribute.type ?? "")
+    );
+  });
+  if (!valid) {
+    return null;
+  }
+  return {
+    template,
+    placeholders,
+    displayField: placeholders[0]
+  };
+};
+const renderTemplate = (compiled, values) => {
+  const rendered = compiled.template.replace(
+    /\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
+    (_match, name) => {
+      const value = values[name];
+      return value === null || value === void 0 ? "" : String(value);
+    }
+  );
+  return rendered.trim();
+};
+const getIdentity = (value, modelType) => modelType === "component" ? value.id : value.documentId ?? value.id;
+const matchesRelation = (source, candidate, targetModelType) => {
+  if (source.id !== void 0 && candidate.id === source.id) {
+    return true;
+  }
+  if (source.documentId !== void 0 && candidate.documentId === source.documentId) {
+    if (source.locale !== void 0 && candidate.locale !== source.locale) {
+      return false;
+    }
+    if (source.publishedAt !== void 0 && candidate.publishedAt !== source.publishedAt) {
+      return false;
+    }
+    return true;
+  }
+  return getIdentity(source, targetModelType) === getIdentity(candidate, targetModelType);
+};
+const applyLabel = (value, hydrated, runtime) => {
+  const label = renderTemplate(runtime, hydrated);
+  if (label) {
+    return { ...value, [runtime.displayField]: label };
+  }
+  if (runtime.displayField === runtime.originalMainField) {
+    return value;
+  }
+  const fallbackField = runtime.originalMainField === "id" ? "documentId" : runtime.originalMainField;
+  const fallback = Object.prototype.hasOwnProperty.call(hydrated, fallbackField) ? hydrated[fallbackField] : void 0;
+  return { ...value, [runtime.displayField]: fallback };
+};
+const relationValues = (value) => {
+  if (Array.isArray(value)) {
+    return value.filter(isRecord$1);
+  }
+  return isRecord$1(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) : null;
+  if (!compiled || !targetSchema) {
+    return null;
+  }
+  return {
+    ...compiled,
+    sourceUid,
+    targetUid: targetSchema.uid,
+    originalMainField: await getOriginalMainField(
+      strapi,
+      sourceSchema,
+      targetSchema,
+      targetField,
+      userAbility
+    )
+  };
+};
+const hydrateValues = async (strapi, ctx, runtime, values) => {
+  const targetSchema = strapi.getModel(runtime.targetUid);
+  const targetModelType = targetSchema.modelType;
+  const missingFields = runtime.placeholders.filter(
+    (field) => values.some((value) => !Object.prototype.hasOwnProperty.call(value, field))
+  );
+  if (missingFields.length === 0) {
+    return new Map(values.map((value) => [value, value]));
+  }
+  const identities = values.map((value) => getIdentity(value, targetModelType)).filter((identity) => identity !== void 0 && identity !== null);
+  if (identities.length === 0) {
+    return new Map(values.map((value) => [value, value]));
+  }
+  try {
+    const permissionChecker = strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: runtime.targetUid });
+    const fields = Array.from(
+      /* @__PURE__ */ new Set([
+        ...runtime.placeholders,
+        runtime.originalMainField,
+        "id",
+        "documentId",
+        "locale",
+        "publishedAt"
+      ])
+    );
+    const identityField = targetModelType === "component" ? "id" : "documentId";
+    const permissionQuery = await permissionChecker.sanitizedQuery.read({
+      fields,
+      filters: { [identityField]: { $in: identities } }
+    });
+    const query = strapi.get("query-params").transform(runtime.targetUid, permissionQuery);
+    const hydrated = await strapi.db.query(runtime.targetUid).findMany(query);
+    return new Map(
+      values.map((value) => [
+        value,
+        hydrated.find((candidate) => matchesRelation(value, candidate, targetModelType)) ?? value
+      ])
+    );
+  } catch {
+    return new Map(values.map((value) => [value, value]));
+  }
+};
+const relationLabels = ({ strapi }) => {
+  const getSettings = () => strapi.plugin("strapi-relation-names").service("settings").get();
+  const decorateRelationResults = async (ctx, sourceUid, targetField, results) => {
+    const settings2 = await getSettings();
+    if (!isCollectionEnabled(settings2.collections, sourceUid)) {
+      return results;
+    }
+    const runtime = await getRuntime(
+      strapi,
+      settings2,
+      sourceUid,
+      targetField,
+      ctx.state.userAbility
+    );
+    if (!runtime) {
+      return results;
+    }
+    const values = results.filter(isRecord$1);
+    const hydrated = await hydrateValues(strapi, ctx, runtime, values);
+    return results.map(
+      (result) => isRecord$1(result) ? applyLabel(result, hydrated.get(result) ?? result, runtime) : result
+    );
+  };
+  const decorateConfiguration = async (configuration, sourceUid) => {
+    if (!configuration || !isRecord$1(configuration.metadatas)) {
+      return configuration;
+    }
+    const settings2 = await getSettings();
+    const metadatas = { ...configuration.metadatas };
+    const relationNames = {};
+    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;
+      }
+      const targetSchema = strapi.getModel(attribute.target);
+      const compiled = compileTemplate(
+        settings2.relations[sourceUid]?.[fieldName] ?? "",
+        targetSchema
+      );
+      if (!compiled || !isRecord$1(metadata)) {
+        continue;
+      }
+      metadatas[fieldName] = {
+        ...metadata,
+        edit: {
+          ...isRecord$1(metadata.edit) ? metadata.edit : {},
+          mainField: compiled.displayField
+        },
+        list: {
+          ...isRecord$1(metadata.list) ? metadata.list : {},
+          mainField: compiled.displayField
+        }
+      };
+      relationNames[fieldName] = { mainField: compiled.displayField };
+    }
+    return {
+      ...configuration,
+      metadatas,
+      settings: {
+        ...isRecord$1(configuration.settings) ? configuration.settings : {},
+        relationNames
+      }
+    };
+  };
+  const decorateContentManagerConfiguration = async (data, sourceUid) => {
+    if (!isRecord$1(data)) {
+      return data;
+    }
+    const settings2 = await getSettings();
+    if (!isCollectionEnabled(settings2.collections, sourceUid)) {
+      return data;
+    }
+    const next = { ...data };
+    if (next.contentType) {
+      next.contentType = await decorateConfiguration(next.contentType, sourceUid);
+    }
+    if (next.component) {
+      next.component = await decorateConfiguration(next.component, sourceUid);
+    }
+    if (isRecord$1(next.components)) {
+      const components = { ...next.components };
+      for (const [uid, configuration] of Object.entries(components)) {
+        components[uid] = await decorateConfiguration(configuration, uid);
+      }
+      next.components = components;
+    }
+    return next;
+  };
+  const decorateCollectionResults = async (ctx, sourceUid, results) => {
+    const settings2 = await getSettings();
+    if (!isCollectionEnabled(settings2.collections, sourceUid)) {
+      return results;
+    }
+    const runtimeCache = /* @__PURE__ */ new Map();
+    const sourceSchemas = /* @__PURE__ */ new Map();
+    const getSchema = (uid) => {
+      if (!sourceSchemas.has(uid)) {
+        sourceSchemas.set(uid, strapi.getModel(uid));
+      }
+      return sourceSchemas.get(uid);
+    };
+    const visit = async (value, uid) => {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          await visit(item, uid);
+        }
+        return;
+      }
+      if (!isRecord$1(value)) {
+        return;
+      }
+      const schema = getSchema(uid);
+      for (const [fieldName, attribute] of Object.entries(schema?.attributes ?? {})) {
+        if (attribute.type === "relation" && attribute.target) {
+          const cacheKey = `${uid}:${fieldName}`;
+          if (!runtimeCache.has(cacheKey)) {
+            runtimeCache.set(
+              cacheKey,
+              await getRuntime(strapi, settings2, uid, fieldName, ctx.state.userAbility)
+            );
+          }
+          const runtime = runtimeCache.get(cacheKey);
+          if (runtime) {
+            const originalRelation = value[fieldName];
+            const relationItems = relationValues(originalRelation);
+            const hydrated = await hydrateValues(strapi, ctx, runtime, relationItems);
+            value[fieldName] = replaceRelationValue(
+              originalRelation,
+              relationItems,
+              hydrated,
+              runtime
+            );
+          }
+        }
+        if (attribute.type === "component" && attribute.component) {
+          await visit(value[fieldName], attribute.component);
+        }
+        if (attribute.type === "dynamiczone" && Array.isArray(attribute.components)) {
+          for (const item of relationValues(value[fieldName])) {
+            if (typeof item.__component === "string" && attribute.components.includes(item.__component)) {
+              await visit(item, item.__component);
+            }
+          }
+        }
+      }
+    };
+    for (const result of results) {
+      await visit(result, sourceUid);
+    }
+    return results;
+  };
+  return {
+    decorateCollectionResults,
+    decorateConfiguration: decorateContentManagerConfiguration,
+    decorateRelationResults,
+    compileTemplate,
+    parseTemplate,
+    renderTemplate
+  };
+};
+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: {} };
+  }
+  const relations = {};
+  for (const [sourceUid, sourceRelations] of Object.entries(value.relations)) {
+    if (!isRecord(sourceRelations)) {
+      continue;
+    }
+    const normalizedRelations = {};
+    for (const [fieldName, template] of Object.entries(sourceRelations)) {
+      if (typeof template === "string" && template.length > 0) {
+        normalizedRelations[fieldName] = template;
+      }
+    }
+    if (Object.keys(normalizedRelations).length > 0) {
+      relations[sourceUid] = normalizedRelations;
+    }
+  }
+  return { collections, relations };
+};
+const settings = ({ strapi }) => {
+  const getCollections = () => {
+    const config2 = strapi.config.get("plugin::strapi-relation-names");
+    return Array.isArray(config2?.collections) ? config2.collections.filter(
+      (collection) => typeof collection === "string"
+    ) : [];
+  };
+  const store = () => strapi.store({
+    type: "plugin",
+    name: PLUGIN_ID,
+    key: STORE_KEY
+  });
+  return {
+    async get() {
+      const value = await store().get();
+      return normalizeSettings(value ?? EMPTY_SETTINGS, getCollections());
+    },
+    async set(value) {
+      const normalized = normalizeSettings(value, getCollections());
+      await store().set({ value: normalized });
+      return normalized;
+    }
+  };
+};
+const services = {
+  "relation-labels": relationLabels,
+  settings
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

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

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

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

@@ -0,0 +1,12 @@
+type RelationNamesConfig = {
+    collections: string[];
+};
+declare const validateConfig: (config: unknown) => asserts config is RelationNamesConfig;
+declare const config: {
+    default: {
+        collections: any[];
+    };
+    validator: (config: unknown) => asserts config is RelationNamesConfig;
+};
+export { validateConfig };
+export default config;

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

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "strapi-relation-names";

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

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

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

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

@@ -0,0 +1,8 @@
+import { Core } from '@strapi/strapi';
+declare const settings: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(ctx: any): Promise<void>;
+    update(ctx: any): Promise<any>;
+};
+export default settings;

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

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

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

@@ -0,0 +1,66 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    config: {
+        default: {
+            collections: any[];
+        };
+        validator: (config: unknown) => asserts config is {
+            collections: string[];
+        };
+    };
+    controllers: {
+        settings: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            find(ctx: any): Promise<void>;
+            update(ctx: any): Promise<any>;
+        };
+    };
+    routes: {
+        'content-api': () => {
+            type: string;
+            routes: any[];
+        };
+        admin: () => {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: string[];
+                };
+            }[];
+        };
+    };
+    services: {
+        'relation-labels': ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            decorateCollectionResults: (ctx: any, sourceUid: string, results: unknown[]) => Promise<unknown[]>;
+            decorateConfiguration: (data: any, sourceUid: string) => Promise<any>;
+            decorateRelationResults: (ctx: any, sourceUid: string, targetField: string, results: unknown[]) => Promise<unknown[]>;
+            compileTemplate: (template: string, targetSchema: import('./services/utils/relation-labels').SchemaLike | undefined) => import('./services/utils/relation-labels').CompiledTemplate | null;
+            parseTemplate: (template: string) => string[] | null;
+            renderTemplate: (compiled: import('./services/utils/relation-labels').CompiledTemplate, values: Record<string, unknown>) => string;
+        };
+        settings: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            get(): Promise<import('./types').RelationNamesSettings>;
+            set(value: unknown): Promise<import('./types').RelationNamesSettings>;
+        };
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {};
+};
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

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

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;