strapi-plugin-document-metadata 1.0.1

package/dist/admin/index.mjs

@@ -0,0 +1,312 @@
+import { useRef, useEffect, useState } from "react";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useLocation } from "react-router-dom";
+import { useFetchClient, useQueryParams, unstable_useDocument } from "@strapi/strapi/admin";
+import { Grid, Typography, Box, Flex, Divider } from "@strapi/design-system";
+import { Paperclip } from "@strapi/icons";
+import { useIntl, FormattedMessage } from "react-intl";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "document-metadata";
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const prefixKey = (key) => `${PLUGIN_ID}.${key}`;
+const relativeDateFormatter = (date, textBuilder) => {
+  const today = /* @__PURE__ */ new Date();
+  if (today.toDateString() === date.toDateString()) {
+    return textBuilder.today(date.toLocaleTimeString());
+  }
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (yesterday.toDateString() === date.toDateString()) {
+    return textBuilder.yesterday(date.toLocaleTimeString());
+  }
+  return textBuilder.other(date.toLocaleString());
+};
+const config$3 = {
+  /** The threshold in minutes to determine if a date is considered "recent". */
+  thresholdInMinutes: 60
+};
+const recentTimeFormatter = ({
+  date,
+  fallbackFormatter
+}) => {
+  const now = /* @__PURE__ */ new Date();
+  const minutesElapsedSinceNow = minutesElapsed(now, date);
+  if (minutesElapsedSinceNow >= config$3.thresholdInMinutes) {
+    return fallbackFormatter(date);
+  }
+  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+  return rtf.format(-minutesElapsedSinceNow, "minutes");
+};
+const minutesElapsed = (now, then) => {
+  const millisecondsPerMinute = 60 * 1e3;
+  return Math.floor((now.getTime() - then.getTime()) / millisecondsPerMinute);
+};
+const MetadataRow = ({ title, line1, line2 }) => {
+  return /* @__PURE__ */ jsxs(Grid.Item, { direction: "column", alignItems: "stretch", children: [
+    /* @__PURE__ */ jsx(Typography, { variant: "sigma", children: title }),
+    /* @__PURE__ */ jsxs(Typography, { variant: "pi", textColor: "neutral600", children: [
+      line1,
+      /* @__PURE__ */ jsx("br", {}),
+      line2
+    ] })
+  ] });
+};
+var FetchStatus = /* @__PURE__ */ ((FetchStatus2) => {
+  FetchStatus2["Initial"] = "initial";
+  FetchStatus2["InProgress"] = "in-progress";
+  FetchStatus2["Success"] = "success";
+  FetchStatus2["Failure"] = "failure";
+  return FetchStatus2;
+})(FetchStatus || {});
+const config$2 = {
+  /** The configuration for the last-opened request. */
+  lastOpenedRequest: {
+    /** The path to fetch the last-opened metadata for the entity with the given `uid` and `documentId`. */
+    path: (uid, documentId) => `/document-metadata/last-opened/${uid}/${documentId}`
+  }
+};
+const useLastOpened = ({
+  uid,
+  documentId,
+  locale
+}) => {
+  const fetchClient = useFetchClient();
+  const [lastOpenedFetchState, setLastOpenedFetchState] = useState({
+    status: "initial"
+    /* Initial */
+  });
+  useEffect(() => {
+    const fetchLastOpened = async () => {
+      setLastOpenedFetchState({
+        status: "in-progress"
+        /* InProgress */
+      });
+      try {
+        const { data: lastOpened } = await fetchClient.get(
+          config$2.lastOpenedRequest.path(uid, documentId),
+          {
+            params: { locale }
+          }
+        );
+        setLastOpenedFetchState({ status: "success", lastOpened });
+      } catch (error) {
+        console.error(`Failed to fetch last-opened metadata: ${error}`);
+        setLastOpenedFetchState({ status: "failure", error });
+      }
+    };
+    fetchLastOpened();
+  }, [uid, documentId, locale]);
+  return lastOpenedFetchState;
+};
+const config$1 = {
+  /** The loading text to show while fetching data. */
+  loadingString: "…",
+  /** The non-breaking space character. */
+  nonBreakingSpace: " "
+};
+const LastOpenedMetadataLoader = ({
+  uid,
+  documentId,
+  locale
+}) => {
+  const { formatMessage } = useIntl();
+  const translate = (key, values) => formatMessage({ id: prefixKey(key) }, values);
+  const lastOpenedFetchState = useLastOpened({ uid, documentId, locale });
+  switch (lastOpenedFetchState.status) {
+    case FetchStatus.Initial:
+    case FetchStatus.InProgress:
+      return /* @__PURE__ */ jsx(
+        MetadataRow,
+        {
+          title: translate("opened-at"),
+          line1: config$1.loadingString,
+          line2: config$1.nonBreakingSpace
+        }
+      );
+    case FetchStatus.Failure:
+      return null;
+    case FetchStatus.Success:
+      const lastOpened = lastOpenedFetchState.lastOpened;
+      if (!lastOpened.openedAt || !lastOpened.openedBy) {
+        return /* @__PURE__ */ jsx(MetadataRow, { title: translate("opened-at"), line1: translate("opened-first-time") });
+      }
+      const formattedOpenedAt = recentTimeFormatter({
+        date: new Date(lastOpened.openedAt),
+        fallbackFormatter: (date) => relativeDateFormatter(date, {
+          today: (formattedTime) => translate("date.today", { formattedTime }),
+          yesterday: (formattedTime) => translate("date.yesterday", { formattedTime }),
+          other: (formattedDate) => translate("date.other", { formattedDate })
+        })
+      });
+      const formattedOpenedBy = translate("opened-by", { username: lastOpened.openedBy });
+      return /* @__PURE__ */ jsx(
+        MetadataRow,
+        {
+          title: translate("opened-at"),
+          line1: formattedOpenedAt,
+          line2: formattedOpenedBy
+        }
+      );
+  }
+};
+const LastOpenedMetadataGuard = ({
+  uid,
+  document
+}) => {
+  const hasLastOpenedFields = "openedAt" in document && "openedBy" in document;
+  if (!hasLastOpenedFields) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(LastOpenedMetadataLoader, { uid, documentId: document.documentId, locale: document.locale });
+};
+const DocumentMetadataCard = ({
+  collectionType,
+  uid,
+  documentId
+}) => {
+  const { formatMessage } = useIntl();
+  const translate = (key, values) => formatMessage({ id: prefixKey(key) }, values);
+  const initialParams = { plugins: { i18n: { locale: void 0 } } };
+  const [queryParams, _] = useQueryParams(initialParams);
+  const locale = queryParams.query.plugins.i18n.locale;
+  const { document } = unstable_useDocument({ documentId, model: uid, collectionType, params: { locale } });
+  if (!document) {
+    return null;
+  }
+  const formatDate = (date) => recentTimeFormatter({
+    date: new Date(date),
+    fallbackFormatter: (date2) => relativeDateFormatter(date2, {
+      today: (formattedTime) => translate("date.today", { formattedTime }),
+      yesterday: (formattedTime) => translate("date.yesterday", { formattedTime }),
+      other: (formattedDate) => translate("date.other", { formattedDate })
+    })
+  });
+  const formatUsername = (user) => `${user.firstname} ${user.lastname}`;
+  let formattedUpdatedAt = formatDate(new Date(document.updatedAt));
+  let formattedUpdatedBy = document.updatedBy ? translate("updated-by", { username: formatUsername(document.updatedBy) }) : "";
+  let formattedCreatedAt = formatDate(new Date(document.createdAt));
+  let formattedCreatedBy = document.createdBy ? translate("created-by", { username: formatUsername(document.createdBy) }) : "";
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      width: "100%",
+      padding: "16px",
+      background: "neutral0",
+      hasRadius: true,
+      borderColor: "neutral200",
+      borderStyle: "solid",
+      borderWidth: "1px",
+      children: /* @__PURE__ */ jsxs(Grid.Root, { gap: "8px", gridCols: 1, children: [
+        /* @__PURE__ */ jsxs(Grid.Item, { direction: "column", alignItems: "stretch", children: [
+          /* @__PURE__ */ jsxs(Flex, { gap: "8px", direction: "row", alignItems: "center", justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: /* @__PURE__ */ jsx(FormattedMessage, { id: prefixKey("title") }) }),
+            /* @__PURE__ */ jsx(Paperclip, { fill: "neutral600", style: { marginRight: "4px" } })
+          ] }),
+          /* @__PURE__ */ jsx(Divider, { style: { marginTop: "6px", marginBottom: "4px" } })
+        ] }),
+        /* @__PURE__ */ jsx(LastOpenedMetadataGuard, { uid, document }),
+        /* @__PURE__ */ jsx(
+          MetadataRow,
+          {
+            title: translate("updated-at"),
+            line1: formattedUpdatedAt,
+            line2: formattedUpdatedBy
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          MetadataRow,
+          {
+            title: translate("created-at"),
+            line1: formattedCreatedAt,
+            line2: formattedCreatedBy
+          }
+        )
+      ] })
+    }
+  );
+};
+const config = {
+  /**
+   * The supported collection type.
+   * We currently only support "collection-types", as "single-types" don't have their document ID as part of the URL.
+   */
+  supportedCollectionType: "collection-types",
+  /**
+   * The expected length of a valid document ID.
+   *
+   * > To address this limitation, Strapi 5 introduced documentId, a 24-character alphanumeric string, as a unique and
+   * > persistent identifier for a content entry, independent of its physical records.
+   *
+   * https://docs.strapi.io/cms/api/document-service
+   */
+  documentIdLength: 24
+};
+const DocumentMetadataGuard = () => {
+  const location = useLocation();
+  const urlPathComponents = location.pathname.split("/").filter(Boolean);
+  const [collectionType, uid, documentId] = urlPathComponents.slice(-3);
+  const isValidCollectionType = collectionType === config.supportedCollectionType;
+  const isValidUID = uid && uid.length;
+  const isValidDocumentId = documentId && documentId.length === config.documentIdLength;
+  if (!isValidCollectionType || !isValidUID || !isValidDocumentId) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    DocumentMetadataCard,
+    {
+      collectionType,
+      uid,
+      documentId
+    }
+  );
+};
+const index = {
+  register(app) {
+    app.getPlugin("content-manager").injectComponent("editView", "right-links", {
+      name: "DocumentMetadataGuard",
+      Component: DocumentMetadataGuard
+    });
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => import("../_chunks/en-h9IAaoUJ.mjs") }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+export {
+  index as default
+};

package/dist/admin/src/components/DocumentMetadataCard/index.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionType, ContentTypeUID, DocumentID } from '../../types';
+/**
+ * Renders a document metadata card showing various metadata about the given document.
+ */
+declare const DocumentMetadataCard: ({ collectionType, uid, documentId, }: {
+    collectionType: CollectionType;
+    uid: ContentTypeUID;
+    documentId: DocumentID;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default DocumentMetadataCard;

package/dist/admin/src/components/DocumentMetadataGuard/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A wrapper component that conditionally renders the `DocumentMetadataCard` and its contents
+ * when the current document being edited is supported.
+ */
+declare const DocumentMetadataGuard: () => import("react/jsx-runtime").JSX.Element | null;
+export default DocumentMetadataGuard;

package/dist/admin/src/components/Initializer/index.d.ts

@@ -0,0 +1,5 @@
+type InitializerProps = {
+    setPlugin: (id: string) => void;
+};
+declare const Initializer: ({ setPlugin }: InitializerProps) => null;
+export { Initializer };

package/dist/admin/src/components/LastOpenedMetadataGuard/index.d.ts

@@ -0,0 +1,10 @@
+import type { AnyDocument, ContentTypeUID } from '../../types';
+/**
+ * A wrapper component that conditionally renders the `LastOpenedMetadataLoader`
+ * when the current content-type being edited contains the last-opened fields.
+ */
+declare const LastOpenedMetadataGuard: ({ uid, document, }: {
+    uid: ContentTypeUID;
+    document: AnyDocument;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default LastOpenedMetadataGuard;

package/dist/admin/src/components/LastOpenedMetadataLoader/index.d.ts

@@ -0,0 +1,10 @@
+import type { ContentTypeUID, DocumentID } from '../../types';
+/**
+ * Fetches the last-opened metadata for the given document.
+ */
+declare const LastOpenedMetadataLoader: ({ uid, documentId, locale, }: {
+    uid: ContentTypeUID;
+    documentId: DocumentID;
+    locale: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default LastOpenedMetadataLoader;

package/dist/admin/src/components/LastOpenedMetadataLoader/useLastOpened.d.ts

@@ -0,0 +1,31 @@
+import type { ContentTypeUID, DocumentID, LastOpened } from '../../types';
+/**
+ * Represents the different states of a fetch workflow.
+ */
+export declare enum FetchStatus {
+    Initial = "initial",
+    InProgress = "in-progress",
+    Success = "success",
+    Failure = "failure"
+}
+/**
+ * A discriminated union describing the current state of last-opened fetch process.
+ * Each state can optionally include payload data relevant to that stage.
+ */
+type LastOpenedFetchState = {
+    status: FetchStatus.Initial;
+} | {
+    status: FetchStatus.InProgress;
+} | {
+    status: FetchStatus.Success;
+    lastOpened: LastOpened;
+} | {
+    status: FetchStatus.Failure;
+    error: any;
+};
+export declare const useLastOpened: ({ uid, documentId, locale, }: {
+    uid: ContentTypeUID;
+    documentId: DocumentID;
+    locale: string | undefined;
+}) => LastOpenedFetchState;
+export {};

package/dist/admin/src/components/MetadataRow/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Displays a single metadata row consisting of a title and one or two lines of descriptive text.
+ */
+declare const MetadataRow: ({ title, line1, line2 }: {
+    title: string;
+    line1: string;
+    line2?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default MetadataRow;

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

@@ -0,0 +1,10 @@
+declare const _default: {
+    register(app: any): void;
+    registerTrads({ locales }: {
+        locales: string[];
+    }): Promise<{
+        data: any;
+        locale: string;
+    }[]>;
+};
+export default _default;

package/dist/admin/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "document-metadata";

package/dist/admin/src/utils/prefixKey.d.ts

@@ -0,0 +1,2 @@
+declare const prefixKey: (key: string) => string;
+export { prefixKey };

package/dist/admin/src/utils/recentTimeFormatter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Formats a given `Date` object into a human-readable string for **recent dates**,
+ * and delegates to a fallback formatter for older dates.
+ *
+ * - If the date is within the **last 60 minutes**, it returns a relative time string like `"5 minutes ago"`.
+ * - Otherwise, it falls back to the `relativeDateFormatter()` function for formatting.
+ *
+ * @param params.date - The `Date` object to format.
+ * @param params.fallbackFormatter - A function that formats dates which are not considered "recent".
+ *
+ * @returns A human-readable relative date string based on the provided date.
+ */
+export declare const recentTimeFormatter: ({ date, fallbackFormatter, }: {
+    date: Date;
+    fallbackFormatter: (date: Date) => string;
+}) => string;

package/dist/admin/src/utils/relativeDateFormatter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Defines a set of functions that build human-readable text for relative dates.
+ *
+ * This interface allows customization of how "today", "yesterday",
+ * and "other" dates are represented in formatted output.
+ *
+ * Example:
+ * ```ts
+ * const textBuilder: RelativeDateTextBuilder = {
+ *   today: (time) => `Today at ${time}`,
+ *   yesterday: (time) => `Yesterday at ${time}`,
+ *   other: (date) => date,
+ * };
+ * ```
+ */
+interface RelativeDateTextBuilder {
+    today: (formattedTime: string) => string;
+    yesterday: (formattedTime: string) => string;
+    other: (formattedDate: string) => string;
+}
+/**
+ * Formats a given `Date` object into a human-readable, relative date string.
+ *
+ * @param date - The `Date` object to format.
+ * @param textBuilder - A builder object that defines how to format "today", "yesterday", and other dates.
+ *
+ * @returns A human-readable relative date string based on the provided date.
+ */
+export declare const relativeDateFormatter: (date: Date, textBuilder: RelativeDateTextBuilder) => string;
+export {};

package/dist/server/index.js

@@ -0,0 +1,119 @@
+"use strict";
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  /**
+   * Controller method for the route that fetches and updates the last-opened fields
+   * of a document with the given `uid` and `documentId` path parameters (GET request).
+   */
+  async lastOpened(ctx) {
+    const { uid, documentId } = ctx.params;
+    const { locale } = ctx.request.query;
+    const previousLastOpened = await strapi.plugin("document-metadata").service("service").fetchLastOpened({ uid, documentId, locale });
+    const openedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const { user } = ctx.state;
+    const openedBy = `${user.firstname} ${user.lastname}`;
+    await strapi.plugin("document-metadata").service("service").updateLastOpened({ uid, documentId, locale, openedAt, openedBy });
+    ctx.response.body = previousLastOpened;
+  }
+});
+const controllers = {
+  controller
+};
+const middlewares = {};
+const policies = {};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/last-opened/:uid/:documentId",
+      handler: "controller.lastOpened",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  admin
+};
+const service = ({ strapi }) => ({
+  /**
+   * Fetches the last-opened fields for a specific document within a content type.
+   *
+   * @param uid - The unique identifier of the content type (e.g. 'api::products.products').
+   * @param documentId - The ID of the document to fetch.
+   * @param locale - The current locale of the content type / `undefined` if localization is turned off.
+   */
+  fetchLastOpened: async ({
+    uid,
+    documentId,
+    locale
+  }) => {
+    return await strapi.documents(uid).findOne({
+      documentId,
+      fields: ["openedAt", "openedBy"],
+      locale
+    });
+  },
+  /**
+   * Updates the last-opened fields for a specific document within a content type.
+   *
+   * @param uid - The unique identifier of the content type (e.g. 'api::products.products').
+   * @param documentId - The ID of the document to update.
+   * @param locale - The current locale of the content type / `undefined` if localization is turned off.
+   * @param openedAt - The date and time when the document was last opened.
+   * @param openedBy - The name of the user who last opened the document.
+   */
+  async updateLastOpened({
+    uid,
+    documentId,
+    locale,
+    openedAt,
+    openedBy
+  }) {
+    const tableName = strapi.getModel(uid).collectionName;
+    if (!tableName) {
+      throw new Error(
+        `Expected to have a collection name for the content type "${uid}" at this point.`
+      );
+    }
+    return await strapi.db.connection(tableName).update({
+      opened_at: openedAt,
+      opened_by: openedBy
+    }).where({
+      document_id: documentId,
+      // We explicitly need to provide `null` here, cause in the database
+      // the locale is stored as `NULL` when localization is turned off.
+      // Without this fallback, the query would not match any rows.
+      locale: locale || null
+    });
+  }
+});
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;