@vulog/aima-booking 1.0.0

package/.eslintrc.js

@@ -0,0 +1,112 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        // Indicates the location of the TypeScript configuration file
+        project: 'tsconfig.json',
+        // Sets the root directory for the TypeScript configuration
+        tsconfigRootDir: __dirname,
+        // Specifies the version of ECMAScript syntax to be used
+        ecmaVersion: 'latest',
+        // Indicates the type of source code (script or module)
+        sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint', 'prettier', 'import'],
+    extends: [
+        'airbnb-base',
+        'airbnb-typescript/base',
+        'plugin:@typescript-eslint/recommended',
+        'prettier',
+        'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+        es6: true,
+        node: true,
+    },
+    ignorePatterns: [
+        '/dist/**/*', // Ignore built files.
+        '.eslintrc.js',
+        '**/*.test.ts',
+    ],
+    rules: {
+        // Configures the Prettier integration with ESLint
+        'prettier/prettier': ['error', { endOfLine: 'auto' }],
+        // Disables the rule requiring an 'I' prefix for interfaces
+        '@typescript-eslint/interface-name-prefix': 'off',
+        // Configures the naming conventions for various code constructs
+        '@typescript-eslint/naming-convention': [
+            // ... various naming convention configurations ...
+            'error',
+            // Allows any naming format for destructured variables
+            {
+                selector: 'variable',
+                modifiers: ['destructured'],
+                format: null,
+            },
+            // Requires strict camelCase for function names
+            {
+                selector: 'function',
+                format: ['strictCamelCase'],
+            },
+            // Requires boolean variables to have one of the specified prefixes
+            {
+                selector: 'variable',
+                format: null,
+                types: ['boolean'],
+                prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+            },
+            // Requires enum names to have a strict PascalCase format
+            {
+                selector: 'enum',
+                format: ['StrictPascalCase'],
+            },
+        ],
+        'import/extensions': 'off',
+        // Disables the rule requiring explicit return types for functions
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        // Disables the rule requiring explicit boundary types for modules
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        // Disables the rule prohibiting the use of 'any' type
+        '@typescript-eslint/no-explicit-any': 'off',
+        // Disables the rule detecting unused variables
+        'no-unused-vars': 0,
+        // Disables the rule disallowing named exports used as a default export
+        'import/no-named-as-default': 0,
+        // Configures the order and formatting of import statements
+        'import/order': [
+            // ... import order configuration ...
+            'error',
+            {
+                // Configure the alphabetization settings
+                alphabetize: {
+                    // Enforce ascending alphabetical order
+                    order: 'asc',
+                    // Do not ignore the case while sorting
+                    caseInsensitive: false,
+                },
+                // Enforce newlines between different groups and inside groups of imports
+                'newlines-between': 'always-and-inside-groups',
+                // Warn when there is an import statement that is not part of any group
+                warnOnUnassignedImports: true,
+            },
+        ],
+        // Configures the rule detecting extraneous dependencies
+        'import/no-extraneous-dependencies': [
+            // ... extraneous dependencies configuration ...
+            'error',
+            {
+                // Specify the file patterns where devDependencies imports are allowed
+                devDependencies: [
+                    // Allow devDependencies imports in test and spec files
+                    '**/*.test.{ts,js}',
+                    '**/*.spec.{ts,js}',
+                    // Allow devDependencies imports in the 'test' folder
+                    './test/**.{ts,js}',
+                    // Allow devDependencies imports in the 'scripts' folder
+                    './scripts/**/*.{ts,js}',
+                ],
+            },
+        ],
+        'import/prefer-default-export': 'off',
+    },
+};

package/dist/index.d.mts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@vulog/aima-booking",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "keywords": [
+        "AIMA",
+        "VULOG",
+        "BOOKING"
+    ],
+    "author": "Vulog",
+    "license": "ISC",
+    "devDependencies": {
+        "@types/lodash": "^4.17.12",
+        "@types/node": "^22.7.9",
+        "eslint-config-airbnb-base": "^15.0.0",
+        "eslint-config-airbnb-typescript": "^18.0.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-import": "^2.31.0",
+        "eslint-plugin-prettier": "^5.2.1",
+        "eslint-plugin-unused-imports": "^4.1.4",
+        "prettier": "^3.3.3",
+        "tsup": "^8.3.0",
+        "typescript": "^5.6.3",
+        "vitest": "^2.1.3"
+    },
+    "peerDependencies": {
+        "@vulog/aima-client": "^1.0.0",
+        "@vulog/aima-core": "^1.0.0",
+        "lodash": "^4.17.21",
+        "zod": "^3.23.8"
+    },
+    "description": ""
+}

package/src/getBookingRequests.test.ts

@@ -0,0 +1,146 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getBookingRequests } from './getBookingRequests';
+import { Client } from '@vulog/aima-client';
+
+describe('getBookingRequests', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+    });
+
+    afterEach(() => {
+        // restoring date after each test run
+        vi.useRealTimers();
+    });
+
+    test('Fake status', async () => {
+        const rejects = await expect(() => getBookingRequests({} as Client, 'FAKE' as any)).rejects;
+        rejects.toThrowError('Invalid status');
+        rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('received');
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].received).toBe('FAKE');
+            expect(error.cause[0].code).toBe('invalid_enum_value');
+            return true;
+        });
+    });
+
+    test('negative page', async () => {
+        const rejects = await expect(() =>
+            getBookingRequests({} as Client, 'UPCOMING', {
+                page: -1,
+            })
+        ).rejects;
+        rejects.toThrowError('Invalid options');
+        rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('path');
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].path[0]).toBe('page');
+            expect(error.cause[0].code).toBe('too_small');
+            return true;
+        });
+    });
+
+    test('negative pageSize', async () => {
+        const rejects = await expect(() =>
+            getBookingRequests({} as Client, 'UPCOMING', {
+                page: 0,
+                pageSize: -1,
+            })
+        ).rejects;
+        rejects.toThrowError('Invalid options');
+        rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('path');
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].path[0]).toBe('pageSize');
+            expect(error.cause[0].code).toBe('too_small');
+            return true;
+        });
+    });
+
+    test('too big pageSize', async () => {
+        const rejects = await expect(() =>
+            getBookingRequests({} as Client, 'UPCOMING', {
+                pageSize: 1001,
+            })
+        ).rejects;
+        rejects.toThrowError('Invalid options');
+        rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('path');
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].path[0]).toBe('pageSize');
+            expect(error.cause[0].code).toBe('too_big');
+            return true;
+        });
+    });
+
+    test('call Base', async () => {
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: {
+                number: 0,
+                size: 100,
+                totalelements: 0,
+                totalpages: 0,
+            },
+        });
+
+        const result = await getBookingRequests(client, 'UPCOMING');
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(
+            '/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/status/UPCOMING/filters?page=0&pageSize=100&startDate=2025-01-12T13%3A35%3A50Z&endDate=2025-03-12T13%3A35%3A50Z'
+        );
+        expect(result).toEqual({
+            data: [],
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+    });
+
+    test('call serviceTypes', async () => {
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: {
+                number: 0,
+                size: 100,
+                totalelements: 0,
+                totalpages: 0,
+            },
+        });
+
+        const result = await getBookingRequests(client, 'UPCOMING', {
+            filters: {
+                serviceTypes: ['ROUND_TRIP_BOOKING', 'SCHEDULED_BOOKING_STATION'],
+            },
+        });
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(
+            '/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/status/UPCOMING/filters?page=0&pageSize=100&serviceTypes=ROUND_TRIP_BOOKING%2CSCHEDULED_BOOKING_STATION&startDate=2025-01-12T13%3A35%3A50Z&endDate=2025-03-12T13%3A35%3A50Z'
+        );
+        expect(result).toEqual({
+            data: [],
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+    });
+});

package/src/getBookingRequests.ts

@@ -0,0 +1,148 @@
+import { Client } from '@vulog/aima-client';
+import { createPaginableOptionsSchema, PaginableOptions, PaginableResponse } from '@vulog/aima-core';
+import { isNumber } from 'lodash';
+import { z } from 'zod';
+
+const BookingRequestStatusSchema = z.enum([
+    'ALERT',
+    'UPCOMING',
+    'ONGOING',
+    'COMPLETED',
+    'CANCELLED',
+    'PENDING_APPROVAL',
+]);
+export type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
+
+const ServiceTypeSchema = z.enum(['SUBSCRIPTION', 'ROUND_TRIP_BOOKING', 'SCHEDULED_BOOKING_STATION']);
+export type ServiceType = z.infer<typeof ServiceTypeSchema>;
+
+export type SpecificBookingRequestFilters = {
+    serviceIds?: string[];
+    userId?: string;
+    modelId?: number;
+    vehicleId?: string;
+    stationId?: string;
+    /**
+     * Format: yyyy-MM-dd
+     */
+    creationDate?: string;
+    /**
+     * Format: yyyy-MM-dd'T'HH:mm:ssZ
+     * default now plus 2 months
+     */
+    startDate?: string;
+    /**
+     * Format: yyyy-MM-dd'T'HH:mm:ssZ
+     * default now plus 2 months
+     */
+    endDate?: string;
+};
+export type BookingRequestFilters = SpecificBookingRequestFilters & {
+    serviceTypes?: ServiceType[];
+};
+
+export type BookingRequest = {
+    [key: string]: any;
+};
+
+export const getBookingRequests = async (
+    client: Client,
+    status: BookingRequestStatus,
+    options?: PaginableOptions<BookingRequestFilters>
+): Promise<PaginableResponse<BookingRequest>> => {
+    const resultStatus = BookingRequestStatusSchema.safeParse(status);
+    if (!resultStatus.success) {
+        throw new TypeError('Invalid status', {
+            cause: resultStatus.error.issues,
+        });
+    }
+
+    const date = new Date();
+    date.setMilliseconds(0);
+    const startDate = date.toISOString().replace('.000Z', 'Z');
+    date.setMonth(date.getMonth() + 2);
+    const endDate = date.toISOString().replace('.000Z', 'Z');
+    const BookingRequestFiltersSchema = z.object({
+        serviceTypes: z.array(ServiceTypeSchema).optional(),
+        serviceIds: z.array(z.string().uuid()).optional(),
+        userId: z.string().uuid().optional(),
+        modelId: z.number().positive().optional(),
+        vehicleId: z.string().uuid().optional(),
+        stationId: z.string().uuid().optional(),
+        creationDate: z.string().date().optional(),
+        startDate: z.string().datetime({ offset: false, precision: 0 }).default(startDate),
+        endDate: z.string().datetime({ offset: false, precision: 0 }).default(endDate),
+    });
+
+    const PaginableOptionsSchema = createPaginableOptionsSchema(BookingRequestFiltersSchema).default({});
+
+    const resultOptions = PaginableOptionsSchema.safeParse(options);
+    if (!resultOptions.success) {
+        throw new TypeError('Invalid options', {
+            cause: resultOptions.error.issues,
+        });
+    }
+
+    const finalOptions = resultOptions.data;
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('page', finalOptions.page!.toString());
+    searchParams.append('pageSize', finalOptions.pageSize!.toString());
+
+    Object.entries(finalOptions.filters!).forEach(([key, value]) => {
+        if (value === undefined) {
+            return;
+        }
+        if (Array.isArray(value) && value.length > 0) {
+            searchParams.append(key, value.join(','));
+            return;
+        }
+        if (isNumber(value)) {
+            searchParams.append(key, value.toString());
+            return;
+        }
+        searchParams.append(key, value as string);
+    });
+
+    return client
+        .get<
+            BookingRequest[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/status/${status}/filters?${searchParams.toString()}`)
+        .then(({ data, headers }) => {
+            return {
+                data,
+                page: headers.number,
+                pageSize: headers.size,
+                total: headers.totalelements,
+                totalPages: headers.totalpages,
+            };
+        });
+};
+
+export const getScheduleBookingRequests = async (
+    client: Client,
+    status: BookingRequestStatus,
+    options?: PaginableOptions<SpecificBookingRequestFilters>
+): Promise<PaginableResponse<BookingRequest>> => {
+    return getBookingRequests(client, status, {
+        ...options,
+        filters: {
+            ...options?.filters,
+            serviceTypes: ['ROUND_TRIP_BOOKING', 'SCHEDULED_BOOKING_STATION'],
+        },
+    });
+};
+
+export const getSubscriptionBookingRequests = async (
+    client: Client,
+    status: BookingRequestStatus,
+    options?: PaginableOptions<SpecificBookingRequestFilters>
+): Promise<PaginableResponse<BookingRequest>> => {
+    return getBookingRequests(client, status, {
+        ...options,
+        filters: {
+            ...options?.filters,
+            serviceTypes: ['SUBSCRIPTION'],
+        },
+    });
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "include": ["src"],
+    "exclude": ["**/*.test.ts"],
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "lib": ["esnext"],
+        "declaration": true,
+        "strict": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "rootDir": "src"
+    }
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    clean: true,
+    format: ['cjs', 'esm'],
+    dts: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+});