@raketa-cloud/admin 1.9.3 → 1.9.5

package/dist/application.css

@@ -1862,9 +1862,9 @@ select {
   height: 3rem;
 }
 
-.size-14 {
-  width: 3.5rem;
-  height: 3.5rem;
+.size-16 {
+  width: 4rem;
+  height: 4rem;
 }
 
 .size-3 {
@@ -1994,10 +1994,6 @@ select {
   width: 500px;
 }
 
-.w-\[96px\] {
-  width: 96px;
-}
-
 .w-full {
   width: 100%;
 }

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "main": "src/index.js",
   "files": [
     "src/",
     "dist/"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/studioraketa/raketa-admin-js.git",
+    "directory": "packages/raketa-cms-admin"
+  },
   "scripts": {
     "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",
     "test": "jest --coverage --coverageReporters=html --coverageReporters=\"text-summary\"",

package/src/HonoAdapter.js

@@ -74,9 +74,15 @@ function getPartialPath(partialPath, views, viewsFallback) {
 
   const paths = [
     sanitizePath(`${process.cwd()}/src/views/${resolvedPartialPath}`),
-    sanitizePath(`${currentPath}/views/${resolvedPartialPath}`),
   ];
 
+  if (viewsFallback) {
+    const fallbackPath = sanitizePath(`${viewsFallback}/${partialPath}`);
+    paths.push(sanitizePath(`${process.cwd()}/src/views/${fallbackPath}`));
+  }
+
+  paths.push(sanitizePath(`${currentPath}/views/${resolvedPartialPath}`));
+
   // For fallback, resolve the partial path relative to viewsFallback
   // This naturally handles ".." navigation: "resource_revisions/codes/../_nav.ejs" → "resource_revisions/_nav.ejs"
   if (viewsFallback) {
@@ -147,13 +153,33 @@ export default class HonoAdapter {
   }
 
   getActionPath(views, viewsFallback, action) {
-    const packagePath = viewsFallback
-      ? `${currentPath}/views/${viewsFallback}/${action}.ejs`
-      : `${currentPath}/views/${views}/${action}.ejs`;
+    const paths = [
+      sanitizePath(`${process.cwd()}/src/views/${views}/${action}.ejs`),
+    ];
+
+    if (viewsFallback) {
+      paths.push(
+        sanitizePath(
+          `${process.cwd()}/src/views/${viewsFallback}/${action}.ejs`,
+        ),
+      );
+    }
 
-    const appPath = `${process.cwd()}/src/views/${views}/${action}.ejs`;
+    paths.push(sanitizePath(`${currentPath}/views/${views}/${action}.ejs`));
 
-    return existsSync(appPath) ? appPath : packagePath;
+    if (viewsFallback) {
+      paths.push(
+        sanitizePath(`${currentPath}/views/${viewsFallback}/${action}.ejs`),
+      );
+    }
+
+    const existingPath = paths.find((path) => existsSync(path));
+
+    if (existingPath) return existingPath;
+
+    throw new Error(
+      `Template for action "${action}" not found:\nSearched in:\n${paths.join("\n")}`,
+    );
   }
 
   getHelpers(viewHelpersConfig) {

package/src/cloud/RaketaClient.js

@@ -137,6 +137,17 @@ export default class RaketaClient {
     return { ...result };
   }
 
+  formatLocaleErrors(localeErrors) {
+    if (!localeErrors || !Array.isArray(localeErrors)) {
+      return [];
+    }
+
+    return localeErrors.map((item) => ({
+      locale: item.locale,
+      errors: this.formatErrors(item.errors || []),
+    }));
+  }
+
   buildFiltersInput(query) {
     if (!query) {
       return {};

package/src/cloud/Resources.js

@@ -7,11 +7,11 @@ import {
   CreateResourceDocument,
   DeleteResourceDocument,
   MiniResourcesDocument,
+  MultiTranslateResourceDocument,
   ResourceByIdDocument,
   ResourceChangePreviewDocument,
   ResourcesDocument,
   TranslateResourceDocument,
-  buildBatchTranslateResourceDocument,
 } from "./documents/resourcesDocuments";
 
 const SETTINGS_DATE_DEFAULTS = {
@@ -178,43 +178,97 @@ export default class Resources extends RaketaClient {
     }
   }
 
-  async translateBatch(
+  async multiTranslate(
     sourceResourceId,
     locales,
     params,
     resourceType,
     workflow,
+    sourceLocale,
   ) {
     const paramsCopy = { ...params, resourceType };
     paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
     paramsCopy.settings = JSON.stringify(paramsCopy.settings);
 
-    const BatchTranslateDocument = buildBatchTranslateResourceDocument(
-      locales.length,
-    );
+    const translations = locales.map((locale) => ({
+      locale,
+      resource: paramsCopy,
+    }));
 
-    const variables = {};
-    locales.forEach((locale, i) => {
-      const input = {
-        locale,
-        sourceResourceId,
-        resource: paramsCopy,
+    const input = {
+      sourceResourceId,
+      translations,
+    };
+
+    if (workflow?.type) {
+      input.workflow = {
+        type: workflow.type,
+        previewUrl: buildMagicPreviewAddress(
+          {
+            slug: paramsCopy.slug,
+            locale: sourceLocale || locales[0],
+            resourceType,
+          },
+          this.getConfig(),
+        ),
       };
 
-      this.appendWorkflow(input, workflow);
+      if (workflow.due_date) {
+        input.workflow.dueDate = toUTCISO8601String(workflow.due_date);
+      }
+    }
 
-      variables[`input${i}`] = input;
-    });
+    const {
+      multiTranslateResource: { resources, errors, localeErrors },
+    } = await this.query(MultiTranslateResourceDocument, { input });
 
-    const response = await this.query(BatchTranslateDocument, variables);
+    return { resources, errors, localeErrors };
+  }
 
-    return locales.map((_, i) => {
-      const result = response[`translate${i}`];
-      return {
-        resource: result.resource,
-        errors: result.errors,
-      };
-    });
+  async translateBatch(
+    sourceResourceId,
+    locales,
+    params,
+    resourceType,
+    workflow,
+    sourceLocale,
+  ) {
+    const { resources, errors, localeErrors } = await this.multiTranslate(
+      sourceResourceId,
+      locales,
+      params,
+      resourceType,
+      workflow,
+      sourceLocale,
+    );
+
+    if (localeErrors && localeErrors.length > 0) {
+      const localeErrorMap = {};
+      localeErrors.forEach((le) => {
+        localeErrorMap[le.locale] = le.errors;
+      });
+
+      return locales.map((locale) => ({
+        resource: null,
+        errors: localeErrorMap[locale] || errors || null,
+      }));
+    }
+
+    if (errors) {
+      return locales.map(() => ({
+        resource: null,
+        errors,
+      }));
+    }
+
+    if (!resources) {
+      return null;
+    }
+
+    return locales.map((_, i) => ({
+      resource: resources[i],
+      errors: null,
+    }));
   }
 
   async updateSlug(id, slug, locale, resourceType, redirect) {

package/src/cloud/documents/contentTasksDocuments.js

@@ -15,7 +15,7 @@ export const ContentTasksDocument = gql`
         failedAt
         insertedAt
         updatedAt
-        resource {
+        resources {
           id
           title
           slug

package/src/cloud/documents/resourcesDocuments.js

@@ -195,22 +195,16 @@ const TranslateResourceDocument = gql`
   }
 `;
 
-const buildBatchTranslateResourceDocument = (count) => gql`
-  mutation BatchTranslateResources(${Array(count)
-    .fill(0)
-    .map((_, i) => `$input${i}: TranslateResourceInput!`)
-    .join(", ")}) {
-    ${Array(count)
-      .fill(0)
-      .map(
-        (_, i) => `
-      translate${i}: translateResource(input: $input${i}) {
-        resource ${resourceFragment()}
+const MultiTranslateResourceDocument = gql`
+  mutation MultiTranslateResource($input: MultiTranslateResourceInput!) {
+    multiTranslateResource(input: $input) {
+      resources ${resourceFragment()}
+      errors ${errorsFragment()}
+      localeErrors {
+        locale
         errors ${errorsFragment()}
       }
-    `,
-      )
-      .join("\n")}
+    }
   }
 `;
 
@@ -365,6 +359,7 @@ export {
   DeleteResourceDocument,
   ResourceAndSiteDocument,
   TranslateResourceDocument,
+  MultiTranslateResourceDocument,
   ResourceRevisionDocument,
   ResourceRevisionsDocument,
   StartResourceRevisionDocument,
@@ -375,7 +370,6 @@ export {
   ReopenResourceChangeDocument,
   LockResourceRevisionDocument,
   UnlockResourceRevisionDocument,
-  buildBatchTranslateResourceDocument,
   ResourceHistoryDocument,
   buildBatchStartResourceRevisionDocument,
   ResourceEditorsDocument,

package/src/handlers/resources/TranslationsHandler.js

@@ -128,7 +128,7 @@ const create = async (ctx) => {
     : [ctx.resourceParams.resource.languages].filter(Boolean);
 
   const existingTranslations = Object.keys(blueprint.translations || {});
-  const selectedLocales = formLanguages.filter(
+  const selectedLocales = [...new Set(formLanguages)].filter(
     (locale) =>
       locale !== originalLocale && !existingTranslations.includes(locale),
   );
@@ -153,15 +153,52 @@ const create = async (ctx) => {
 
   const workflow = ctx.resourceParams?.resource?.workflow;
 
-  const translations = await ctx.client.resources.translateBatch(
-    parent_id,
-    selectedLocales,
-    resource,
-    resourceType,
-    workflow,
-  );
+  const { resources, errors, localeErrors } =
+    await ctx.client.resources.multiTranslate(
+      parent_id,
+      selectedLocales,
+      resource,
+      resourceType,
+      workflow,
+      originalLocale,
+    );
+
+  if (localeErrors && localeErrors.length > 0) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          translations: blueprint.translations || {},
+          languages: formLanguages,
+          workflow: workflow,
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: errors ? ctx.client.resources.formatErrors(errors) : {},
+          localeErrors: ctx.client.resources.formatLocaleErrors(localeErrors),
+        },
+      },
+    };
+  }
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          translations: blueprint.translations || {},
+          languages: formLanguages,
+          workflow: workflow,
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: { resource: ctx.client.resources.formatErrors(errors) },
+      },
+    };
+  }
 
-  if (!translations) {
+  if (!resources) {
     return {
       assigns: {
         resource: {
@@ -184,8 +221,10 @@ const create = async (ctx) => {
     };
   }
 
-  for (let i = 0; i < translations.length; i++) {
-    const { resource: translated } = translations[i];
+  const revisionInputs = [];
+
+  for (let i = 0; i < resources.length; i++) {
+    const translated = resources[i];
     const locale = selectedLocales[i];
 
     if (translated) {
@@ -197,32 +236,7 @@ const create = async (ctx) => {
           visibility: translated.visibility,
         },
       };
-    }
-  }
-
-  const revisionInputs = [];
-
-  for (let i = 0; i < translations.length; i++) {
-    const { errors, resource: translated } = translations[i];
-    const locale = selectedLocales[i];
 
-    if (errors) {
-      return {
-        assigns: {
-          resource: {
-            ...resource,
-            translations: blueprint.translations || {},
-            languages: formLanguages,
-            workflow: workflow,
-          },
-          blueprint,
-          targetLocale: locale,
-          errors: { resource: ctx.client.resources.formatErrors(errors) },
-        },
-      };
-    }
-
-    if (translated) {
       translationIds.push(`${locale}:${translated.id}`);
       revisionInputs.push({
         resourceId: translated.id,
@@ -247,7 +261,7 @@ const create = async (ctx) => {
               languages: formLanguages,
             },
             blueprint,
-            targetLocale: selectedLocales[i],
+            targetLocale: revisionInputs[i]?.locale || selectedLocales[i],
             errors: {
               resource: ctx.client.resources.formatErrors(revisionErrors),
             },

package/src/routeCategoriesModule.js

@@ -9,7 +9,7 @@ function routeCategoriesModule(adapter, categoryType, categoryTypePlural) {
 
   routeCollection(adapter, categoryTypePlural, CategoriesHandler, {
     ...resourceConfig,
-    views: "categories",
+    viewsFallback: "categories",
   });
 }
 

package/src/tests/HonoAdapter.coverage.test.js

@@ -91,12 +91,22 @@ describe("HonoAdapter.getActionPath", () => {
     expect(result).toBe(`${process.cwd()}/src/views/authors/index.ejs`);
   });
 
-  test("returns package path when app missing", () => {
-    existsSync.mockReturnValue(false);
+  test("returns app fallback path when app specific is missing but app fallback exists", () => {
+    existsSync.mockImplementation(
+      (p) => p === `${process.cwd()}/src/views/categories/index.ejs`,
+    );
+
+    const result = adapter.getActionPath("movie-types", "categories", "index");
 
-    const result = adapter.getActionPath("widget-sets", "resources", "index");
+    expect(result).toBe(`${process.cwd()}/src/views/categories/index.ejs`);
+  });
+
+  test("throws an error when all paths are missing.", () => {
+    existsSync.mockReturnValue(false);
 
-    expect(result).toContain("/views/resources/index.ejs");
+    expect(async () => {
+      adapter.getActionPath("tags", undefined, "index");
+    }).rejects.toThrow();
   });
 });
 
@@ -143,6 +153,23 @@ describe("HonoAdapter.renderPartial", () => {
     );
   });
 
+  test("uses app fallback partial when app specific is missing but app fallback exists", () => {
+    existsSync.mockImplementation(
+      (p) => p === `${process.cwd()}/src/views/categories/_form.ejs`,
+    );
+    readFileSync.mockReturnValue("<%= fallback %>");
+    ejs.render.mockReturnValue("fallback rendered");
+
+    const render = adapter.renderPartial({}, "genres", "categories");
+    const result = render("_form.ejs");
+
+    expect(result).toBe("fallback rendered");
+    expect(readFileSync).toHaveBeenCalledWith(
+      `${process.cwd()}/src/views/categories/_form.ejs`,
+      "utf8",
+    );
+  });
+
   test("returns error markup on render failure", () => {
     existsSync.mockReturnValue(true);
     readFileSync.mockImplementation(() => {

package/src/tests/RaketaClient.test.js

@@ -232,6 +232,46 @@ describe("RaketaClient", () => {
     });
   });
 
+  describe("formatLocaleErrors", () => {
+    test("formats array of locale errors", () => {
+      const client = buildClient();
+      const localeErrors = [
+        {
+          locale: "fr",
+          errors: [{ key: "title", message: "Title is required" }],
+        },
+        {
+          locale: "de",
+          errors: [
+            { key: "slug", message: "Slug is taken" },
+            { key: "slug", message: "Slug is invalid" },
+          ],
+        },
+      ];
+
+      const result = client.formatLocaleErrors(localeErrors);
+
+      expect(result).toEqual([
+        {
+          locale: "fr",
+          errors: { title: "Title is required" },
+        },
+        {
+          locale: "de",
+          errors: { slug: "Slug is taken, Slug is invalid" },
+        },
+      ]);
+    });
+
+    test("returns empty array for invalid input", () => {
+      const client = buildClient();
+
+      expect(client.formatLocaleErrors(null)).toEqual([]);
+      expect(client.formatLocaleErrors(undefined)).toEqual([]);
+      expect(client.formatLocaleErrors({})).toEqual([]);
+    });
+  });
+
   describe("buildFiltersInput", () => {
     test("extracts filters with f: prefix", () => {
       const client = buildClient();

package/src/tests/handlers/content_tasks/ContentTasksHandler.test/index.test.js

@@ -26,22 +26,26 @@ describe("ContentTasksHandler", () => {
       Factory.build("contentTask", {
         id: "1",
         workflow: "lokalise",
-        resource: {
-          id: "123",
-          title: "Test Page",
-          locale: "en",
-          resourceType: "page",
-        },
+        resources: [
+          {
+            id: "123",
+            title: "Test Page",
+            locale: "en",
+            resourceType: "page",
+          },
+        ],
       }),
       Factory.build("contentTask", {
         id: "2",
         workflow: "default",
-        resource: {
-          id: "456",
-          title: "Test Movie",
-          locale: "de",
-          resourceType: "movie-type",
-        },
+        resources: [
+          {
+            id: "456",
+            title: "Test Movie",
+            locale: "de",
+            resourceType: "movie-type",
+          },
+        ],
       }),
     ];