apimo.js 1.0.1

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

@@ -0,0 +1,246 @@
+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 { Api, 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 Api('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(Api);
+        });
+        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 Api('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 Api('provider', 'token', {
+                catalogs: {
+                    cache: {
+                        adapter: new DummyCache(),
+                    },
+                },
+            });
+            expect(testApi.cache).toBeInstanceOf(DummyCache);
+        });
+        it('should use DummyCache when cache is not active', () => {
+            const testApi = new Api('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 Api('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/core/converters.d.ts

@@ -0,0 +1,4 @@
+export declare const Converters: {
+    toDate: (v: string) => Date;
+    toUrl: (path: string, baseUrl: string) => (v: string) => string;
+};

package/dist/src/core/converters.js

@@ -0,0 +1,4 @@
+export const Converters = {
+    toDate: (v) => new Date(v),
+    toUrl: (path, baseUrl) => (v) => new URL(`${path}${v}`, baseUrl).href,
+};

package/dist/src/schemas/agency.d.ts

@@ -0,0 +1,416 @@
+import type { AdditionalConfig } from '../core/api';
+import type { LocalizedCatalogTransformer } from './common';
+import { z } from 'zod';
+export declare function getRateSchema(transformer: LocalizedCatalogTransformer): z.ZodObject<{
+    id: z.ZodNumber;
+    category: z.ZodEffects<z.ZodNumber, string | import("../services/storage/types").CatalogEntryName | null, number>;
+    range_min: z.ZodNullable<z.ZodNumber>;
+    range_max: z.ZodNullable<z.ZodNumber>;
+    commission_price: z.ZodNullable<z.ZodNumber>;
+    commission_rate: z.ZodNullable<z.ZodNumber>;
+    comment: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    category: string | import("../services/storage/types").CatalogEntryName | null;
+    range_min: number | null;
+    range_max: number | null;
+    commission_price: number | null;
+    commission_rate: number | null;
+    comment: string;
+    url: string | null;
+}, {
+    id: number;
+    category: number;
+    range_min: number | null;
+    range_max: number | null;
+    commission_price: number | null;
+    commission_rate: number | null;
+    comment: string;
+    url: string | null;
+}>;
+export declare const PartnerSchema: z.ZodObject<{
+    type: z.ZodNumber;
+    partner: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    reference: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string | null;
+    type: number;
+    partner: number | null;
+    reference: string;
+    amount: number;
+    currency: string;
+}, {
+    name: string | null;
+    type: number;
+    partner: number | null;
+    reference: string;
+    amount: number;
+    currency: string;
+}>;
+export declare function getAgencySchema(transformer: LocalizedCatalogTransformer, config: AdditionalConfig): z.ZodObject<{
+    id: z.ZodNumber;
+    reference: z.ZodNumber;
+    active: z.ZodBoolean;
+    name: z.ZodString;
+    company: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        name: string;
+    }, {
+        id: number;
+        name: string;
+    }>;
+    brand: z.ZodNullable<z.ZodUnknown>;
+    networks: z.ZodArray<z.ZodUnknown, "many">;
+    address: z.ZodString;
+    address_more: z.ZodNullable<z.ZodString>;
+    city: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    } & {
+        zipcode: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        name: string;
+        zipcode: string;
+    }, {
+        id: number;
+        name: string;
+        zipcode: string;
+    }>;
+    district: z.ZodUnknown;
+    country: z.ZodString;
+    region: z.ZodString;
+    latitude: z.ZodNumber;
+    longitude: z.ZodNumber;
+    email: z.ZodString;
+    phone: z.ZodString;
+    fax: z.ZodNullable<z.ZodString>;
+    url: z.ZodString;
+    logo: z.ZodString;
+    logo_svg: z.ZodNullable<z.ZodString>;
+    picture: z.ZodString;
+    currency: z.ZodString;
+    timetable: z.ZodString;
+    created_at: z.ZodEffects<z.ZodString, Date, string>;
+    updated_at: z.ZodEffects<z.ZodString, Date, string>;
+    providers: z.ZodEffects<z.ZodString, string, string>;
+    rates: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        category: z.ZodEffects<z.ZodNumber, string | import("../services/storage/types").CatalogEntryName | null, number>;
+        range_min: z.ZodNullable<z.ZodNumber>;
+        range_max: z.ZodNullable<z.ZodNumber>;
+        commission_price: z.ZodNullable<z.ZodNumber>;
+        commission_rate: z.ZodNullable<z.ZodNumber>;
+        comment: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        category: string | import("../services/storage/types").CatalogEntryName | null;
+        range_min: number | null;
+        range_max: number | null;
+        commission_price: number | null;
+        commission_rate: number | null;
+        comment: string;
+        url: string | null;
+    }, {
+        id: number;
+        category: number;
+        range_min: number | null;
+        range_max: number | null;
+        commission_price: number | null;
+        commission_rate: number | null;
+        comment: string;
+        url: string | null;
+    }>, "many">;
+    partners: z.ZodArray<z.ZodObject<{
+        type: z.ZodNumber;
+        partner: z.ZodNullable<z.ZodNumber>;
+        name: z.ZodNullable<z.ZodString>;
+        reference: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string | null;
+        type: number;
+        partner: number | null;
+        reference: string;
+        amount: number;
+        currency: string;
+    }, {
+        name: string | null;
+        type: number;
+        partner: number | null;
+        reference: string;
+        amount: number;
+        currency: string;
+    }>, "many">;
+    stories: z.ZodArray<z.ZodUnknown, "many">;
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        agency: z.ZodNumber;
+        active: z.ZodBoolean;
+        created_at: z.ZodEffects<z.ZodString, Date, string>;
+        updated_at: z.ZodEffects<z.ZodString, Date, string>;
+        firstname: z.ZodString;
+        lastname: z.ZodString;
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        language: z.ZodString;
+        spoken_languages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        group: z.ZodEffects<z.ZodNumber, string | import("../services/storage/types").CatalogEntryName | null, number>;
+        email: z.ZodString;
+        phone: z.ZodNullable<z.ZodString>;
+        mobile: z.ZodString;
+        fax: z.ZodNullable<z.ZodString>;
+        city: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: number;
+            name: string;
+        }, {
+            id: number;
+            name: string;
+        }>>>;
+        birthday_at: z.ZodEffects<z.ZodString, Date, string>;
+        timezone: z.ZodNullable<z.ZodString>;
+        picture: z.ZodNullable<z.ZodString>;
+        partners: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        stories: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        rates: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        agency: number;
+        active: boolean;
+        created_at: Date;
+        updated_at: Date;
+        firstname: string;
+        lastname: string;
+        language: string;
+        group: string | import("../services/storage/types").CatalogEntryName | null;
+        email: string;
+        phone: string | null;
+        mobile: string;
+        fax: string | null;
+        birthday_at: Date;
+        timezone: string | null;
+        picture: string | null;
+        username?: string | undefined;
+        password?: string | undefined;
+        spoken_languages?: string[] | undefined;
+        city?: {
+            id: number;
+            name: string;
+        } | null | undefined;
+        partners?: unknown[] | undefined;
+        stories?: unknown[] | undefined;
+        rates?: unknown;
+    }, {
+        id: number;
+        agency: number;
+        active: boolean;
+        created_at: string;
+        updated_at: string;
+        firstname: string;
+        lastname: string;
+        language: string;
+        group: number;
+        email: string;
+        phone: string | null;
+        mobile: string;
+        fax: string | null;
+        birthday_at: string;
+        timezone: string | null;
+        picture: string | null;
+        username?: string | undefined;
+        password?: string | undefined;
+        spoken_languages?: string[] | undefined;
+        city?: {
+            id: number;
+            name: string;
+        } | null | undefined;
+        partners?: unknown[] | undefined;
+        stories?: unknown[] | undefined;
+        rates?: unknown;
+    }>, "many">;
+    sectors: z.ZodArray<z.ZodUnknown, "many">;
+    parameters: z.ZodEffects<z.ZodString, string, string>;
+    subscription: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    name: string;
+    active: boolean;
+    created_at: Date;
+    updated_at: Date;
+    email: string;
+    phone: string;
+    fax: string | null;
+    city: {
+        id: number;
+        name: string;
+        zipcode: string;
+    };
+    picture: string;
+    partners: {
+        name: string | null;
+        type: number;
+        partner: number | null;
+        reference: string;
+        amount: number;
+        currency: string;
+    }[];
+    stories: unknown[];
+    rates: {
+        id: number;
+        category: string | import("../services/storage/types").CatalogEntryName | null;
+        range_min: number | null;
+        range_max: number | null;
+        commission_price: number | null;
+        commission_rate: number | null;
+        comment: string;
+        url: string | null;
+    }[];
+    url: string;
+    reference: number;
+    currency: string;
+    company: {
+        id: number;
+        name: string;
+    };
+    networks: unknown[];
+    address: string;
+    address_more: string | null;
+    country: string;
+    region: string;
+    latitude: number;
+    longitude: number;
+    logo: string;
+    logo_svg: string | null;
+    timetable: string;
+    providers: string;
+    users: {
+        id: number;
+        agency: number;
+        active: boolean;
+        created_at: Date;
+        updated_at: Date;
+        firstname: string;
+        lastname: string;
+        language: string;
+        group: string | import("../services/storage/types").CatalogEntryName | null;
+        email: string;
+        phone: string | null;
+        mobile: string;
+        fax: string | null;
+        birthday_at: Date;
+        timezone: string | null;
+        picture: string | null;
+        username?: string | undefined;
+        password?: string | undefined;
+        spoken_languages?: string[] | undefined;
+        city?: {
+            id: number;
+            name: string;
+        } | null | undefined;
+        partners?: unknown[] | undefined;
+        stories?: unknown[] | undefined;
+        rates?: unknown;
+    }[];
+    sectors: unknown[];
+    parameters: string;
+    subscription: string;
+    brand?: unknown;
+    district?: unknown;
+}, {
+    id: number;
+    name: string;
+    active: boolean;
+    created_at: string;
+    updated_at: string;
+    email: string;
+    phone: string;
+    fax: string | null;
+    city: {
+        id: number;
+        name: string;
+        zipcode: string;
+    };
+    picture: string;
+    partners: {
+        name: string | null;
+        type: number;
+        partner: number | null;
+        reference: string;
+        amount: number;
+        currency: string;
+    }[];
+    stories: unknown[];
+    rates: {
+        id: number;
+        category: number;
+        range_min: number | null;
+        range_max: number | null;
+        commission_price: number | null;
+        commission_rate: number | null;
+        comment: string;
+        url: string | null;
+    }[];
+    url: string;
+    reference: number;
+    currency: string;
+    company: {
+        id: number;
+        name: string;
+    };
+    networks: unknown[];
+    address: string;
+    address_more: string | null;
+    country: string;
+    region: string;
+    latitude: number;
+    longitude: number;
+    logo: string;
+    logo_svg: string | null;
+    timetable: string;
+    providers: string;
+    users: {
+        id: number;
+        agency: number;
+        active: boolean;
+        created_at: string;
+        updated_at: string;
+        firstname: string;
+        lastname: string;
+        language: string;
+        group: number;
+        email: string;
+        phone: string | null;
+        mobile: string;
+        fax: string | null;
+        birthday_at: string;
+        timezone: string | null;
+        picture: string | null;
+        username?: string | undefined;
+        password?: string | undefined;
+        spoken_languages?: string[] | undefined;
+        city?: {
+            id: number;
+            name: string;
+        } | null | undefined;
+        partners?: unknown[] | undefined;
+        stories?: unknown[] | undefined;
+        rates?: unknown;
+    }[];
+    sectors: unknown[];
+    parameters: string;
+    subscription: string;
+    brand?: unknown;
+    district?: unknown;
+}>;