apimo.js 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apimo.js",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A wrapper for the Apimo API with catalog caching for building custom Real Estate website using their technologies.",
   "author": "Vitaly Lysen <vitaly@lysen.dev> (https://lysen.dev)",
   "license": "MIT",

package/dist/src/core/api.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/core/api.test.js

@@ -1,246 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { afterEach, beforeEach, it as defaultIt, describe, expect, vi } from 'vitest';
-import { z } from 'zod';
-import { DummyCache } from '../services/storage/dummy.cache';
-import { MemoryCache } from '../services/storage/memory.cache';
-import { Apimo, DEFAULT_BASE_URL } from './api';
-// Mock fetch globally
-const mockFetch = vi.fn();
-const PROVIDER = '0';
-const TOKEN = 'TOKEN';
-const BasicAuthHeaders = {
-    Authorization: `Basic ${btoa(`${PROVIDER}:${TOKEN}`)}`,
-};
-const it = defaultIt.extend({
-    // eslint-disable-next-line no-empty-pattern
-    api: (_a, use_1) => __awaiter(void 0, [_a, use_1], void 0, function* ({}, use) {
-        let api = new Apimo('0', 'TOKEN', {
-            catalogs: {
-                transform: {
-                    active: false,
-                },
-            },
-        });
-        yield use(api);
-        api = null;
-    }),
-    // eslint-disable-next-line no-empty-pattern
-    mockResponse: (_a, use_1) => __awaiter(void 0, [_a, use_1], void 0, function* ({}, use) {
-        const mockResponse = (config) => {
-            var _a, _b;
-            mockFetch.mockResolvedValue({
-                ok: (_a = config === null || config === void 0 ? void 0 : config.ok) !== null && _a !== void 0 ? _a : true,
-                status: (_b = config === null || config === void 0 ? void 0 : config.status) !== null && _b !== void 0 ? _b : 200,
-                json: (config === null || config === void 0 ? void 0 : config.json) ? vi.fn().mockResolvedValue(config.json()) : vi.fn().mockResolvedValue({}),
-                text: vi.fn(),
-                headers: new Headers(),
-                statusText: 'OK',
-                url: '',
-                redirected: false,
-                type: 'basic',
-                body: null,
-                bodyUsed: false,
-                clone: vi.fn(),
-                arrayBuffer: vi.fn(),
-                blob: vi.fn(),
-                formData: vi.fn(),
-            });
-        };
-        yield use(mockResponse);
-    }),
-});
-describe('api', () => {
-    let mockResponse;
-    beforeEach(() => {
-        // Mock global fetch
-        vi.stubGlobal('fetch', mockFetch);
-        // Create a mock response object
-        mockResponse = {
-            ok: true,
-            status: 200,
-            json: vi.fn(),
-            text: vi.fn(),
-            headers: new Headers(),
-            statusText: 'OK',
-            url: '',
-            redirected: false,
-            type: 'basic',
-            body: null,
-            bodyUsed: false,
-            clone: vi.fn(),
-            arrayBuffer: vi.fn(),
-            blob: vi.fn(),
-            formData: vi.fn(),
-        };
-        mockFetch.mockResolvedValue(mockResponse);
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-    });
-    describe('constructor', () => {
-        it('should accept a provider, a token and a base config', ({ api }) => {
-            expect(api).toBeInstanceOf(Apimo);
-        });
-        it('should use default config when no additional config provided', ({ api }) => {
-            expect(api.config).toStrictEqual({
-                baseUrl: DEFAULT_BASE_URL,
-                culture: 'en',
-                catalogs: {
-                    cache: {
-                        active: true,
-                        adapter: expect.any(MemoryCache),
-                    },
-                    transform: {
-                        active: false,
-                    },
-                },
-            });
-        });
-        it('should merge custom config with defaults', () => {
-            const testApi = new Apimo('provider', 'token', {
-                baseUrl: 'https://custom.api.com',
-                culture: 'fr',
-                catalogs: {
-                    cache: {
-                        active: false,
-                        adapter: new DummyCache(),
-                    },
-                },
-            });
-            expect(testApi.config).toStrictEqual({
-                baseUrl: 'https://custom.api.com',
-                culture: 'fr',
-                catalogs: {
-                    cache: {
-                        active: false,
-                        adapter: expect.any(DummyCache),
-                    },
-                    transform: {
-                        active: true,
-                    },
-                },
-            });
-        });
-        it('should use provided cache adapter', () => {
-            const testApi = new Apimo('provider', 'token', {
-                catalogs: {
-                    cache: {
-                        adapter: new DummyCache(),
-                    },
-                },
-            });
-            expect(testApi.cache).toBeInstanceOf(DummyCache);
-        });
-        it('should use DummyCache when cache is not active', () => {
-            const testApi = new Apimo('provider', 'token', {
-                catalogs: {
-                    cache: {
-                        active: false,
-                        adapter: new MemoryCache(),
-                    },
-                },
-            });
-            expect(testApi.cache).toBeInstanceOf(DummyCache);
-        });
-    });
-    describe('fetch', () => {
-        it('should have the right authorization headers when fetching', () => __awaiter(void 0, void 0, void 0, function* () {
-            const testApi = new Apimo('provider', 'token');
-            yield testApi.fetch(DEFAULT_BASE_URL);
-            expect(mockFetch).toHaveBeenCalledExactlyOnceWith(DEFAULT_BASE_URL, {
-                headers: {
-                    Authorization: `Basic ${btoa('provider:token')}`,
-                },
-            });
-        }));
-        it('should merge additional headers with authorization', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api }) {
-            const customHeaders = { 'Content-Type': 'application/json' };
-            yield api.fetch(DEFAULT_BASE_URL, { headers: customHeaders });
-            expect(mockFetch).toHaveBeenCalledWith(DEFAULT_BASE_URL, {
-                headers: Object.assign(Object.assign({}, BasicAuthHeaders), { 'Content-Type': 'application/json' }),
-            });
-        }));
-        it('should pass through other fetch options', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api }) {
-            const options = {
-                method: 'POST',
-                body: JSON.stringify({ test: 'data' }),
-                headers: { 'Custom-Header': 'value' },
-            };
-            yield api.fetch(DEFAULT_BASE_URL, options);
-            expect(mockFetch).toHaveBeenCalledWith(DEFAULT_BASE_URL, {
-                method: 'POST',
-                body: JSON.stringify({ test: 'data' }),
-                headers: Object.assign(Object.assign({}, BasicAuthHeaders), { 'Custom-Header': 'value' }),
-            });
-        }));
-        it('should handle rate limiting with Bottleneck', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api }) {
-            // Make multiple concurrent requests to test rate limiting
-            const promises = Array.from({ length: 3 }, () => api.fetch(DEFAULT_BASE_URL));
-            yield Promise.all(promises);
-            expect(mockFetch).toHaveBeenCalledTimes(3);
-        }));
-    });
-    describe('get', () => {
-        it('should fetch and parse according to the specified schema', (_a) => __awaiter(void 0, [_a], void 0, function* ({ mockResponse, api }) {
-            mockResponse({
-                json: () => ({ success: true }),
-            });
-            const spy = vi.spyOn(api, 'fetch');
-            yield api.get(['path', 'to', 'catalogs'], z.object({ success: z.boolean() }), { culture: 'en' });
-            expect(spy).toHaveBeenCalledExactlyOnceWith(new URL('https://api.apimo.pro/path/to/catalogs?culture=en'));
-        }));
-    });
-    describe('populateCache', () => {
-        it('should populate cache without returning entry when no id provided', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api, mockResponse }) {
-            const catalogName = 'property_type';
-            const culture = 'en';
-            const mockEntries = [
-                { id: 1, name: 'Apartment', name_plurial: 'Apartments' },
-                { id: 2, name: 'House', name_plurial: 'Houses' },
-            ];
-            mockResponse({
-                json: () => mockEntries,
-            });
-            const result = yield api.populateCache(catalogName, culture);
-            expect(result).toBeUndefined();
-            expect(mockFetch).toHaveBeenCalledExactlyOnceWith(new URL(`https://api.apimo.pro/catalogs/${catalogName}?culture=${culture}`), {
-                headers: BasicAuthHeaders,
-            });
-        }));
-        it('should populate cache and return specific entry when id provided', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api, mockResponse }) {
-            const catalogName = 'property_type';
-            const culture = 'en';
-            const mockEntries = [
-                { id: 1, name: 'Apartment', name_plurial: 'Apartments' },
-                { id: 2, name: 'House', name_plurial: 'Houses' },
-            ];
-            mockResponse({
-                json: () => mockEntries,
-            });
-            const result = yield api.populateCache(catalogName, culture, 1);
-            expect(result).toEqual({
-                name: 'Apartment',
-                namePlural: 'Apartments',
-            });
-        }));
-        it('should return null when requested id not found', (_a) => __awaiter(void 0, [_a], void 0, function* ({ api, mockResponse }) {
-            const catalogName = 'property_type';
-            const culture = 'en';
-            const mockEntries = [
-                { id: 1, name: 'Apartment', name_plurial: 'Apartments' },
-            ];
-            mockResponse({ json: () => mockEntries });
-            const result = yield api.populateCache(catalogName, culture, 999);
-            expect(result).toBeNull();
-        }));
-    });
-});

package/dist/src/services/storage/dummy.cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/storage/dummy.cache.test.js

@@ -1,96 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DummyCache } from './dummy.cache';
-import { CacheExpiredError } from './types';
-describe('cache - Dummy', () => {
-    let cache;
-    beforeEach(() => {
-        cache = new DummyCache();
-    });
-    afterEach(() => {
-        // No cleanup needed for dummy cache
-    });
-    describe('constructor', () => {
-        it('should create an instance without any configuration', () => {
-            const dummyCache = new DummyCache();
-            expect(dummyCache).toBeInstanceOf(DummyCache);
-        });
-    });
-    describe('setEntries', () => {
-        const culture = 'en';
-        const entries = [
-            { id: 1, name: 'Item 1', name_plurial: 'Items 1' },
-            { id: 2, name: 'Item 2', name_plurial: 'Items 2' },
-        ];
-        it('should not throw when setting entries', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield expect(cache.setEntries(catalogName, culture, entries)).resolves.toBeUndefined();
-        }));
-        it('should handle empty entries array', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield expect(cache.setEntries(catalogName, culture, [])).resolves.toBeUndefined();
-        }));
-        it('should handle different catalog and culture combinations', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(cache.setEntries('book_step', 'en', entries)).resolves.toBeUndefined();
-            yield expect(cache.setEntries('property_land', 'fr', entries)).resolves.toBeUndefined();
-            yield expect(cache.setEntries('property_type', 'de', entries)).resolves.toBeUndefined();
-        }));
-    });
-    describe('getEntry', () => {
-        const culture = 'en';
-        it('should always throw CacheExpiredError regardless of parameters', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should throw CacheExpiredError for any ID', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield expect(cache.getEntry(catalogName, culture, 999)).rejects.toThrow(CacheExpiredError);
-            yield expect(cache.getEntry(catalogName, culture, 0)).rejects.toThrow(CacheExpiredError);
-            yield expect(cache.getEntry(catalogName, culture, -1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should throw CacheExpiredError for different catalogs and cultures', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(cache.getEntry('book_step', 'en', 1)).rejects.toThrow(CacheExpiredError);
-            yield expect(cache.getEntry('property_land', 'fr', 1)).rejects.toThrow(CacheExpiredError);
-            yield expect(cache.getEntry('property_type', 'de', 1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should throw CacheExpiredError even after setting entries', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const entries = [{ id: 1, name: 'Item 1', name_plurial: 'Items 1' }];
-            yield cache.setEntries(catalogName, culture, entries);
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-        }));
-    });
-    describe('behavior consistency', () => {
-        it('should behave consistently across multiple calls', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const culture = 'en';
-            const entries = [{ id: 1, name: 'Item 1', name_plurial: 'Items 1' }];
-            // Multiple setEntries calls should not throw
-            yield expect(cache.setEntries(catalogName, culture, entries)).resolves.toBeUndefined();
-            yield expect(cache.setEntries(catalogName, culture, entries)).resolves.toBeUndefined();
-            // Multiple getEntry calls should always throw
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should maintain dummy behavior regardless of cache state', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const culture = 'en';
-            // Should throw before any operations
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-            // Should still throw after setting entries
-            yield cache.setEntries(catalogName, culture, [{ id: 1, name: 'Test', name_plurial: 'Tests' }]);
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-            // Should still throw after multiple operations
-            yield cache.setEntries(catalogName, culture, []);
-            yield expect(cache.getEntry(catalogName, culture, 999)).rejects.toThrow(CacheExpiredError);
-        }));
-    });
-});

package/dist/src/services/storage/filesystem.cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/storage/filesystem.cache.test.js

@@ -1,197 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { existsSync, mkdirSync, rmSync } from 'node:fs';
-import { readFile, writeFile } from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { FilesystemCache } from './filesystem.cache';
-import { CacheExpiredError } from './types';
-describe('cache - Filesystem', () => {
-    let tempDir;
-    let cache;
-    beforeEach(() => {
-        // Create a unique temporary directory for each test
-        tempDir = path.join(os.tmpdir(), `filesystem-cache-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        mkdirSync(tempDir, { recursive: true });
-    });
-    afterEach(() => {
-        // Clean up the temporary directory after each test
-        if (existsSync(tempDir)) {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    });
-    describe('constructor', () => {
-        it('should use default cache location and expiration when no settings provided', () => {
-            // eslint-disable-next-line no-new
-            new FilesystemCache();
-            expect(existsSync('./cache/catalogs')).toBe(true);
-        });
-        it('should create custom cache directory when provided', () => {
-            const customPath = path.join(tempDir, 'custom-cache');
-            cache = new FilesystemCache({ path: customPath });
-            expect(existsSync(customPath)).toBe(true);
-        });
-        it('should use custom expiration time when provided', () => {
-            const customExpiration = 60000;
-            cache = new FilesystemCache({
-                path: tempDir,
-                cacheExpirationMs: customExpiration,
-            });
-            // The expiration time is private, but we can test its effect
-            expect(cache).toBeInstanceOf(FilesystemCache);
-        });
-        it('should create nested directories recursively', () => {
-            const nestedPath = path.join(tempDir, 'level1', 'level2', 'cache');
-            cache = new FilesystemCache({ path: nestedPath });
-            expect(existsSync(nestedPath)).toBe(true);
-        });
-    });
-    describe('setEntries and getEntry', () => {
-        const culture = 'en';
-        const entries = [
-            { id: 1, name: 'Item 1', name_plurial: 'Items 1' },
-            { id: 2, name: 'Item 2', name_plurial: 'Items 2' },
-        ];
-        beforeEach(() => {
-            cache = new FilesystemCache({ path: tempDir });
-        });
-        it('should store and retrieve entries correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield cache.setEntries(catalogName, culture, entries);
-            const entry1 = yield cache.getEntry(catalogName, culture, 1);
-            const entry2 = yield cache.getEntry(catalogName, culture, 2);
-            expect(entry1).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            expect(entry2).toEqual({ name: 'Item 2', namePlural: 'Items 2' });
-        }));
-        it('should create cache file with correct format', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield cache.setEntries(catalogName, culture, entries);
-            const filePath = path.join(tempDir, `${catalogName}-${culture}.json`);
-            expect(existsSync(filePath)).toBe(true);
-            const fileContent = yield readFile(filePath, 'utf-8');
-            const parsed = JSON.parse(fileContent);
-            expect(parsed).toHaveProperty('timestamp');
-            expect(parsed).toHaveProperty('cache');
-            expect(parsed.cache).toEqual({
-                1: { name: 'Item 1', namePlural: 'Items 1' },
-                2: { name: 'Item 2', namePlural: 'Items 2' },
-            });
-            expect(typeof parsed.timestamp).toBe('number');
-        }));
-        it('should return null for non-existent entry', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield cache.setEntries(catalogName, culture, entries);
-            const entry = yield cache.getEntry(catalogName, culture, 999);
-            expect(entry).toBeNull();
-        }));
-        it('should throw CacheExpiredError when cache file does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should throw CacheExpiredError when cache has expired', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const expiredCache = new FilesystemCache({
-                path: tempDir,
-                cacheExpirationMs: 1,
-            });
-            yield expiredCache.setEntries(catalogName, culture, entries);
-            yield new Promise(resolve => setTimeout(resolve, 10));
-            yield expect(expiredCache.getEntry(catalogName, culture, 1)).rejects.toThrow(CacheExpiredError);
-        }));
-        it('should handle different catalog and culture combinations', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield cache.setEntries('book_step', 'en', entries);
-            yield cache.setEntries('property_land', 'fr', entries);
-            const entry1 = yield cache.getEntry('book_step', 'en', 1);
-            const entry2 = yield cache.getEntry('property_land', 'fr', 1);
-            expect(entry1).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            expect(entry2).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            yield expect(cache.getEntry('book_step', 'fr', 1)).rejects.toThrow(CacheExpiredError);
-            // Verify separate files were created
-            expect(existsSync(path.join(tempDir, 'book_step-en.json'))).toBe(true);
-            expect(existsSync(path.join(tempDir, 'property_land-fr.json'))).toBe(true);
-            expect(existsSync(path.join(tempDir, 'book_step-fr.json'))).toBe(false);
-        }));
-        it('should overwrite existing cache when setting new entries', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'property_land';
-            yield cache.setEntries(catalogName, culture, entries);
-            const newEntries = [{ id: 3, name: 'New Item', name_plurial: 'New Items' }];
-            yield cache.setEntries(catalogName, culture, newEntries);
-            const newEntry = yield cache.getEntry(catalogName, culture, 3);
-            expect(newEntry).toEqual({ name: 'New Item', namePlural: 'New Items' });
-            const oldEntry = yield cache.getEntry(catalogName, culture, 1);
-            expect(oldEntry).toBeNull();
-        }));
-        it('should handle entries with undefined name_plurial', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const entriesWithUndefined = [
-                { id: 1, name: 'Item 1', name_plurial: undefined },
-                { id: 2, name: 'Item 2', name_plurial: 'Items 2' },
-            ];
-            yield cache.setEntries(catalogName, culture, entriesWithUndefined);
-            const entry1 = yield cache.getEntry(catalogName, culture, 1);
-            const entry2 = yield cache.getEntry(catalogName, culture, 2);
-            expect(entry1).toEqual({ name: 'Item 1', namePlural: undefined });
-            expect(entry2).toEqual({ name: 'Item 2', namePlural: 'Items 2' });
-        }));
-        it('should handle large entry IDs correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const largeIdEntries = [
-                { id: 999999999, name: 'Large ID Item', name_plurial: 'Large ID Items' },
-            ];
-            yield cache.setEntries(catalogName, culture, largeIdEntries);
-            const entry = yield cache.getEntry(catalogName, culture, 999999999);
-            expect(entry).toEqual({ name: 'Large ID Item', namePlural: 'Large ID Items' });
-        }));
-        it('should persist cache across multiple FilesystemCache instances', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            // Create cache with first instance
-            const cache1 = new FilesystemCache({ path: tempDir });
-            yield cache1.setEntries(catalogName, culture, entries);
-            // Access cache with second instance
-            const cache2 = new FilesystemCache({ path: tempDir });
-            const entry = yield cache2.getEntry(catalogName, culture, 1);
-            expect(entry).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-        }));
-    });
-    describe('error handling', () => {
-        beforeEach(() => {
-            cache = new FilesystemCache({ path: tempDir });
-        });
-        it('should handle malformed JSON files gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const culture = 'en';
-            const filePath = path.join(tempDir, `${catalogName}-${culture}.json`);
-            // Write malformed JSON
-            yield writeFile(filePath, 'invalid json content');
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow();
-        }));
-        it('should handle files with missing timestamp', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const culture = 'en';
-            const filePath = path.join(tempDir, `${catalogName}-${culture}.json`);
-            // Write JSON without timestamp
-            yield writeFile(filePath, JSON.stringify({
-                cache: { 1: { name: 'Test', namePlural: 'Tests' } },
-            }));
-            yield expect(cache.getEntry(catalogName, culture, 1)).resolves.toStrictEqual({ name: 'Test', namePlural: 'Tests' });
-        }));
-        it('should handle files with missing cache property', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const culture = 'en';
-            const filePath = path.join(tempDir, `${catalogName}-${culture}.json`);
-            // Write JSON without cache property
-            yield writeFile(filePath, JSON.stringify({
-                timestamp: Date.now(),
-            }));
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrow();
-        }));
-    });
-});

package/dist/src/services/storage/memory.cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/services/storage/memory.cache.test.js

@@ -1,80 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { describe, expect, it } from 'vitest';
-import { MemoryCache } from './memory.cache';
-describe('cache - Memory', () => {
-    describe('constructor', () => {
-        it('should use default expiration time when no settings provided', () => {
-            const defaultCache = new MemoryCache();
-            expect(defaultCache.cacheExpirationMs).toBe(7 * 24 * 60 * 60 * 1000);
-        });
-        it('should use custom expiration time when provided', () => {
-            const customExpiration = 60000;
-            const customCache = new MemoryCache({ cacheExpirationMs: customExpiration });
-            expect(customCache.cacheExpirationMs).toBe(customExpiration);
-        });
-    });
-    describe('setEntries and getEntry', () => {
-        const culture = 'en';
-        const entries = [
-            { id: 1, name: 'Item 1', name_plurial: 'Items 1' },
-            { id: 2, name: 'Item 2', name_plurial: 'Items 2' },
-        ];
-        it('should store and retrieve entries correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-            const cache = new MemoryCache();
-            const catalogName = 'book_step';
-            yield cache.setEntries(catalogName, culture, entries);
-            const entry1 = yield cache.getEntry(catalogName, culture, 1);
-            const entry2 = yield cache.getEntry(catalogName, culture, 2);
-            expect(entry1).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            expect(entry2).toEqual({ name: 'Item 2', namePlural: 'Items 2' });
-        }));
-        it('should return null for non-existent entry', () => __awaiter(void 0, void 0, void 0, function* () {
-            const cache = new MemoryCache();
-            const catalogName = 'book_step';
-            yield cache.setEntries(catalogName, culture, entries);
-            const entry = yield cache.getEntry(catalogName, culture, 999);
-            expect(entry).toBeNull();
-        }));
-        it('should throw CacheExpiredError when cache entry does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            const cache = new MemoryCache();
-            const catalogName = 'book_step';
-            yield expect(cache.getEntry(catalogName, culture, 1)).rejects.toThrowError();
-        }));
-        it('should throw CacheExpiredError when cache has expired', () => __awaiter(void 0, void 0, void 0, function* () {
-            const catalogName = 'book_step';
-            const expiredCache = new MemoryCache({ cacheExpirationMs: 1 });
-            yield expiredCache.setEntries(catalogName, culture, entries);
-            yield new Promise(resolve => setTimeout(resolve, 10));
-            yield expect(expiredCache.getEntry(catalogName, culture, 1)).rejects.toThrowError();
-        }));
-        it('should handle different catalog and culture combinations', () => __awaiter(void 0, void 0, void 0, function* () {
-            const cache = new MemoryCache();
-            yield cache.setEntries('book_step', 'en', entries);
-            yield cache.setEntries('property_land', 'fr', entries);
-            const entry1 = yield cache.getEntry('book_step', 'en', 1);
-            const entry2 = yield cache.getEntry('property_land', 'fr', 1);
-            expect(entry1).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            expect(entry2).toEqual({ name: 'Item 1', namePlural: 'Items 1' });
-            yield expect(cache.getEntry('book_step', 'fr', 1)).rejects.toThrowError();
-        }));
-        it('should overwrite existing cache when setting new entries', () => __awaiter(void 0, void 0, void 0, function* () {
-            const cache = new MemoryCache();
-            const catalogName = 'property_land';
-            yield cache.setEntries(catalogName, culture, entries);
-            const newEntries = [{ id: 3, name: 'New Item', name_plurial: 'New Items' }];
-            yield cache.setEntries(catalogName, culture, newEntries);
-            const newEntry = yield cache.getEntry(catalogName, culture, 3);
-            expect(newEntry).toEqual({ name: 'New Item', namePlural: 'New Items' });
-            const oldEntry = yield cache.getEntry(catalogName, culture, 1);
-            expect(oldEntry).toBeNull();
-        }));
-    });
-});

package/dist/src/utils/url.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/utils/url.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { DEFAULT_ADDITIONAL_CONFIG } from '../core/api';
-import { makeApiUrl } from './url';
-const CONFIG = DEFAULT_ADDITIONAL_CONFIG;
-describe('url util', () => {
-    it('should, given an array of parts return a complete url', () => {
-        const url = makeApiUrl(['hello', 'world'], CONFIG);
-        expect(url.href).toBe('https://api.apimo.pro/hello/world');
-    });
-    it('should, given an array of parts and search params return a complete url', () => {
-        const url = makeApiUrl(['hello', 'world'], CONFIG, { culture: 'fr', limit: 10 });
-        expect(url.href).toBe('https://api.apimo.pro/hello/world?culture=fr&limit=10');
-    });
-    it('should, given an array of parts and search params with undefined values, ignore them', () => {
-        const url = makeApiUrl(['hello', 'world'], CONFIG, { culture: 'fr', limit: undefined });
-        expect(url.href).toBe('https://api.apimo.pro/hello/world?culture=fr');
-    });
-});

package/dist/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;

package/dist/vitest.config.js

@@ -1,6 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        setupFiles: ['dotenv/config'],
-    },
-});