@raketa-cloud/admin 1.9.5 → 1.9.7

package/dist/application.css

@@ -749,40 +749,6 @@ select {
   --tw-contain-style:  ;
 }
 
-.container {
-  width: 100%;
-}
-
-@media (min-width: 640px) {
-  .container {
-    max-width: 640px;
-  }
-}
-
-@media (min-width: 768px) {
-  .container {
-    max-width: 768px;
-  }
-}
-
-@media (min-width: 1024px) {
-  .container {
-    max-width: 1024px;
-  }
-}
-
-@media (min-width: 1280px) {
-  .container {
-    max-width: 1280px;
-  }
-}
-
-@media (min-width: 1536px) {
-  .container {
-    max-width: 1536px;
-  }
-}
-
 /* Utils */
 
 .chip {
@@ -3557,6 +3523,10 @@ body {
   background-color: rgb(124 45 18 / 0.5);
 }
 
+.dark\:bg-orange-950\/40:where(.dark, .dark *) {
+  background-color: rgb(67 20 7 / 0.4);
+}
+
 .dark\:bg-raketa-primary\/15:where(.dark, .dark *) {
   background-color: rgba(var(--primary), 0.15);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.9.5",
+  "version": "1.9.7",
   "main": "src/index.js",
   "files": [
     "src/",
@@ -37,7 +37,7 @@
     "chart.js": "4.5.1",
     "ejs": "6.0.1",
     "graphql-request": "7.4.0",
-    "hono": "4.12.34",
+    "hono": "4.13.7",
     "lru-cache": "11.5.2"
   },
   "overrides": {

package/src/cloud/Resources.js

@@ -156,7 +156,7 @@ export default class Resources extends RaketaClient {
     return { resource, errors };
   }
 
-  appendWorkflow(input, workflow) {
+  appendWorkflow(input, workflow, previewParams = {}) {
     if (!workflow?.type) {
       return;
     }
@@ -165,9 +165,9 @@ export default class Resources extends RaketaClient {
       type: workflow.type,
       previewUrl: buildMagicPreviewAddress(
         {
-          slug: input.resource.slug,
-          locale: input.locale,
-          resourceType: input.resource.resourceType,
+          slug: previewParams.slug,
+          locale: previewParams.locale,
+          resourceType: previewParams.resourceType,
         },
         this.getConfig(),
       ),
@@ -200,23 +200,11 @@ export default class Resources extends RaketaClient {
       translations,
     };
 
-    if (workflow?.type) {
-      input.workflow = {
-        type: workflow.type,
-        previewUrl: buildMagicPreviewAddress(
-          {
-            slug: paramsCopy.slug,
-            locale: sourceLocale || locales[0],
-            resourceType,
-          },
-          this.getConfig(),
-        ),
-      };
-
-      if (workflow.due_date) {
-        input.workflow.dueDate = toUTCISO8601String(workflow.due_date);
-      }
-    }
+    this.appendWorkflow(input, workflow, {
+      slug: paramsCopy.slug,
+      locale: sourceLocale,
+      resourceType,
+    });
 
     const {
       multiTranslateResource: { resources, errors, localeErrors },

package/src/cloud/documents/resourcesDocuments.js

@@ -44,16 +44,7 @@ function resourceFragment() {
       tags ${tagFragment()}
       categories ${categoryFragment()}
       changes ${summaryChangeFragment()}
-      activeContentTask {
-        id
-        workflow
-        operator
-        operatorMeta
-        completedAt
-        failedAt
-        insertedAt
-        updatedAt
-      }
+      activeContentTask ${contentTaskFragment()}
     }
   `;
 }

package/src/helpers/content_tasks_helper.js

@@ -23,3 +23,27 @@ export const buildResourceUrl = (resource, globalConfig) => {
 
   return `/${locale}/${route}/${id}`;
 };
+
+export const hasUnattachedKeys = (task) => {
+  if (!task || task.completedAt || task.failedAt) return false;
+
+  const unattachedKeys = task.lokaliseWorkflow?.settings?.unattached_keys;
+  const ids = unattachedKeys?.ids;
+
+  if (Array.isArray(ids)) {
+    return ids.length > 0;
+  }
+
+  return Boolean(ids);
+};
+
+export const unattachedKeyIds = (task) => {
+  const unattachedKeys = task?.lokaliseWorkflow?.settings?.unattached_keys;
+  const ids = unattachedKeys?.ids;
+
+  if (Array.isArray(ids)) {
+    return ids.join(", ");
+  }
+
+  return ids ? String(ids) : "";
+};

package/src/magicPreview.js

@@ -8,9 +8,10 @@ import {
 const ALGORITHM = "aes-256-gcm";
 const IV_LENGTH = 12;
 const TAG_LENGTH = 16;
+const CHUNK_SIZE = 40;
 
 function getSecretKey(config = {}) {
-  const secret = config.secrets.crypto_secret;
+  const secret = config.secrets?.crypto_secret;
 
   if (!secret) {
     throw new Error(
@@ -21,6 +22,40 @@ function getSecretKey(config = {}) {
   return createHash("sha256").update(secret).digest();
 }
 
+export function chunkToken(token, chunkSize = CHUNK_SIZE) {
+  if (!token || typeof token !== "string") {
+    return token;
+  }
+
+  const chunks = [];
+  for (let i = 0; i < token.length; i += chunkSize) {
+    chunks.push(token.slice(i, i + chunkSize));
+  }
+
+  return chunks.join("-");
+}
+
+export function unchunkToken(token, chunkSize = CHUNK_SIZE) {
+  if (!token || typeof token !== "string") {
+    return token;
+  }
+
+  let result = "";
+  let i = 0;
+
+  while (i < token.length) {
+    const chunk = token.slice(i, i + chunkSize);
+    result += chunk;
+    i += chunkSize;
+
+    if (i < token.length && token[i] === "-") {
+      i += 1;
+    }
+  }
+
+  return result;
+}
+
 export function generateMagicPreviewToken(
   { slug, resourceType, locale } = {},
   config = {},
@@ -40,17 +75,14 @@ export function generateMagicPreviewToken(
   ]);
   const tag = cipher.getAuthTag();
 
-  return Buffer.concat([iv, tag, encrypted]).toString("base64url");
-}
+  const rawToken = Buffer.concat([iv, tag, encrypted]).toString("base64url");
 
-export function decipherMagicPreviewToken(token, config) {
-  if (!token || typeof token !== "string") {
-    return null;
-  }
+  return chunkToken(rawToken);
+}
 
+function decipherPayload(rawToken, key) {
   try {
-    const key = getSecretKey(config);
-    const combined = Buffer.from(token, "base64url");
+    const combined = Buffer.from(rawToken, "base64url");
 
     if (combined.length < IV_LENGTH + TAG_LENGTH) {
       return null;
@@ -80,6 +112,31 @@ export function decipherMagicPreviewToken(token, config) {
   }
 }
 
+export function decipherMagicPreviewToken(token, config) {
+  if (!token || typeof token !== "string") {
+    return null;
+  }
+
+  try {
+    const key = getSecretKey(config);
+
+    const unchunked = unchunkToken(token);
+    const payload = decipherPayload(unchunked, key);
+
+    if (payload) {
+      return payload;
+    }
+
+    if (unchunked !== token) {
+      return decipherPayload(token, key);
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export function buildMagicPreviewAddress(
   { slug, resourceType, locale },
   globalConfig,

package/src/tests/helpers/content_tasks_helper.test.js

@@ -1,6 +1,8 @@
 import {
   workflowsMap,
   buildResourceUrl,
+  hasUnattachedKeys,
+  unattachedKeyIds,
 } from "../../helpers/content_tasks_helper";
 
 describe("content_tasks_helper", () => {
@@ -65,4 +67,107 @@ describe("content_tasks_helper", () => {
       );
     });
   });
+
+  describe("hasUnattachedKeys", () => {
+    test("returns false when task is null or undefined", () => {
+      expect(hasUnattachedKeys(null)).toBe(false);
+      expect(hasUnattachedKeys(undefined)).toBe(false);
+    });
+
+    test("returns false when task is completed or failed", () => {
+      expect(
+        hasUnattachedKeys({
+          completedAt: "2024-01-01T00:00:00Z",
+          lokaliseWorkflow: { settings: { unattached_keys: { ids: [1, 2] } } },
+        }),
+      ).toBe(false);
+
+      expect(
+        hasUnattachedKeys({
+          failedAt: "2024-01-01T00:00:00Z",
+          lokaliseWorkflow: { settings: { unattached_keys: { ids: [1, 2] } } },
+        }),
+      ).toBe(false);
+    });
+
+    test("returns false when task has no lokaliseWorkflow or settings", () => {
+      expect(hasUnattachedKeys({ completedAt: null, failedAt: null })).toBe(
+        false,
+      );
+      expect(
+        hasUnattachedKeys({
+          completedAt: null,
+          failedAt: null,
+          lokaliseWorkflow: {},
+        }),
+      ).toBe(false);
+      expect(
+        hasUnattachedKeys({
+          completedAt: null,
+          failedAt: null,
+          lokaliseWorkflow: { settings: {} },
+        }),
+      ).toBe(false);
+    });
+
+    test("returns false when unattached_keys has empty ids array or null", () => {
+      expect(
+        hasUnattachedKeys({
+          completedAt: null,
+          failedAt: null,
+          lokaliseWorkflow: { settings: { unattached_keys: { ids: [] } } },
+        }),
+      ).toBe(false);
+
+      expect(
+        hasUnattachedKeys({
+          completedAt: null,
+          failedAt: null,
+          lokaliseWorkflow: { settings: { unattached_keys: null } },
+        }),
+      ).toBe(false);
+    });
+
+    test("returns true when task is in progress and has unattached key ids", () => {
+      expect(
+        hasUnattachedKeys({
+          completedAt: null,
+          failedAt: null,
+          lokaliseWorkflow: {
+            settings: { unattached_keys: { ids: [101, 102] } },
+          },
+        }),
+      ).toBe(true);
+    });
+  });
+
+  describe("unattachedKeyIds", () => {
+    test("returns empty string when no unattached keys exist", () => {
+      expect(unattachedKeyIds(null)).toBe("");
+      expect(unattachedKeyIds({})).toBe("");
+      expect(
+        unattachedKeyIds({
+          lokaliseWorkflow: { settings: { unattached_keys: {} } },
+        }),
+      ).toBe("");
+    });
+
+    test("returns comma separated string of ids", () => {
+      expect(
+        unattachedKeyIds({
+          lokaliseWorkflow: {
+            settings: { unattached_keys: { ids: [101, 102, 103] } },
+          },
+        }),
+      ).toBe("101, 102, 103");
+
+      expect(
+        unattachedKeyIds({
+          lokaliseWorkflow: {
+            settings: { unattached_keys: { ids: ["key_a", "key_b"] } },
+          },
+        }),
+      ).toBe("key_a, key_b");
+    });
+  });
 });

package/src/tests/magicPreview.test.js

@@ -1,7 +1,9 @@
 import {
   buildMagicPreviewAddress,
+  chunkToken,
   decipherMagicPreviewToken,
   generateMagicPreviewToken,
+  unchunkToken,
 } from "../magicPreview";
 
 describe("magicPreview helper", () => {
@@ -104,6 +106,13 @@ describe("magicPreview helper", () => {
       expect(typeof token).toBe("string");
       expect(token).not.toContain("my-first-ebook");
 
+      // Verify token contains dashes breaking it into chunks of at most 40 characters
+      const chunks = token.split("-");
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(40);
+      }
+
       const payload = decipherMagicPreviewToken(token, config);
       expect(payload).not.toBeNull();
       expect(payload.slug).toBe("my-first-ebook");
@@ -111,9 +120,40 @@ describe("magicPreview helper", () => {
       expect(payload.locale).toBe("en");
     });
 
+    it("deciphers legacy unchunked tokens without dashes", () => {
+      // Manually produce a legacy unchunked token
+      const {
+        createCipheriv,
+        createHash,
+        randomBytes,
+      } = require("node:crypto");
+      const key = createHash("sha256")
+        .update(config.secrets.crypto_secret)
+        .digest();
+      const iv = randomBytes(12);
+      const cipher = createCipheriv("aes-256-gcm", key, iv);
+      const payload = {
+        slug: "legacy-post",
+        resourceType: "post",
+        locale: "de",
+      };
+      const encrypted = Buffer.concat([
+        cipher.update(JSON.stringify(payload), "utf8"),
+        cipher.final(),
+      ]);
+      const tag = cipher.getAuthTag();
+      const legacyToken = Buffer.concat([iv, tag, encrypted]).toString(
+        "base64url",
+      );
+
+      const deciphered = decipherMagicPreviewToken(legacyToken, config);
+      expect(deciphered).toEqual(payload);
+    });
+
     it("returns null on invalid / tampered token", () => {
       expect(decipherMagicPreviewToken("", config)).toBeNull();
       expect(decipherMagicPreviewToken(null, config)).toBeNull();
+      expect(decipherMagicPreviewToken(123, config)).toBeNull();
       expect(decipherMagicPreviewToken("invalid-token", config)).toBeNull();
 
       const token = generateMagicPreviewToken(
@@ -124,4 +164,43 @@ describe("magicPreview helper", () => {
       expect(decipherMagicPreviewToken(tampered, config)).toBeNull();
     });
   });
+
+  describe("chunkToken and unchunkToken helpers", () => {
+    it("handles non-string or falsy input gracefully", () => {
+      expect(chunkToken(null)).toBeNull();
+      expect(chunkToken(undefined)).toBeUndefined();
+      expect(chunkToken("")).toBe("");
+      expect(unchunkToken(null)).toBeNull();
+      expect(unchunkToken(undefined)).toBeUndefined();
+      expect(unchunkToken("")).toBe("");
+    });
+
+    it("chunks string into 40-char segments joined by dashes", () => {
+      const input = "a".repeat(40) + "b".repeat(40) + "c".repeat(15);
+      const chunked = chunkToken(input, 40);
+
+      expect(chunked).toBe(
+        "a".repeat(40) + "-" + "b".repeat(40) + "-" + "c".repeat(15),
+      );
+      expect(unchunkToken(chunked, 40)).toBe(input);
+    });
+
+    it("leaves string <= chunkSize unchanged", () => {
+      const input = "a".repeat(35);
+
+      expect(chunkToken(input, 40)).toBe(input);
+      expect(unchunkToken(input, 40)).toBe(input);
+    });
+
+    it("handles strings with existing dashes inside chunks", () => {
+      const input = "abc-def-123".repeat(10);
+      const chunked = chunkToken(input, 40);
+
+      expect(chunked).toBe(
+        "abc-def-123abc-def-123abc-def-123abc-def--123abc-def-123abc-def-123abc-def-123abc--def-123abc-def-123abc-def-123",
+      );
+
+      expect(unchunkToken(chunked, 40)).toBe(input);
+    });
+  });
 });

package/src/views/_shared/_content_tasks.ejs

@@ -9,6 +9,7 @@
         <th>Workflow</th>
         <th>Started at</th>
         <% if (showAllDetails) { %>
+        <th>Due date</th>
         <th>Finished at</th>
         <% } %>
         <th>Status</th>
@@ -18,8 +19,9 @@
     <tbody>
       <% tasks.forEach(task => { %>
         <% const resources = task.resources || []; %>
+        <% const isMarked = showAllDetails && content_tasks.hasUnattachedKeys(task); %>
 
-        <tr>
+        <tr class="<%= isMarked ? 'bg-orange-100 dark:bg-orange-950/40' : '' %>">
           <% if (showAllDetails) { %>
             <td class="w-1/3">
               <% if (resources && resources.length > 0) { %>
@@ -61,6 +63,12 @@
             <span class="body-2">
               <%= content_tasks.workflowsMap(task.workflow) %>
             </span>
+
+            <% if (isMarked) { %>
+              <div class="body-3 text-raketa-foreground/50">
+                <%= content_tasks.unattachedKeyIds(task) %>
+              </div>
+            <% } %>
           </td>
 
           <td>
@@ -84,6 +92,23 @@
           </td>
 
           <% if (showAllDetails) { %>
+            <td>
+              <div class="body-3 text-raketa-foreground/50">
+                <% const dueDate = task.lokaliseWorkflow?.settings?.due_date %>
+
+                <% if (dueDate) { %>
+                  <div class="flex items-center gap-1 mb-0.5">
+                    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-4 text-raketa-foreground">
+                      <path stroke-linecap="round" stroke-linejoin="round" d="M12 6v6h4.5m4.5 0a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" />
+                    </svg>
+                    <time data-pretty-datetime datetime="<%= dueDate %>"><%= utils.formattedDateTime(dueDate) %></time>
+                  </div>
+                <% } else { %>
+                  <span class="text-raketa-foreground/50">—</span>
+                <% } %>
+              </div>
+            </td>
+
             <td>
               <% if (task.completedAt || task.failedAt) { %>
                 <div class="body-3 text-raketa-foreground/50">