apimo.js 1.0.1

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

@@ -0,0 +1,197 @@
+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.d.ts

@@ -0,0 +1,20 @@
+import type { CatalogName } from '../../consts/catalogs';
+import type { ApiCulture } from '../../consts/languages';
+import type { CatalogEntry } from '../../schemas/common';
+import type { ApiCacheAdapter, CatalogEntryName } from './types';
+type Memory = Map<string, {
+    timestamp: number;
+    cache: Map<number, CatalogEntryName>;
+}>;
+export declare class MemoryCache implements ApiCacheAdapter {
+    readonly cacheExpirationMs: number;
+    readonly _MEMORY: Memory;
+    constructor(settings?: {
+        cacheExpirationMs?: number;
+    });
+    setEntries(catalogName: CatalogName, culture: ApiCulture, entries: CatalogEntry[]): Promise<void>;
+    getEntry(catalogName: CatalogName, culture: ApiCulture, id: number): Promise<CatalogEntryName | null>;
+    getEntries(catalogName: CatalogName, culture: ApiCulture): Promise<CatalogEntry[]>;
+    private getCacheKey;
+}
+export {};

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

@@ -0,0 +1,62 @@
+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 { CacheExpiredError } from './types';
+const MS_IN_ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+export class MemoryCache {
+    constructor(settings) {
+        var _a;
+        this.cacheExpirationMs = (_a = settings === null || settings === void 0 ? void 0 : settings.cacheExpirationMs) !== null && _a !== void 0 ? _a : MS_IN_ONE_WEEK;
+        this._MEMORY = new Map();
+    }
+    setEntries(catalogName, culture, entries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memoryEntry = new Map(entries.map(({ id, name, name_plurial }) => [id, {
+                    name,
+                    namePlural: name_plurial,
+                }]));
+            this._MEMORY.set(this.getCacheKey(catalogName, culture), {
+                timestamp: Date.now(),
+                cache: memoryEntry,
+            });
+        });
+    }
+    getEntry(catalogName, culture, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const memoryEntry = this._MEMORY.get(this.getCacheKey(catalogName, culture));
+            if (!memoryEntry) {
+                throw new CacheExpiredError();
+            }
+            if (memoryEntry.timestamp + this.cacheExpirationMs < Date.now()) {
+                throw new CacheExpiredError();
+            }
+            return (_a = memoryEntry.cache.get(id)) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    getEntries(catalogName, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memoryEntry = this._MEMORY.get(this.getCacheKey(catalogName, culture));
+            if (!memoryEntry) {
+                throw new CacheExpiredError();
+            }
+            if (memoryEntry.timestamp + this.cacheExpirationMs < Date.now()) {
+                throw new CacheExpiredError();
+            }
+            return Array.from(memoryEntry.cache.entries()).map(([id, { name, namePlural }]) => ({
+                id,
+                name,
+                name_plurial: namePlural,
+            }));
+        });
+    }
+    getCacheKey(catalogName, culture) {
+        return `${catalogName}.${culture}`;
+    }
+}

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

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

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

@@ -0,0 +1,80 @@
+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/services/storage/types.d.ts

@@ -0,0 +1,16 @@
+import type { CatalogName } from '../../consts/catalogs';
+import type { ApiCulture } from '../../consts/languages';
+import type { CatalogEntry } from '../../schemas/common';
+export interface CatalogEntryName {
+    name: string;
+    namePlural: string | undefined;
+}
+export interface ApiCacheAdapter {
+    setEntries: (catalogName: CatalogName, culture: ApiCulture, entries: CatalogEntry[]) => Promise<void>;
+    getEntry: (catalogName: CatalogName, culture: ApiCulture, id: number) => Promise<CatalogEntryName | null>;
+    getEntries: (catalogName: CatalogName, culture: ApiCulture) => Promise<CatalogEntry[]>;
+}
+export declare class CacheExpiredError extends Error {
+}
+export declare class NotInCacheError extends Error {
+}

package/dist/src/services/storage/types.js

@@ -0,0 +1,4 @@
+export class CacheExpiredError extends Error {
+}
+export class NotInCacheError extends Error {
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,4 @@
+export type LACK_OF_DOCUMENTATION = string;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/dist/src/types/index.js

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

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

@@ -0,0 +1,14 @@
+import type { ApiCulture } from '../consts/languages';
+import type { AdditionalConfig } from '../core/api';
+import type { LACK_OF_DOCUMENTATION } from '../types';
+export interface ApiSearchParams {
+    culture?: ApiCulture;
+    limit?: number;
+    offset?: number;
+    timestamp?: number;
+    step?: LACK_OF_DOCUMENTATION;
+    status?: LACK_OF_DOCUMENTATION;
+    group?: LACK_OF_DOCUMENTATION;
+    [key: string]: string | number | undefined;
+}
+export declare function makeApiUrl(pathParts: string[], config: AdditionalConfig, searchParams?: Partial<ApiSearchParams>): URL;

package/dist/src/utils/url.js

@@ -0,0 +1,11 @@
+export function makeApiUrl(pathParts, config, searchParams) {
+    const url = new URL(pathParts.join('/'), config.baseUrl);
+    if (searchParams) {
+        Object.entries(searchParams).forEach(([key, value]) => {
+            if (value !== undefined) {
+                url.searchParams.append(key, value.toString());
+            }
+        });
+    }
+    return url;
+}

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

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

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

@@ -0,0 +1,18 @@
+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

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

package/dist/vitest.config.js

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

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import antfu from '@antfu/eslint-config'
+
+export default antfu()

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "apimo.js",
+  "version": "1.0.1",
+  "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",
+  "homepage": "https://github.com/Neikow/apimo.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Neikow/apimo.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Neikow/apimo.js/issues"
+  },
+  "keywords": [
+    "api",
+    "apimo",
+    "real-estate"
+  ],
+  "main": "/dist/index.js",
+  "scripts": {
+    "dev": "",
+    "build": "tsc",
+    "run": "node dist/index.js",
+    "test": "vitest run",
+    "test-coverage": "vitest run --coverage",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "bottleneck": "^2.19.5",
+    "merge-anything": "^6.0.6",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@anatine/zod-mock": "^3.14.0",
+    "@antfu/eslint-config": "^5.0.0",
+    "@faker-js/faker": "^9.9.0",
+    "@types/node": "^24.1.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^17.2.1",
+    "eslint": "^9.32.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}

package/src/consts/catalogs.ts

@@ -0,0 +1,55 @@
+export const API_CATALOGS = [
+  'action_type',
+  'action_method',
+  'book_step',
+  'book_type',
+  'construction_step',
+  'contact_title',
+  'document_type',
+  'fees',
+  'lead_type',
+  'lead_step',
+  'property_activity',
+  'property_areas',
+  'property_adjacency',
+  'property_agreement',
+  'property_availability',
+  'property_building',
+  'property_category',
+  'property_subcategory',
+  'property_condition',
+  'property_construction_method',
+  'property_floor',
+  'property_flooring',
+  'property_heating_device',
+  'property_heating_access',
+  'property_heating_type',
+  'property_hot_water_device',
+  'property_hot_water_access',
+  'property_land',
+  'property_lease',
+  'property_location',
+  'property_orientation',
+  'property_period',
+  'property_proximity',
+  'property_reglementation',
+  'property_regulation',
+  'property_financial',
+  'property_service',
+  'property_service_category',
+  'property_standing',
+  'property_step',
+  'property_status',
+  'property_type',
+  'property_subtype',
+  'property_view_landscape',
+  'property_view_type',
+  'property_waste_water',
+  'referral',
+  'tags',
+  'unit_area',
+  'unit_length',
+  'user_group',
+] as const
+
+export type CatalogName = typeof API_CATALOGS[number]

package/src/consts/languages.ts

@@ -0,0 +1,22 @@
+export const API_LANGUAGES = [
+  'fr',
+  'it',
+  'de',
+  'es',
+  'en',
+  'nl',
+  'zh',
+  'ru',
+  'sv',
+  'ar',
+  'he',
+  'nb',
+  'pt',
+  'fa',
+  'lb',
+  'km',
+  'tr',
+  'lo',
+] as const
+
+export type ApiCulture = (typeof API_LANGUAGES)[number]