apimo.js 1.0.2 → 1.0.4

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Vitaly Lysen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -346,6 +346,14 @@ To use this library, you need:
 
 Contact [Apimo customer service](https://apimo.net/en/contact/) to request your credentials.
 
+## Currently Missing Features
+
+- [ ] **Hardened error handling**: More robust error handling for API responses
+- [ ] **Exported types & schemas**: Export all internal types & schemas for better TypeScript integration & validation
+- [ ] **Minified build**: Smaller production build size
+- [ ] **Documentation for all methods**: Complete API documentation for all available methods
+- [ ] **More comprehensive tests**: Additional test coverage for edge cases
+
 ## Support
 
 - 📖 [Apimo API Documentation](https://apimo.net/en/api/webservice/)

package/dist/{src/index.d.ts → index.d.ts}

@@ -2,7 +2,9 @@ export type { CatalogName } from './consts/catalogs';
 export type { ApiCulture } from './consts/languages';
 export { type AdditionalConfig, Apimo, DEFAULT_ADDITIONAL_CONFIG, DEFAULT_BASE_URL } from './core/api';
 export { Apimo as Api } from './core/api';
-export type { CatalogDefinition, CatalogEntry, CatalogTransformer, LocalizedCatalogTransformer } from './schemas/common';
+export type { ApimoAgency, ApimoPartner, ApimoRate } from './schemas/agency';
+export type { ApimoCity, ApimoUser, CatalogDefinition, CatalogEntry, CatalogTransformer, LocalizedCatalogTransformer, } from './schemas/common';
+export type { ApimoAgreement, ApimoArea, ApimoComment, ApimoConstruction, ApimoFloor, ApimoHeating, ApimoPicture, ApimoPlot, ApimoPrice, ApimoProperty, ApimoRegulation, ApimoResidence, ApimoSurface, ApimoView, ApimoWater, } from './schemas/property';
 export { DummyCache } from './services/storage/dummy.cache';
 export { FilesystemCache } from './services/storage/filesystem.cache';
 export { MemoryCache } from './services/storage/memory.cache';

package/dist/{src/schemas → schemas}/agency.d.ts

@@ -414,3 +414,6 @@ export declare function getAgencySchema(transformer: LocalizedCatalogTransformer
     brand?: unknown;
     district?: unknown;
 }>;
+export type ApimoAgency = z.infer<ReturnType<typeof getAgencySchema>>;
+export type ApimoPartner = z.infer<typeof PartnerSchema>;
+export type ApimoRate = z.infer<ReturnType<typeof getRateSchema>>;

package/dist/{src/schemas → schemas}/common.d.ts

@@ -151,3 +151,5 @@ export declare function getUserSchema(transformer: LocalizedCatalogTransformer):
     stories?: unknown[] | undefined;
     rates?: unknown;
 }>;
+export type ApimoUser = z.infer<ReturnType<typeof getUserSchema>>;
+export type ApimoCity = z.infer<typeof CitySchema>;

package/dist/{src/schemas → schemas}/property.d.ts

@@ -1498,3 +1498,18 @@ export declare function getPropertySchema(transformer: LocalizedCatalogTransform
     interagency_comment?: unknown;
     status_comment?: unknown;
 }>;
+export type ApimoProperty = z.infer<ReturnType<typeof getPropertySchema>>;
+export type ApimoRegulation = z.infer<ReturnType<typeof getRegulationSchema>>;
+export type ApimoConstruction = z.infer<ReturnType<typeof getConstructionSchema>>;
+export type ApimoFloor = z.infer<ReturnType<typeof getFloorSchema>>;
+export type ApimoHeating = z.infer<ReturnType<typeof getHeatingSchema>>;
+export type ApimoWater = z.infer<ReturnType<typeof getWaterSchema>>;
+export type ApimoPrice = z.infer<ReturnType<typeof getPriceSchema>>;
+export type ApimoResidence = z.infer<ReturnType<typeof getResidenceSchema>>;
+export type ApimoView = z.infer<ReturnType<typeof getViewSchema>>;
+export type ApimoAgreement = z.infer<ReturnType<typeof getAgreementSchema>>;
+export type ApimoSurface = z.infer<ReturnType<typeof getSurfaceSchema>>;
+export type ApimoPlot = z.infer<ReturnType<typeof getPlotSchema>>;
+export type ApimoArea = z.infer<ReturnType<typeof getAreaSchema>>;
+export type ApimoPicture = z.infer<typeof PictureSchema>;
+export type ApimoComment = z.infer<typeof CommentSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apimo.js",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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'],
-    },
-});