@raketa-cloud/admin 1.10.5 → 1.10.7

package/src/routeResourceModule.js

@@ -15,6 +15,7 @@ import ClonesHandler from "./handlers/resources/ClonesHandler";
 import DeletesHandler from "./handlers/resources/DeletesHandler";
 import ExportsHandler from "./handlers/resources/ExportsHandler";
 import HistoryHandler from "./handlers/resources/HistoryHandler";
+import PartialTranslationsHandler from "./handlers/resources/PartialTranslationsHandler";
 import ReportsAPIHandler from "./handlers/resources/ReportsAPIHandler";
 import ResourcesAPIHandler from "./handlers/resources/ResourcesAPIHandler";
 import ResourcesHandler from "./handlers/resources/ResourcesHandler";
@@ -93,6 +94,16 @@ function routeResourceModule(
     { ...resourceConfig, viewsFallback: "resources/translations" },
   );
 
+  if (adapter.globalConfig?.features?.contentTasks) {
+    routeNestedCollection(
+      adapter,
+      baseResource,
+      "partial-translations",
+      PartialTranslationsHandler,
+      { ...resourceConfig, viewsFallback: "resources/partial-translations" },
+    );
+  }
+
   routeNestedCollection(adapter, baseResource, "history", HistoryHandler, {
     ...resourceConfig,
     viewsFallback: "resources/history",

package/src/styles/application.css

@@ -1,4 +1,8 @@
 @import "tailwindcss";
+
+/* Keep dark utilities opt-in through a `.dark` ancestor, rather than the OS theme. */
+@custom-variant dark (&:where(.dark, .dark *));
+
 @plugin "@tailwindcss/forms";
 @plugin "@tailwindcss/typography";
 @source "../**/*.{html,js,ejs}";

package/src/tests/handlers/resources/PartialTranslationsHandler.test.js

@@ -0,0 +1,279 @@
+import PartialTranslationsHandler from "../../../handlers/resources/PartialTranslationsHandler";
+
+const resource = {
+  id: "42",
+  slug: "hello",
+  title: "Hello",
+  translations: { fr: { id: "43" } },
+  widgets: [
+    { widgetId: "hero-1", component: "Hero", settings: { title: "Hero" } },
+  ],
+};
+
+const buildCtx = (params = {}) => ({
+  client: {
+    resources: {
+      find: jest.fn().mockResolvedValue(resource),
+      previewUrl: jest.fn().mockReturnValue("https://preview.example/hello"),
+      formatErrors: jest.fn((errors) =>
+        Object.fromEntries(errors.map((error) => [error.key, error.message])),
+      ),
+      multiPartialTranslate: jest.fn().mockResolvedValue({ errors: null }),
+    },
+  },
+  params: { parent_id: "42" },
+  query: {},
+  locale: "en",
+  resourceConfig: { resourceType: "page", resourceTypePlural: "pages" },
+  resourceParams: params,
+});
+
+describe("PartialTranslationsHandler", () => {
+  test("builds the form from the selected source widgets", async () => {
+    const ctx = buildCtx();
+    ctx.query = { widget_ids: "hero-1" };
+
+    const result = await PartialTranslationsHandler.create_form(ctx);
+
+    expect(result.assigns).toMatchObject({
+      resource,
+      previewUrl: "https://preview.example/hello",
+      partialTranslation: { widgetIds: ["hero-1"] },
+    });
+  });
+
+  test.each([{}, { widget_ids: "" }])(
+    "returns a validation error when selected widgets are missing",
+    async (query) => {
+      const ctx = buildCtx();
+      ctx.query = query;
+
+      const result = await PartialTranslationsHandler.create_form(ctx);
+
+      expect(result.assigns).toMatchObject({
+        partialTranslation: { widgetIds: [] },
+        errors: { partialTranslation: { widgetIds: "can't be blank" } },
+      });
+    },
+  );
+
+  test("returns an error and preserves valid widgets when a requested widget does not exist", async () => {
+    const ctx = buildCtx();
+    ctx.query = { widget_ids: "hero-1,missing-widget" };
+
+    const result = await PartialTranslationsHandler.create_form(ctx);
+
+    expect(result.assigns).toMatchObject({
+      partialTranslation: { widgetIds: ["hero-1"] },
+      errors: {
+        partialTranslation: {
+          widgetIds: "not found in the source resource: missing-widget",
+        },
+      },
+    });
+  });
+
+  test("returns an error when the resource has no translations", async () => {
+    const ctx = buildCtx();
+    ctx.query = { widget_ids: "hero-1" };
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      translations: {},
+    });
+
+    const result = await PartialTranslationsHandler.create_form(ctx);
+
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      generalError:
+        "cannot start a partial translation without existing translations",
+    });
+  });
+
+  test("returns an error when the source has an active content task", async () => {
+    const ctx = buildCtx();
+    ctx.query = { widget_ids: "hero-1" };
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      activeContentTask: { workflow: "lokalise_tt_ai" },
+    });
+
+    const result = await PartialTranslationsHandler.create_form(ctx);
+
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      generalError:
+        "cannot start a partial translation while a translation task is in progress",
+    });
+  });
+
+  test("starts a partial translation workflow", async () => {
+    const ctx = buildCtx({
+      partial_translation: {
+        locales: ["fr"],
+        widget_ids: ["hero-1"],
+        workflow: { type: "LOKALISE_TT_AI" },
+      },
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(ctx.client.resources.multiPartialTranslate).toHaveBeenCalledWith(
+      "42",
+      ["fr"],
+      [
+        {
+          widgetId: "hero-1",
+          component: "Hero",
+          settings: { title: "Hero" },
+        },
+      ],
+      { type: "LOKALISE_TT_AI" },
+      { ...resource, locale: "en", resourceType: "page" },
+    );
+    expect(result).toEqual({ redirect: "/en/pages/42" });
+  });
+
+  test("does not submit unknown widgets and keeps only valid widgets on the form", async () => {
+    const ctx = buildCtx({
+      partial_translation: {
+        locales: ["fr"],
+        widget_ids: ["hero-1", "missing-widget"],
+        workflow: { type: "LOKALISE_TT_AI" },
+      },
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(ctx.client.resources.multiPartialTranslate).not.toHaveBeenCalled();
+    expect(result.assigns.partialTranslation.widgetIds).toEqual(["hero-1"]);
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      widgetIds: "not found in the source resource: missing-widget",
+    });
+  });
+
+  test.each(["en", "stale-locale"])(
+    "does not submit locales outside the resource translations: %s",
+    async (locale) => {
+      const ctx = buildCtx({
+        partial_translation: {
+          locales: ["fr", locale],
+          widget_ids: ["hero-1"],
+          workflow: { type: "LOKALISE_TT_AI" },
+        },
+      });
+
+      const result = await PartialTranslationsHandler.create(ctx);
+
+      expect(ctx.client.resources.multiPartialTranslate).not.toHaveBeenCalled();
+      expect(result.assigns.partialTranslation.locales).toEqual(["fr"]);
+      expect(result.assigns.errors.partialTranslation).toEqual({
+        locales: `not found in the resource translations: ${locale}`,
+      });
+    },
+  );
+
+  test("does not submit when the resource has no translations", async () => {
+    const ctx = buildCtx({
+      partial_translation: {
+        locales: ["fr"],
+        widget_ids: ["hero-1"],
+        workflow: { type: "LOKALISE_TT_AI" },
+      },
+    });
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      translations: {},
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(ctx.client.resources.multiPartialTranslate).not.toHaveBeenCalled();
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      locales: "not found in the resource translations: fr",
+      generalError:
+        "cannot start a partial translation without existing translations",
+    });
+  });
+
+  test("does not submit when a translation has an active content task", async () => {
+    const ctx = buildCtx({
+      partial_translation: {
+        locales: ["fr"],
+        widget_ids: ["hero-1"],
+        workflow: { type: "LOKALISE_TT_AI" },
+      },
+    });
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      translations: {
+        fr: {
+          id: "43",
+          active_content_task: { workflow: "lokalise_tt_ai" },
+        },
+      },
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(ctx.client.resources.multiPartialTranslate).not.toHaveBeenCalled();
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      generalError:
+        "cannot start a partial translation while a translation task is in progress",
+    });
+  });
+
+  test("preserves selected widget IDs when the API returns errors", async () => {
+    const ctx = buildCtx({
+      partial_translation: {
+        locales: ["fr"],
+        widget_ids: ["hero-1"],
+        workflow: { type: "LOKALISE_TT_AI" },
+      },
+    });
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      widgets: [
+        ...resource.widgets,
+        { widgetId: "body-1", component: "Body", settings: {} },
+      ],
+    });
+    ctx.client.resources.multiPartialTranslate.mockResolvedValue({
+      errors: [{ key: "generalError", message: "translation failed" }],
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(result.assigns.partialTranslation.widgetIds).toEqual(["hero-1"]);
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      generalError: "translation failed",
+    });
+  });
+
+  test("preserves query widget IDs when the submitted body omits them", async () => {
+    const ctx = buildCtx({ partial_translation: {} });
+    ctx.query = { widget_ids: "hero-1" };
+    ctx.client.resources.find.mockResolvedValue({
+      ...resource,
+      widgets: [
+        ...resource.widgets,
+        { widgetId: "body-1", component: "Body", settings: {} },
+      ],
+    });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(result.assigns.partialTranslation.widgetIds).toEqual(["hero-1"]);
+  });
+
+  test("returns validation errors without calling the API", async () => {
+    const ctx = buildCtx({ partial_translation: {} });
+
+    const result = await PartialTranslationsHandler.create(ctx);
+
+    expect(ctx.client.resources.multiPartialTranslate).not.toHaveBeenCalled();
+    expect(result.assigns.errors.partialTranslation).toEqual({
+      locales: "select at least one existing translation",
+      widgetIds: "can't be blank",
+      workflow: "can't be blank",
+    });
+  });
+});

package/src/tests/routeResourceModule.test.js

@@ -210,6 +210,32 @@ describe("routeResourceModule", () => {
     );
   });
 
+  test("registers partial translations only when content tasks are enabled", () => {
+    const enabledAdapter = makeAdapter({ features: { contentTasks: true } });
+    const disabledAdapter = makeAdapter({ features: { contentTasks: false } });
+
+    routeResourceModule(enabledAdapter, "article", "articles");
+    routeResourceModule(disabledAdapter, "article", "articles");
+
+    const routes = (adapter) =>
+      adapter.routeNestedCollection.mock.calls.flatMap(([mapping]) =>
+        mapping.map(([method, path]) => `${method} ${path}`),
+      );
+
+    expect(routes(enabledAdapter)).toEqual(
+      expect.arrayContaining([
+        "GET /articles/:parent_id/partial-translations/new",
+        "POST /articles/:parent_id/partial-translations",
+      ]),
+    );
+    expect(routes(disabledAdapter)).not.toContain(
+      "GET /articles/:parent_id/partial-translations/new",
+    );
+    expect(routes(disabledAdapter)).not.toContain(
+      "POST /articles/:parent_id/partial-translations",
+    );
+  });
+
   test("registers nested members for general, visuals, codes, meta, tags", () => {
     const adapter = makeAdapter();
 

package/src/tests/views/due_date.test.js

@@ -0,0 +1,121 @@
+import { readFileSync } from "node:fs";
+import vm from "node:vm";
+import ejs from "ejs";
+
+const template = readFileSync(
+  `${process.cwd()}/src/views/resources/_shared/_due_date.ejs`,
+  "utf8",
+);
+
+function renderDueDate(assigns) {
+  return ejs.render(template, assigns);
+}
+
+function setupDueDateScript({ workflow = "", dueDate = "" } = {}) {
+  const listeners = {};
+  const workflowSelect = {
+    value: workflow,
+    addEventListener: jest.fn((event, callback) => {
+      listeners.workflow = { event, callback };
+    }),
+  };
+  const dueDateWrapper = { style: {} };
+  const dueDateInput = {
+    value: dueDate,
+    min: "",
+    validationMessage: "",
+    setCustomValidity(message) {
+      this.validationMessage = message;
+    },
+    addEventListener: jest.fn((event, callback) => {
+      listeners.dueDate = { event, callback };
+    }),
+  };
+  const elements = {
+    workflow: workflowSelect,
+    due_date_wrapper: dueDateWrapper,
+    due_date: dueDateInput,
+  };
+  let loadCallback;
+  const window = {
+    addEventListener: jest.fn((event, callback) => {
+      if (event === "load") loadCallback = callback;
+    }),
+  };
+  const document = {
+    getElementById: jest.fn((id) => elements[id]),
+  };
+  const rendered = renderDueDate({
+    dueDateField: "resource[workflow][due_date]",
+    workflow: { due_date: dueDate },
+  });
+  const script = rendered.match(/<script>([\s\S]*?)<\/script>/)[1];
+
+  vm.runInNewContext(script, { window, document, Date });
+  loadCallback();
+
+  return { workflowSelect, dueDateWrapper, dueDateInput, listeners };
+}
+
+describe("resources shared due date", () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("renders the configured field name and submitted value", () => {
+    const standard = renderDueDate({
+      dueDateField: "resource[workflow][due_date]",
+      workflow: { due_date: "2026-10-19T12:30" },
+    });
+    const partial = renderDueDate({
+      dueDateField: "partial_translation[workflow][due_date]",
+      workflow: { due_date: "2026-10-20T09:15" },
+    });
+
+    expect(standard).toContain('name="resource[workflow][due_date]"');
+    expect(standard).toContain('value="2026-10-19T12:30"');
+    expect(partial).toContain('name="partial_translation[workflow][due_date]"');
+    expect(partial).toContain('value="2026-10-20T09:15"');
+  });
+
+  test("hides and clears the due date when no workflow is selected", () => {
+    const { dueDateWrapper, dueDateInput } = setupDueDateScript({
+      dueDate: "2026-10-19T12:30",
+    });
+
+    expect(dueDateWrapper.style.display).toBe("none");
+    expect(dueDateInput.value).toBe("");
+  });
+
+  test("shows the due date and defaults it to the minimum weekday", () => {
+    jest.useFakeTimers().setSystemTime(new Date("2026-10-16T10:00:00"));
+
+    const { dueDateWrapper, dueDateInput } = setupDueDateScript({
+      workflow: "LOKALISE_TT_AI",
+    });
+
+    expect(dueDateWrapper.style.display).toBe("block");
+    expect(dueDateInput.value).toBe("2026-10-19T10:00");
+    expect(dueDateInput.min).toBe("2026-10-19T10:00");
+  });
+
+  test("rejects weekend dates and accepts weekdays", () => {
+    const { dueDateInput, listeners } = setupDueDateScript({
+      workflow: "LOKALISE_TT_AI",
+      dueDate: "2026-10-19T12:30",
+    });
+
+    dueDateInput.value = "2026-10-17T12:30";
+    listeners.dueDate.callback();
+
+    expect(dueDateInput.value).toBe("");
+    expect(dueDateInput.validationMessage).toBe(
+      "Weekends are not allowed. Please select a weekday.",
+    );
+
+    dueDateInput.value = "2026-10-19T12:30";
+    listeners.dueDate.callback();
+
+    expect(dueDateInput.validationMessage).toBe("");
+  });
+});

package/src/tests/views/partial_translations.test.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import ejs from "ejs";
+
+const template = readFileSync(
+  `${process.cwd()}/src/views/resources/partial-translations/create_form.ejs`,
+  "utf8",
+);
+
+function renderPartialTranslations(translations) {
+  return ejs.render(template, {
+    _context: {
+      locale: "en",
+      locales: { en: { name: "English" }, fr: { name: "French" } },
+      resourceConfig: { resourceTypePlural: "pages" },
+    },
+    content_tasks: { workflowsMap: (workflow) => workflow },
+    errors: {},
+    partialTranslation: { locales: [], widgetIds: ["hero-1"], workflow: {} },
+    previewUrl: "https://preview.example/hello",
+    render_partial: () => "",
+    resource: {
+      id: "42",
+      title: "Hello",
+      translations,
+      widgets: [{ widgetId: "hero-1", component: "Hero", settings: {} }],
+    },
+  });
+}
+
+describe("partial translations form", () => {
+  test("shows an empty-translations message when only the source locale exists", () => {
+    const rendered = renderPartialTranslations({ en: { id: "42" } });
+
+    expect(rendered).toContain("This resource has no translations.");
+    expect(rendered).not.toContain('value="en"');
+  });
+
+  test("renders only existing target translations", () => {
+    const rendered = renderPartialTranslations({
+      en: { id: "42" },
+      fr: { id: "43" },
+      de: {},
+    });
+
+    expect(rendered).toContain('value="fr"');
+    expect(rendered).not.toContain('value="en"');
+    expect(rendered).not.toContain('value="de"');
+    expect(rendered).not.toContain("This resource has no translations.");
+  });
+});

package/src/views/_shared/_content_tasks.ejs

@@ -60,7 +60,19 @@
           <% } %>
 
           <td>
-            <span class="body-3">
+            <span class="body-3 flex items-center gap-0.5">
+              <% if (task.lokaliseWorkflow?.partial) { %>
+                <svg viewBox="0 0 20 20" class="size-3.5 shrink-0 text-raketa-primary" role="img" aria-label="Partial translation">
+                  <title>Partial translation</title>
+                  <path fill="currentColor" d="M10 10V2a8 8 0 1 1-8 8h8Z" />
+                </svg>
+              <% } else { %>
+                <svg viewBox="0 0 20 20" class="size-3.5 shrink-0 text-raketa-primary" role="img" aria-label="Full translation">
+                  <title>Full translation</title>
+                  <circle cx="10" cy="10" r="8" fill="currentColor" />
+                </svg>
+              <% } %>
+
               <%= content_tasks.workflowsMap(task.workflow) %>
             </span>
 
@@ -69,7 +81,7 @@
                 <summary class="cursor-pointer whitespace-nowrap" onclick="event.preventDefault(); this.parentElement.nextElementSibling.showModal()">Unattached keys</summary>
               </details>
 
-              <dialog class="w-full max-w-2xl rounded-lg bg-raketa-background p-0 text-raketa-foreground shadow-xl backdrop:bg-black/50">
+              <dialog class="m-auto w-full max-w-2xl rounded-lg bg-raketa-background p-0 text-raketa-foreground shadow-xl backdrop:bg-black/50">
                 <div class="flex items-center justify-between border-b p-4 dark:border-neutral-700">
                   <h2 class="heading-3">Unattached keys</h2>
                   <form method="dialog">

package/src/views/resources/_shared/_due_date.ejs

@@ -0,0 +1,71 @@
+<div class="mb-4" id="due_date_wrapper">
+  <label for="due_date" class="font-semibold hover:cursor-pointer body-3">Due date (UTC)</label>
+  <input type="datetime-local" name="<%= dueDateField %>" id="due_date" value="<%= workflow?.due_date || "" %>" />
+
+  <p class="mt-1 text-sm text-raketa-foreground/50">
+    Select a due date for the translation. Weekends are not a valid choice.
+  </p>
+</div>
+
+<script>
+  window.addEventListener("load", () => {
+    const workflowSelect = document.getElementById("workflow");
+    const dueDateWrapper = document.getElementById("due_date_wrapper");
+    const dueDateInput = document.getElementById("due_date");
+
+    if (!workflowSelect || !dueDateWrapper || !dueDateInput) return;
+
+    function validateInputValue() {
+      if (dueDateInput.value === "") {
+        dueDateInput.setCustomValidity("");
+        return;
+      }
+
+      const selectedDate = new Date(dueDateInput.value);
+      const day = selectedDate.getDay();
+
+      if (day === 0 || day === 6) {
+        dueDateInput.setCustomValidity("Weekends are not allowed. Please select a weekday.");
+        dueDateInput.value = "";
+      } else {
+        dueDateInput.setCustomValidity("");
+      }
+    }
+
+    function getMinimumDueDate() {
+      const date = new Date();
+      date.setDate(date.getDate() + 3);
+
+      while (date.getDay() === 0 || date.getDay() === 6) {
+        date.setDate(date.getDate() + 1);
+      }
+
+      const year = date.getFullYear();
+      const month = String(date.getMonth() + 1).padStart(2, "0");
+      const day = String(date.getDate()).padStart(2, "0");
+      const hours = String(date.getHours()).padStart(2, "0");
+      const minutes = String(date.getMinutes()).padStart(2, "0");
+      return `${year}-${month}-${day}T${hours}:${minutes}`;
+    }
+
+    function toggleDueDate() {
+      const minDate = getMinimumDueDate();
+      dueDateInput.min = minDate;
+
+      const isDefault = !workflowSelect.value;
+      dueDateWrapper.style.display = isDefault ? "none" : "block";
+
+      if (isDefault) {
+        dueDateInput.value = "";
+      } else if (!dueDateInput.value) {
+        dueDateInput.value = minDate;
+      }
+
+      validateInputValue();
+    }
+
+    dueDateInput.addEventListener("change", validateInputValue);
+    workflowSelect.addEventListener("change", toggleDueDate);
+    toggleDueDate();
+  });
+</script>