apimo.js 1.0.1

package/dist/src/schemas/property.js

@@ -0,0 +1,238 @@
+import { z } from 'zod';
+import { Converters } from '../core/converters';
+import { CitySchema, getUserSchema, NameIdPairSchema } from './common';
+import { TYPE_UNDOCUMENTED, TYPE_UNDOCUMENTED_NULLABLE } from './internal';
+export function getAgreementSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_agreement', v)),
+        reference: z.string(),
+        start_at: z.coerce.string().transform(Converters.toDate),
+        end_at: z.coerce.string().transform(Converters.toDate),
+    });
+}
+export function getSurfaceSchema(transformer) {
+    return z.object({
+        unit: z.coerce.number().transform(v => transformer('unit_area', v)),
+        value: z.coerce.number(),
+        total: z.coerce.number(),
+        weighted: z.coerce.number(),
+    });
+}
+export function getPlotSchema(transformer) {
+    return z.object({
+        net_floor: z.coerce.number(),
+        land_type: z.coerce.number().transform(v => transformer('property_land', v)),
+        width: z.coerce.number(),
+        height: z.coerce.number().optional(),
+        serviced_plot: z.boolean(),
+    });
+}
+export function getPriceSchema(transformer) {
+    return z.object({
+        value: z.coerce.number(),
+        max: z.coerce.number(),
+        fees: z.coerce.number(),
+        unit: TYPE_UNDOCUMENTED_NULLABLE,
+        period: z.coerce.number().transform(v => transformer('property_period', v)),
+        hide: z.coerce.boolean(),
+        inventory: z.number().nullable(),
+        deposit: z.number().nullable(),
+        currency: z.string().toLowerCase(),
+        commission: z.number().nullable(),
+        transfer_tax: TYPE_UNDOCUMENTED_NULLABLE,
+        contribution: TYPE_UNDOCUMENTED_NULLABLE,
+        pension: TYPE_UNDOCUMENTED_NULLABLE,
+        tenant: z.number().nullable(),
+        vat: z.boolean().nullable(),
+    });
+}
+export function getResidenceSchema(transformer) {
+    return z.object({
+        id: z.coerce.number(),
+        type: z.coerce.number().transform(v => transformer('property_building', v)),
+        fees: z.coerce.number(),
+        period: z.coerce.number().transform(v => transformer('property_period', v)),
+        lots: z.coerce.number(),
+    });
+}
+export function getViewSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_view_type', v)),
+        landscape: z.coerce.number().transform(v => transformer('property_view_landscape', v)).array(),
+    });
+}
+export function getConstructionSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_construction_method', v)).array().optional(),
+        construction_year: z.coerce.number(),
+        renovation_year: z.coerce.number(),
+        renovation_cost: z.coerce.number(),
+        construction_step: z.coerce.number().transform(v => transformer('construction_step', v)),
+    });
+}
+export function getFloorSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_floor', v)),
+        value: z.coerce.number(),
+        levels: z.coerce.number(),
+        floors: z.coerce.number(),
+    });
+}
+export function getHeatingSchema(transformer) {
+    return z.object({
+        device: z.coerce.number().transform(v => transformer('property_heating_device', v)),
+        devices: z.coerce.number().transform(v => transformer('property_heating_device', v)).array().nullable(),
+        access: z.coerce.number().transform(v => transformer('property_heating_access', v)),
+        type: z.coerce.number().transform(v => transformer('property_heating_type', v)),
+        types: z.coerce.number().transform(v => transformer('property_heating_type', v)).array().nullable(),
+    });
+}
+export function getWaterSchema(transformer) {
+    return z.object({
+        hot_device: z.coerce.number().transform(v => transformer('property_hot_water_device', v)),
+        hot_access: z.coerce.number().transform(v => transformer('property_hot_water_access', v)),
+        waste: z.coerce.number().transform(v => transformer('property_waste_water', v)),
+    });
+}
+export const CommentSchema = z.object({
+    language: z.string(),
+    title: z.string().optional().nullable(),
+    subtitle: z.string().optional().nullable(),
+    hook: TYPE_UNDOCUMENTED_NULLABLE.optional(),
+    comment: z.string(),
+    comment_full: z.string().optional().nullable(),
+});
+export const PictureSchema = z.object({
+    id: z.coerce.number(),
+    rank: z.coerce.number(),
+    url: z.string(),
+    width_max: z.coerce.number(),
+    height_max: z.coerce.number(),
+    internet: z.coerce.boolean(),
+    print: z.coerce.boolean(),
+    panorama: z.coerce.boolean(),
+    child: z.coerce.number(),
+    reference: TYPE_UNDOCUMENTED_NULLABLE,
+    comments: CommentSchema.array(),
+});
+export function getAreaSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_areas', v)),
+        number: z.coerce.number(),
+        area: z.coerce.number(),
+        flooring: z.coerce.number().transform(v => transformer('property_flooring', v)),
+        ceiling_height: z.number().nullable(),
+        floor: z.object({
+            type: z.coerce.number().transform(v => transformer('property_floor', v)),
+            value: z.coerce.number(),
+        }),
+        orientations: z.coerce.number().transform(v => transformer('property_orientation', v)).array(),
+        comments: CommentSchema.array(),
+        lot: z.object({
+            type: TYPE_UNDOCUMENTED_NULLABLE,
+            rank: TYPE_UNDOCUMENTED_NULLABLE,
+            name: TYPE_UNDOCUMENTED.array(),
+        }),
+    });
+}
+export function getRegulationSchema(transformer) {
+    return z.object({
+        type: z.coerce.number().transform(v => transformer('property_regulation', v)),
+        value: z.coerce.string().transform((v) => {
+            const values = v.split(',');
+            return values.map(value => Number.parseInt(value));
+        }),
+        date: z.string().transform(Converters.toDate).nullable(),
+        graph: z.string().nullable(),
+    });
+}
+export function getPropertySchema(transformer) {
+    return z.object({
+        id: z.coerce.number(),
+        reference: z.number(),
+        agency: z.coerce.number(),
+        brand: TYPE_UNDOCUMENTED_NULLABLE,
+        sector: TYPE_UNDOCUMENTED_NULLABLE,
+        user: getUserSchema(transformer),
+        step: z.number().transform(v => transformer('property_step', v)),
+        status: z.number().transform(v => transformer('property_status', v)),
+        parent: z.number().nullable(),
+        ranking: TYPE_UNDOCUMENTED_NULLABLE,
+        category: z.coerce.number().transform(v => transformer('property_category', v)),
+        name: z.string().nullable(),
+        type: z.coerce.number().transform(v => transformer('property_type', v)),
+        subtype: z.coerce.number().transform(v => transformer('property_subtype', v)),
+        agreement: getAgreementSchema(transformer).nullable(),
+        block_name: z.string().nullable(),
+        lot_reference: z.string().nullable(),
+        cadastre_reference: z.string().nullable(),
+        stairs_reference: z.string().nullable(),
+        address: z.string().nullable(),
+        address_more: z.string().nullable(),
+        publish_address: z.coerce.boolean(),
+        country: z.string().toLowerCase(),
+        region: NameIdPairSchema,
+        city: CitySchema,
+        original_city: TYPE_UNDOCUMENTED_NULLABLE,
+        district: NameIdPairSchema.nullable(),
+        original_district: TYPE_UNDOCUMENTED_NULLABLE,
+        location: TYPE_UNDOCUMENTED_NULLABLE,
+        longitude: z.coerce.number(),
+        latitude: z.coerce.number(),
+        radius: z.coerce.number(),
+        altitude: z.coerce.number(),
+        referral: TYPE_UNDOCUMENTED_NULLABLE,
+        subreferral: TYPE_UNDOCUMENTED_NULLABLE,
+        area: getSurfaceSchema(transformer),
+        plot: getPlotSchema(transformer),
+        rooms: z.coerce.number(),
+        bedrooms: z.coerce.number(),
+        sleeps: z.coerce.number(),
+        price: getPriceSchema(transformer),
+        rates: z.unknown().array(),
+        owner: TYPE_UNDOCUMENTED_NULLABLE,
+        visit: TYPE_UNDOCUMENTED_NULLABLE,
+        residence: getResidenceSchema(transformer).nullable(),
+        view: getViewSchema(transformer).nullable(),
+        construction: getConstructionSchema(transformer),
+        floor: getFloorSchema(transformer),
+        heating: getHeatingSchema(transformer),
+        water: getWaterSchema(transformer),
+        condition: z.coerce.number().transform(v => transformer('property_condition', v)),
+        standing: z.coerce.number().transform(v => transformer('property_standing', v)),
+        style: z.object({ name: z.string().nullable() }),
+        twinned: z.coerce.number().nullable(),
+        facades: z.coerce.number(),
+        length: z.coerce.number().nullable(),
+        height: z.coerce.number().nullable(),
+        url: z.string().nullable(),
+        availability: z.coerce.number().transform(v => transformer('property_availability', v)),
+        available_at: TYPE_UNDOCUMENTED_NULLABLE,
+        delivered_at: z.string().transform(Converters.toDate).nullable(),
+        activities: z.coerce.number().transform(v => transformer('property_activity', v)).array(),
+        orientations: z.coerce.number().transform(v => transformer('property_orientation', v)).array(),
+        services: z.coerce.number().transform(v => transformer('property_service', v)).array(),
+        proximities: z.coerce.number().transform(v => transformer('property_proximity', v)).array(),
+        tags: z.coerce.number().transform(v => transformer('tags', v)).array(),
+        tags_customized: z.unknown().array(),
+        pictures: PictureSchema.array(),
+        medias: z.unknown().array(),
+        documents: z.unknown().array(),
+        comments: CommentSchema.array(),
+        areas: getAreaSchema(transformer).array(),
+        regulations: getRegulationSchema(transformer).array(),
+        financial: z.unknown().array(),
+        exchanges: z.unknown().array(),
+        options: z.unknown().array(),
+        filling_rate: TYPE_UNDOCUMENTED_NULLABLE,
+        private_comment: TYPE_UNDOCUMENTED_NULLABLE,
+        interagency_comment: TYPE_UNDOCUMENTED_NULLABLE,
+        status_comment: TYPE_UNDOCUMENTED_NULLABLE,
+        logs: z.unknown().array(),
+        referrals: z.unknown().array(),
+        created_at: z.string().transform(Converters.toDate),
+        updated_at: z.string().transform(Converters.toDate),
+        created_by: z.coerce.number(),
+        updated_by: z.coerce.number(),
+    });
+}

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

@@ -0,0 +1,10 @@
+import type { CatalogName } from '../../consts/catalogs';
+import type { ApiCulture } from '../../consts/languages';
+import type { CatalogEntry } from '../../schemas/common';
+import type { ApiCacheAdapter, CatalogEntryName } from './types';
+export declare class DummyCache implements ApiCacheAdapter {
+    constructor();
+    getEntries(_catalogName: CatalogName, _culture: ApiCulture): Promise<CatalogEntry[]>;
+    setEntries(_catalogName: CatalogName, _culture: ApiCulture, _entries: CatalogEntry[]): Promise<void>;
+    getEntry(_catalogName: CatalogName, _culture: ApiCulture, _id: number): Promise<CatalogEntryName | null>;
+}

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

@@ -0,0 +1,28 @@
+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';
+export class DummyCache {
+    constructor() {
+    }
+    getEntries(_catalogName, _culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new CacheExpiredError();
+        });
+    }
+    setEntries(_catalogName, _culture, _entries) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    getEntry(_catalogName, _culture, _id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new CacheExpiredError();
+        });
+    }
+}

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

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

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

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

@@ -0,0 +1,18 @@
+import type { CatalogName } from '../../consts/catalogs';
+import type { ApiCulture } from '../../consts/languages';
+import type { CatalogEntry } from '../../schemas/common';
+import type { ApiCacheAdapter, CatalogEntryName } from './types';
+export declare class FilesystemCache implements ApiCacheAdapter {
+    private readonly path;
+    private readonly cacheExpirationMs;
+    constructor(settings?: {
+        path?: string;
+        cacheExpirationMs?: number;
+    });
+    setEntries(catalogName: CatalogName, culture: ApiCulture, entries: CatalogEntry[]): Promise<void>;
+    readFileOrThrow(filePath: string): Promise<string>;
+    getEntry(catalogName: CatalogName, culture: ApiCulture, id: number): Promise<CatalogEntryName | null>;
+    getEntries(catalogName: CatalogName, culture: ApiCulture): Promise<CatalogEntry[]>;
+    private getCacheFilePath;
+    private getCacheFileName;
+}

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

@@ -0,0 +1,85 @@
+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 { mkdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import { CacheExpiredError } from './types';
+const DEFAULT_FILESYSTEM_CACHE_LOCATION = './cache/catalogs';
+const MS_IN_ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+export class FilesystemCache {
+    constructor(settings) {
+        var _a, _b;
+        this.path = (_a = settings === null || settings === void 0 ? void 0 : settings.path) !== null && _a !== void 0 ? _a : DEFAULT_FILESYSTEM_CACHE_LOCATION;
+        this.cacheExpirationMs = (_b = settings === null || settings === void 0 ? void 0 : settings.cacheExpirationMs) !== null && _b !== void 0 ? _b : MS_IN_ONE_WEEK;
+        mkdirSync(this.path, { recursive: true });
+    }
+    setEntries(catalogName, culture, entries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = this.getCacheFilePath(catalogName, culture);
+            const formattedEntries = Object.fromEntries(entries.map(({ id, name, name_plurial }) => [id.toString(), {
+                    name,
+                    namePlural: name_plurial,
+                }]));
+            const dump = JSON.stringify({
+                timestamp: Date.now(),
+                cache: formattedEntries,
+            });
+            return writeFile(filePath, dump);
+        });
+    }
+    readFileOrThrow(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield readFile(filePath, 'utf-8');
+            }
+            catch (_a) {
+                throw new CacheExpiredError();
+            }
+        });
+    }
+    getEntry(catalogName, culture, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const filePath = this.getCacheFilePath(catalogName, culture);
+            const data = yield this.readFileOrThrow(filePath);
+            const parsed = JSON.parse(data);
+            const currentTimestamp = Date.now();
+            if (parsed.timestamp + this.cacheExpirationMs < currentTimestamp) {
+                throw new CacheExpiredError();
+            }
+            return (_a = parsed.cache[id.toString()]) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    getEntries(catalogName, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = this.getCacheFilePath(catalogName, culture);
+            const data = yield this.readFileOrThrow(filePath);
+            const parsed = JSON.parse(data);
+            const currentTimestamp = Date.now();
+            if (parsed.timestamp + this.cacheExpirationMs < currentTimestamp) {
+                throw new CacheExpiredError();
+            }
+            return Object.entries(parsed.cache).map(([id, entry]) => {
+                var _a;
+                return ({
+                    id: Number.parseInt(id, 10),
+                    name: (_a = entry === null || entry === void 0 ? void 0 : entry.name) !== null && _a !== void 0 ? _a : 'missing',
+                    name_plurial: entry === null || entry === void 0 ? void 0 : entry.namePlural,
+                });
+            });
+        });
+    }
+    getCacheFilePath(catalogName, culture) {
+        return path.join(this.path, this.getCacheFileName(catalogName, culture));
+    }
+    getCacheFileName(catalogName, culture) {
+        return `${catalogName}-${culture}.json`;
+    }
+}

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

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