@raketa-cloud/admin 1.7.4 → 1.7.6

package/src/routeEventsModule.js

@@ -15,6 +15,7 @@ import ClonesHandler from "./handlers/events/ClonesHandler";
 import DeletesHandler from "./handlers/events/DeletesHandler";
 import EventsAPIHandler from "./handlers/events/EventsAPIHandler";
 import EventsHandler from "./handlers/events/EventsHandler";
+import ExportsHandler from "./handlers/events/ExportsHandler";
 import HistoryHandler from "./handlers/events/HistoryHandler";
 import TranslationsHandler from "./handlers/events/TranslationsHandler";
 import URLsHandler from "./handlers/events/URLsHandler";
@@ -35,6 +36,18 @@ function routeEventsModule(
     eventTypePlural,
   };
 
+  const exportsMapping = [
+    [
+      "GET",
+      `/${baseResource}/exports`,
+      "exports",
+      "events/exports",
+      "index",
+      ExportsHandler.index,
+    ],
+  ];
+  adapter.routeCollection(exportsMapping, resourceConfig);
+
   routeCollection(adapter, baseResource, EventsHandler, {
     ...resourceConfig,
     viewsFallback: "events",

package/src/routePagesModule.js

@@ -13,6 +13,7 @@ import WidgetHandler from "./handlers/page_revisions/WidgetHandler";
 import ChangeHandler from "./handlers/pages/ChangeHandler";
 import ClonesHandler from "./handlers/pages/ClonesHandler";
 import DeletesHandler from "./handlers/pages/DeletesHandler";
+import ExportsHandler from "./handlers/pages/ExportsHandler";
 import HistoryHandler from "./handlers/pages/HistoryHandler";
 import PagesAPIHandler from "./handlers/pages/PagesAPIHandler";
 import PagesHandler from "./handlers/pages/PagesHandler";
@@ -35,6 +36,18 @@ function routePagesModule(
     pageTypePlural,
   };
 
+  const exportsMapping = [
+    [
+      "GET",
+      `/${baseResource}/exports`,
+      "exports",
+      "pages/exports",
+      "index",
+      ExportsHandler.index,
+    ],
+  ];
+  adapter.routeCollection(exportsMapping, resourceConfig);
+
   routeCollection(adapter, pageTypePlural, PagesHandler, {
     ...resourceConfig,
     viewsFallback: "pages",

package/src/routeSettings.js

@@ -9,6 +9,10 @@ function routeSettings(adapter) {
   routeMember(adapter, "settings/layout", SettingsHandler, {
     resource: "settings/layout",
   });
+
+  routeMember(adapter, "settings/variables", SettingsHandler, {
+    resource: "settings/variables",
+  });
 }
 
 export default routeSettings;

package/src/tests/RaketaClient.test.js

@@ -0,0 +1,636 @@
+import RaketaClient from '../cloud/RaketaClient'
+import { request } from 'graphql-request'
+
+jest.mock('graphql-request', () => ({
+  request: jest.fn(),
+}))
+
+describe('RaketaClient', () => {
+  function buildMockConfig(overrides = {}) {
+    return {
+      cloud: {
+        gateway_url: 'https://api.example.com',
+        gateway_project: 'test-project',
+        dxp_service_private: 'test-service',
+      },
+      ...overrides,
+    }
+  }
+
+  function buildClient(config = buildMockConfig(), token = 'test-token') {
+    const getConfig = () => config
+    return new RaketaClient(getConfig, token)
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('constructor', () => {
+    test('initializes with getConfig and token', () => {
+      const getConfig = jest.fn(() => buildMockConfig())
+      const client = new RaketaClient(getConfig, 'my-token')
+
+      expect(client.getConfig).toBe(getConfig)
+      expect(client.token).toBe('my-token')
+    })
+  })
+
+  describe('gqlRequest', () => {
+    test('makes GraphQL request with correct parameters', async () => {
+      const client = buildClient()
+      const query = 'query { test }'
+      const variables = { id: '123' }
+      const headers = { 'x-custom': 'value' }
+
+      request.mockResolvedValue({ data: 'response' })
+
+      await client.gqlRequest('https://api.example.com/graphql', query, variables, headers)
+
+      expect(request).toHaveBeenCalledWith({
+        url: 'https://api.example.com/graphql',
+        document: query,
+        variables: variables,
+        requestHeaders: headers,
+      })
+    })
+
+    test('makes request with default empty variables and headers', async () => {
+      const client = buildClient()
+      const query = 'query { test }'
+
+      request.mockResolvedValue({ data: 'response' })
+
+      await client.gqlRequest('https://api.example.com/graphql', query)
+
+      expect(request).toHaveBeenCalledWith({
+        url: 'https://api.example.com/graphql',
+        document: query,
+        variables: {},
+        requestHeaders: {},
+      })
+    })
+  })
+
+  describe('query', () => {
+    test('makes request to gateway with proper headers', async () => {
+      const client = buildClient()
+      const query = 'query { users }'
+      const variables = { limit: 10 }
+
+      request.mockResolvedValue({ data: { users: [] } })
+
+      await client.query(query, variables)
+
+      expect(request).toHaveBeenCalledWith({
+        url: 'https://api.example.com/dispatch',
+        document: query,
+        variables: variables,
+        requestHeaders: {
+          'x-raketa-project': 'test-project',
+          'x-raketa-service': 'test-service',
+          'x-raketa-identity': 'test-token',
+        },
+      })
+    })
+
+    test('uses token from constructor in headers', async () => {
+      const client = buildClient(buildMockConfig(), 'custom-token-123')
+      const query = 'query { test }'
+
+      request.mockResolvedValue({ data: {} })
+
+      await client.query(query)
+
+      expect(request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requestHeaders: expect.objectContaining({
+            'x-raketa-identity': 'custom-token-123',
+          }),
+        })
+      )
+    })
+  })
+
+  describe('logError', () => {
+    test('throws error with message', () => {
+      const client = buildClient()
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+
+      expect(() => client.logError('Something went wrong')).toThrow('Something went wrong')
+
+      consoleSpy.mockRestore()
+    })
+
+    test('logs context to console when provided', () => {
+      const client = buildClient()
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+      const context = { code: 'ERR_001', details: 'Invalid input' }
+
+      expect(() => client.logError('Error occurred', context)).toThrow('Error occurred')
+      expect(consoleSpy).toHaveBeenCalledWith(context)
+
+      consoleSpy.mockRestore()
+    })
+
+    test('does not log when context is not provided', () => {
+      const client = buildClient()
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+
+      expect(() => client.logError('Error occurred')).toThrow('Error occurred')
+      expect(consoleSpy).not.toHaveBeenCalled()
+
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('formatErrors', () => {
+    test('formats single error into object', () => {
+      const client = buildClient()
+      const errors = [{ key: 'email', message: 'Email is invalid' }]
+
+      const result = client.formatErrors(errors)
+
+      expect(result).toEqual({
+        email: 'Email is invalid',
+      })
+    })
+
+    test('formats multiple errors for different keys', () => {
+      const client = buildClient()
+      const errors = [
+        { key: 'email', message: 'Email is required' },
+        { key: 'password', message: 'Password is too short' },
+        { key: 'username', message: 'Username is taken' },
+      ]
+
+      const result = client.formatErrors(errors)
+
+      expect(result).toEqual({
+        email: 'Email is required',
+        password: 'Password is too short',
+        username: 'Username is taken',
+      })
+    })
+
+    test('concatenates multiple messages for same key', () => {
+      const client = buildClient()
+      const errors = [
+        { key: 'email', message: 'Email is required' },
+        { key: 'email', message: 'Email format is invalid' },
+        { key: 'password', message: 'Password is required' },
+      ]
+
+      const result = client.formatErrors(errors)
+
+      expect(result).toEqual({
+        email: 'Email is required, Email format is invalid',
+        password: 'Password is required',
+      })
+    })
+
+    test('remaps generalError to specified key', () => {
+      const client = buildClient()
+      const errors = [
+        { key: 'generalError', message: 'Something went wrong' },
+        { key: 'email', message: 'Email is invalid' },
+      ]
+
+      const result = client.formatErrors(errors, 'base')
+
+      expect(result).toEqual({
+        base: 'Something went wrong',
+        email: 'Email is invalid',
+      })
+    })
+
+    test('keeps generalError key when no remap specified', () => {
+      const client = buildClient()
+      const errors = [{ key: 'generalError', message: 'Operation failed' }]
+
+      const result = client.formatErrors(errors)
+
+      expect(result).toEqual({
+        generalError: 'Operation failed',
+      })
+    })
+
+    test('handles empty errors array', () => {
+      const client = buildClient()
+      const result = client.formatErrors([])
+
+      expect(result).toEqual({})
+    })
+  })
+
+  describe('buildFiltersInput', () => {
+    test('extracts filters with f: prefix', () => {
+      const client = buildClient()
+      const query = {
+        'f:status': 'active',
+        'f:category': 'news',
+        page: '2',
+        order_by: 'created_at',
+      }
+
+      const result = client.buildFiltersInput(query)
+
+      expect(result).toEqual({
+        status: 'active',
+        category: 'news',
+      })
+    })
+
+    test('ignores filters with empty values', () => {
+      const client = buildClient()
+      const query = {
+        'f:status': 'active',
+        'f:category': '',
+        'f:tag': null,
+        'f:author': undefined,
+      }
+
+      const result = client.buildFiltersInput(query)
+
+      expect(result).toEqual({
+        status: 'active',
+      })
+    })
+
+    test('returns empty object when no filters present', () => {
+      const client = buildClient()
+      const query = {
+        page: '1',
+        order_by: 'title',
+      }
+
+      const result = client.buildFiltersInput(query)
+
+      expect(result).toEqual({})
+    })
+
+    test('returns empty object when query is null or undefined', () => {
+      const client = buildClient()
+
+      expect(client.buildFiltersInput(null)).toEqual({})
+      expect(client.buildFiltersInput(undefined)).toEqual({})
+    })
+
+    test('returns empty object when only page param exists', () => {
+      const client = buildClient()
+      const query = { page: '3' }
+
+      const result = client.buildFiltersInput(query)
+
+      expect(result).toEqual({})
+    })
+  })
+
+  describe('buildOrderInput', () => {
+    test('builds order object with field and direction', () => {
+      const client = buildClient()
+      const query = {
+        order_by: 'created_at',
+        order_direction: 'DESC',
+      }
+
+      const result = client.buildOrderInput(query)
+
+      expect(result).toEqual({
+        field: 'created_at',
+        direction: 'DESC',
+      })
+    })
+
+    test('defaults to ASC when direction not provided', () => {
+      const client = buildClient()
+      const query = { order_by: 'title' }
+
+      const result = client.buildOrderInput(query)
+
+      expect(result).toEqual({
+        field: 'title',
+        direction: 'ASC',
+      })
+    })
+
+    test('returns null when order_by not provided', () => {
+      const client = buildClient()
+      const query = { order_direction: 'DESC' }
+
+      const result = client.buildOrderInput(query)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null when order_by is empty string', () => {
+      const client = buildClient()
+      const query = { order_by: '' }
+
+      const result = client.buildOrderInput(query)
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('buildPaginationInput', () => {
+    test('builds pagination with page number from query', () => {
+      const client = buildClient()
+      const query = { page: '3' }
+
+      const result = client.buildPaginationInput(query)
+
+      expect(result).toEqual({
+        page: 3,
+        pageSize: 25,
+      })
+    })
+
+    test('defaults to page 1 when not provided', () => {
+      const client = buildClient()
+      const query = {}
+
+      const result = client.buildPaginationInput(query)
+
+      expect(result).toEqual({
+        page: 1,
+        pageSize: 25,
+      })
+    })
+
+    test('parses string page number to integer', () => {
+      const client = buildClient()
+      const query = { page: '10' }
+
+      const result = client.buildPaginationInput(query)
+
+      expect(result.page).toBe(10)
+      expect(typeof result.page).toBe('number')
+    })
+
+    test('handles invalid page values by defaulting to 1', () => {
+      const client = buildClient()
+
+      expect(client.buildPaginationInput({ page: 'invalid' })).toEqual({
+        page: NaN,
+        pageSize: 25,
+      })
+    })
+  })
+
+  describe('buildListInput', () => {
+    test('builds complete input with pagination, filters, orderBy, and locale', () => {
+      const client = buildClient()
+      const query = {
+        page: '2',
+        'f:status': 'published',
+        'f:category': 'tech',
+        order_by: 'created_at',
+        order_direction: 'DESC',
+      }
+
+      const result = client.buildListInput(query, 'en')
+
+      expect(result).toEqual({
+        input: {
+          pagination: { page: 2, pageSize: 25 },
+          filters: { status: 'published', category: 'tech' },
+          orderBy: { field: 'created_at', direction: 'DESC' },
+          locale: 'en',
+        },
+      })
+    })
+
+    test('omits orderBy when not provided', () => {
+      const client = buildClient()
+      const query = { page: '1', 'f:status': 'active' }
+
+      const result = client.buildListInput(query)
+
+      expect(result).toEqual({
+        input: {
+          pagination: { page: 1, pageSize: 25 },
+          filters: { status: 'active' },
+        },
+      })
+    })
+
+    test('omits locale when not provided', () => {
+      const client = buildClient()
+      const query = { page: '1' }
+
+      const result = client.buildListInput(query)
+
+      expect(result.input).not.toHaveProperty('locale')
+    })
+
+    test('includes locale when provided', () => {
+      const client = buildClient()
+      const query = { page: '1' }
+
+      const result = client.buildListInput(query, 'de')
+
+      expect(result.input.locale).toBe('de')
+    })
+
+    test('handles empty query object', () => {
+      const client = buildClient()
+
+      const result = client.buildListInput({})
+
+      expect(result).toEqual({
+        input: {
+          pagination: { page: 1, pageSize: 25 },
+          filters: {},
+        },
+      })
+    })
+  })
+
+  describe('buildAllInput', () => {
+    test('builds input without pagination', () => {
+      const client = buildClient()
+      const query = {
+        page: '2',
+        'f:status': 'active',
+        order_by: 'title',
+        order_direction: 'ASC',
+      }
+
+      const result = client.buildAllInput(query, 'fr')
+
+      expect(result).toEqual({
+        input: {
+          filters: { status: 'active' },
+          orderBy: { field: 'title', direction: 'ASC' },
+          locale: 'fr',
+        },
+      })
+      expect(result.input).not.toHaveProperty('pagination')
+    })
+
+    test('omits orderBy when not provided', () => {
+      const client = buildClient()
+      const query = { 'f:category': 'news' }
+
+      const result = client.buildAllInput(query)
+
+      expect(result).toEqual({
+        input: {
+          filters: { category: 'news' },
+        },
+      })
+    })
+
+    test('omits locale when not provided', () => {
+      const client = buildClient()
+      const query = {}
+
+      const result = client.buildAllInput(query)
+
+      expect(result.input).not.toHaveProperty('locale')
+    })
+  })
+
+  describe('deepMerge', () => {
+    test('merges two simple objects', () => {
+      const client = buildClient()
+      const target = { a: 1, b: 2 }
+      const source = { b: 3, c: 4 }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result).toEqual({ a: 1, b: 3, c: 4 })
+      // Verify original is not modified
+      expect(target).toEqual({ a: 1, b: 2 })
+    })
+
+    test('merges nested objects deeply', () => {
+      const client = buildClient()
+      const target = {
+        settings: { theme: 'dark', locale: 'en' },
+        profile: { name: 'John' },
+      }
+      const source = {
+        settings: { locale: 'fr', notifications: true },
+        profile: { age: 30 },
+      }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result).toEqual({
+        settings: { theme: 'dark', locale: 'fr', notifications: true },
+        profile: { name: 'John', age: 30 },
+      })
+    })
+
+    test('replaces arrays instead of merging', () => {
+      const client = buildClient()
+      const target = { tags: ['javascript', 'node'] }
+      const source = { tags: ['typescript', 'deno'] }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result).toEqual({ tags: ['typescript', 'deno'] })
+    })
+
+    test('parses JSON strings in source', () => {
+      const client = buildClient()
+      const target = { config: {} }
+      const source = { config: '{"enabled": true, "count": 5}' }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result.config).toEqual({ enabled: true, count: 5 })
+    })
+
+    test('parses JSON strings in nested objects', () => {
+      const client = buildClient()
+      const target = { settings: { meta: {} } }
+      const source = { settings: { meta: '{"title": "Test", "tags": ["a", "b"]}' } }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result.settings.meta).toEqual({ title: 'Test', tags: ['a', 'b'] })
+    })
+
+    test('handles null values', () => {
+      const client = buildClient()
+      const target = { a: 1, b: null }
+      const source = { b: 2, c: null }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result).toEqual({ a: 1, b: 2, c: null })
+    })
+
+    test('does not modify target object', () => {
+      const client = buildClient()
+      const target = { nested: { value: 'original' } }
+      const source = { nested: { value: 'modified' } }
+
+      client.deepMerge(target, source)
+
+      expect(target.nested.value).toBe('original')
+    })
+
+    test('handles deeply nested JSON strings', () => {
+      const client = buildClient()
+      const target = {
+        data: {
+          user: {
+            preferences: {},
+          },
+        },
+      }
+      const source = {
+        data: {
+          user: {
+            preferences: '{"theme": "dark", "language": "en"}',
+          },
+        },
+      }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result.data.user.preferences).toEqual({
+        theme: 'dark',
+        language: 'en',
+      })
+    })
+
+    test('handles array of objects with JSON strings', () => {
+      const client = buildClient()
+      const target = { items: [] }
+      const source = {
+        items: [{ id: 1, data: '{"active": true}' }, { id: 2, data: '{"active": false}' }],
+      }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result.items[0].data).toEqual({ active: true })
+      expect(result.items[1].data).toEqual({ active: false })
+    })
+
+    test('preserves non-JSON strings', () => {
+      const client = buildClient()
+      const target = { title: 'old' }
+      const source = { title: 'new title', description: 'just a string' }
+
+      const result = client.deepMerge(target, source)
+
+      expect(result).toEqual({
+        title: 'new title',
+        description: 'just a string',
+      })
+    })
+
+    test('handles empty objects', () => {
+      const client = buildClient()
+
+      expect(client.deepMerge({}, { a: 1 })).toEqual({ a: 1 })
+      expect(client.deepMerge({ a: 1 }, {})).toEqual({ a: 1 })
+      expect(client.deepMerge({}, {})).toEqual({})
+    })
+  })
+})