@easy-cms/plugin-redirects 0.44.0 → 0.45.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { TypedPlugin } from '@easy-cms/core';
+import { TypedPlugin, RequestContext } from '@easy-cms/core';
 
 type Doc$1 = Record<string, unknown>;
 interface UrlArgs {
@@ -92,6 +92,9 @@ interface RedirectsCMS {
             readonly handler: unknown;
         }[];
     };
+    uniqueScope?(collection: string, field: string, options?: {
+        context?: RequestContext;
+    }): Promise<Record<string, unknown>>;
     find(collection: string, options: Record<string, unknown>): Promise<{
         docs: Doc[];
         hasNextPage: boolean;
@@ -108,6 +111,13 @@ interface Redirect {
  * `null` when it isn't a path.
  */
 declare function normalizePath(input: string): string | null;
+interface ResolveRedirectOptions {
+    /**
+     * The request's context (e.g. its tenant, `cms.forRequest(request)`): with redirects kept per
+     * scope (`uniqueWithin` of `from`), only that scope's apply.
+     */
+    readonly context?: RequestContext;
+}
 /** Forgets the cached redirects, so the next request reads them again. */
 declare function clearRedirects(cms: object): void;
 /**
@@ -120,7 +130,7 @@ declare function clearRedirects(cms: object): void;
  * if (redirect) return Response.redirect(new URL(redirect.location, request.url), redirect.status)
  * ```
  */
-declare function resolveRedirect(cms: RedirectsCMS, input: string | URL): Promise<Redirect | null>;
+declare function resolveRedirect(cms: RedirectsCMS, input: string | URL, options?: ResolveRedirectOptions): Promise<Redirect | null>;
 
 declare const STATUSES: readonly [301, 302, 307, 308];
 type RedirectStatus = (typeof STATUSES)[number];

package/dist/index.js

@@ -6,7 +6,7 @@ import {
 // src/info.ts
 var INFO = {
   name: "@easy-cms/plugin-redirects",
-  ...true ? { version: "0.44.0" } : {}
+  ...true ? { version: "0.45.0" } : {}
 };
 
 // src/shared.ts
@@ -31,12 +31,12 @@ var CACHE = /* @__PURE__ */ Symbol.for("easy-cms.plugin-redirects.cache");
 function clearRedirects(cms) {
   delete cms[CACHE];
 }
-async function resolveRedirect(cms, input) {
+async function resolveRedirect(cms, input, options = {}) {
   const url = typeof input === "string" ? safeUrl(input) : input;
   if (!url) return null;
   const path = normalizePath(url.pathname);
   if (!path) return null;
-  const found = (await redirects(cms)).get(path);
+  const found = (await redirects(cms, options)).get(path);
   if (!found) return null;
   const location = url.search && !found.location.includes("?") ? found.location + url.search : found.location;
   return { location, status: found.status };
@@ -55,22 +55,33 @@ function findSource(cms) {
   }
   throw new Error("resolveRedirect: add redirectsPlugin() to the plugins in your Easy CMS config");
 }
-function redirects(cms) {
+async function redirects(cms, options) {
   const source = findSource(cms);
+  const scope = options.context && cms.uniqueScope ? await cms.uniqueScope(source.slug, "from", { context: options.context }) : {};
+  const key = JSON.stringify(scope);
   const holder = cms;
-  const cached = holder[CACHE];
+  holder[CACHE] ??= /* @__PURE__ */ new Map();
+  const caches = holder[CACHE];
+  const cached = caches.get(key);
   if (cached && Date.now() - cached.at < source.cacheTTL) return cached.map;
-  const map = load(cms, source);
-  holder[CACHE] = { at: Date.now(), map };
+  const map = load(cms, source, scope);
+  caches.set(key, { at: Date.now(), map });
   map.catch(() => {
-    if (holder[CACHE]?.map === map) delete holder[CACHE];
+    if (caches.get(key)?.map === map) caches.delete(key);
   });
   return map;
 }
-async function load(cms, source) {
+async function load(cms, source, scope) {
   const map = /* @__PURE__ */ new Map();
+  const where = Object.entries(scope).map(([name, value]) => ({ [name]: { equals: value } }));
   for (let page = 1; ; page++) {
-    const result = await cms.find(source.slug, { depth: 0, sort: "id", limit: 500, page });
+    const result = await cms.find(source.slug, {
+      depth: 0,
+      sort: "id",
+      limit: 500,
+      page,
+      ...where.length ? { where: { and: where } } : {}
+    });
     for (const doc of result.docs) {
       const from = typeof doc.from === "string" ? normalizePath(doc.from) : null;
       if (!from) continue;
@@ -233,20 +244,30 @@ function redirectsPlugin(options = {}) {
         const to = now[i];
         if (!from || !to || from === to || done.has(from)) continue;
         done.add(from);
-        await addRedirect(cms, { from, collection: s, id: doc.id, locale, current: to });
+        await addRedirect(cms, { from, collection: s, id: doc.id, locale, current: to, doc });
       }
     };
     const addRedirect = async (cms, args) => {
-      const loops = await cms.find(slug, { where: { from: { equals: args.current } }, limit: 100 });
+      const from = cms.config.collections.find((c) => c.slug === slug)?.fields.find((f) => f.name === "from");
+      const scope = Object.fromEntries(
+        (from?.uniqueWithin === void 0 ? [] : [from.uniqueWithin].flat()).map((name) => [
+          name,
+          args.doc[name] ?? null
+        ])
+      );
+      const inScope = Object.entries(scope).map(([name, value]) => ({ [name]: { equals: value } }));
+      const where = (path) => ({ and: [{ from: { equals: path } }, ...inScope] });
+      const loops = await cms.find(slug, { where: where(args.current), limit: 100 });
       for (const loop of loops.docs) await cms.delete(slug, loop.id);
       const data = {
         from: args.from,
         to: null,
         [targetField(args.collection)]: args.id,
         ...locales.length > 0 ? { locale: args.locale } : {},
-        type: "301"
+        type: "301",
+        ...scope
       };
-      const existing = await cms.find(slug, { where: { from: { equals: args.from } }, limit: 1 });
+      const existing = await cms.find(slug, { where: where(args.from), limit: 1 });
       if (existing.docs[0]) await cms.update(slug, existing.docs[0].id, data);
       else await cms.create(slug, data);
     };
@@ -267,11 +288,11 @@ function redirectsPlugin(options = {}) {
       method: "get",
       // Lets `resolveRedirect(cms)` find these options from the resolved config.
       handler: Object.assign(
-        async ({ url, cms }) => {
+        async ({ url, cms, context }) => {
           const path = url.searchParams.get("path");
           if (!path)
             return Response.json({ errors: [{ message: "path is required" }] }, { status: 400 });
-          const redirect = await resolveRedirect(cms, path);
+          const redirect = await resolveRedirect(cms, path, { context });
           if (!redirect)
             return Response.json({ errors: [{ message: "No redirect" }] }, { status: 404 });
           return Response.json(redirect, { headers: { "cache-control": "public, max-age=60" } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easy-cms/plugin-redirects",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Redirects for Easy CMS: 301s managed in the admin, automatic redirects when a page's address changes",
   "license": "MIT",
   "type": "module",
@@ -16,11 +16,11 @@
     "dist"
   ],
   "peerDependencies": {
-    "@easy-cms/core": "^0.44.0"
+    "@easy-cms/core": "^0.45.0"
   },
   "devDependencies": {
-    "@easy-cms/core": "^0.44.0",
-    "@easy-cms/db-sqlite": "^0.44.0"
+    "@easy-cms/core": "^0.45.0",
+    "@easy-cms/db-sqlite": "^0.45.0"
   },
   "engines": {
     "node": ">=22.12"