@vulog/aima-business 1.2.39

package/src/types.ts

@@ -0,0 +1,163 @@
+/** Represents a business entity */
+export type Business = {
+    /** Unique identifier */
+    id: string;
+    /** Business name */
+    name: string;
+    /** Business status */
+    status: string;
+    [key: string]: any;
+};
+
+/** Represents a contact within a business */
+export type BusinessContact = {
+    /** Contact identifier */
+    id: string;
+    /** Contact name */
+    name: string;
+    /** Contact email */
+    email: string;
+    [key: string]: any;
+};
+
+/** Represents a cost center within a business */
+export type CostCenter = {
+    /** Unique identifier */
+    id: string;
+    /** Cost center name */
+    name: string;
+    /** Parent business identifier */
+    businessId: string;
+    [key: string]: any;
+};
+
+/** Represents payment details for a business */
+export type BusinessPaymentDetails = {
+    /** Payment method type */
+    paymentMethod: string;
+    [key: string]: any;
+};
+
+/** Represents a user linked to a business */
+export type BusinessUser = {
+    /** User identifier */
+    userId: string;
+    /** Business identifier */
+    businessId: string;
+    /** User role within the business */
+    role: string;
+    [key: string]: any;
+};
+
+/** Represents an invitation link for a business */
+export type BusinessInviteLink = {
+    /** Invitation URL */
+    url: string;
+    [key: string]: any;
+};
+
+/** Represents entity balance information */
+export type EntityBalance = {
+    /** Entity identifier */
+    entityId: string;
+    /** Current balance */
+    balance: number;
+    [key: string]: any;
+};
+
+/** Represents the total cost of trips for an entity */
+export type EntityTripsCost = {
+    /** Total cost */
+    totalCost: number;
+    [key: string]: any;
+};
+
+/** Represents a billing group in the business context */
+export type BusinessBillingGroup = {
+    /** Group identifier */
+    id: string;
+    /** Group name */
+    name: string;
+    [key: string]: any;
+};
+
+/** Represents a Stripe setup response */
+export type StripeSetup = {
+    /** Client secret for Stripe */
+    clientSecret: string;
+    [key: string]: any;
+};
+
+/** Represents Stripe configuration */
+export type StripeConfig = {
+    /** Stripe publishable key */
+    publishableKey: string;
+    [key: string]: any;
+};
+
+/** Represents a business invoice */
+export type BusinessInvoice = {
+    /** Invoice identifier */
+    id: string;
+    /** Invoice amount */
+    amount: number;
+    /** Invoice status */
+    status: string;
+    [key: string]: any;
+};
+
+/** Represents the refund note for an invoice */
+export type InvoiceRefundNote = {
+    [key: string]: any;
+};
+
+/** Represents the refundable amount for an invoice */
+export type InvoiceRefundableAmount = {
+    /** Invoice identifier */
+    invoiceId: string;
+    /** Refundable amount */
+    refundableAmount: number;
+    [key: string]: any;
+};
+
+/** Represents a business trip */
+export type BusinessTrip = {
+    /** Trip identifier */
+    tripId: string;
+    [key: string]: any;
+};
+
+/** Represents a note on a trip */
+export type TripNote = {
+    /** Note identifier */
+    id: string;
+    /** Note content */
+    content: string;
+    [key: string]: any;
+};
+
+/** Represents a product in the business context */
+export type BusinessProduct = {
+    /** Product identifier */
+    id: string;
+    /** Product name */
+    name: string;
+    [key: string]: any;
+};
+
+/** Represents an invitation request */
+export type InvitationRequest = {
+    /** Invitation request identifier */
+    id: string;
+    [key: string]: any;
+};
+
+/** Represents a business wallet */
+export type BusinessWallet = {
+    [key: string]: any;
+};
+
+/** Represents a business user profile */
+export type BusinessUserProfile = {
+    [key: string]: any;
+};

package/src/updateBusiness.test.ts

@@ -0,0 +1,65 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { updateBusiness, UpdateBusinessBody } from './updateBusiness';
+
+describe('updateBusiness', () => {
+    const putMock = vi.fn();
+    const client = {
+        put: putMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const BUSINESS_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    test('should update a business with valid body', async () => {
+        const body: UpdateBusinessBody = { name: 'Updated Corp' };
+        const mockResponse = { id: BUSINESS_ID, name: 'Updated Corp', status: 'ACTIVE' };
+        putMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await updateBusiness(client, BUSINESS_ID, body);
+
+        expect(result).toEqual(mockResponse);
+        expect(putMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${BUSINESS_ID}`,
+            body
+        );
+    });
+
+    test('should update a business with empty body (no fields)', async () => {
+        const body: UpdateBusinessBody = {};
+        const mockResponse = { id: BUSINESS_ID, name: 'Existing Corp', status: 'ACTIVE' };
+        putMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await updateBusiness(client, BUSINESS_ID, body);
+
+        expect(result).toEqual(mockResponse);
+        expect(putMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${BUSINESS_ID}`,
+            body
+        );
+    });
+
+    test('should throw for empty businessId', async () => {
+        await expect(updateBusiness(client, '', { name: 'Test' })).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for non-uuid businessId', async () => {
+        await expect(updateBusiness(client, 'not-a-uuid', { name: 'Test' })).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for empty name string', async () => {
+        const body: UpdateBusinessBody = { name: '' };
+        await expect(updateBusiness(client, BUSINESS_ID, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for name exceeding 255 characters', async () => {
+        const body: UpdateBusinessBody = { name: 'a'.repeat(256) };
+        await expect(updateBusiness(client, BUSINESS_ID, body)).rejects.toThrow(TypeError);
+    });
+});

package/src/updateBusiness.ts

@@ -0,0 +1,35 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Business } from './types';
+
+export type UpdateBusinessBody = {
+    name?: string;
+};
+
+const updateBusinessBodySchema = z.object({
+    name: z.string().trim().min(1).max(255).optional(),
+});
+
+export const updateBusiness = async (
+    client: Client,
+    businessId: string,
+    body: UpdateBusinessBody
+): Promise<Business> => {
+    const parsedId = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!parsedId.success) {
+        throw new TypeError('Invalid args', { cause: parsedId.error.issues });
+    }
+
+    const result = updateBusinessBodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .put<Business>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedId.data}`,
+            result.data
+        )
+        .then(({ data }) => data);
+};

package/src/updateBusinessCostCenter.ts

@@ -0,0 +1,41 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { CostCenter } from './types';
+
+export type UpdateCostCenterBody = {
+    name?: string;
+};
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+const bodySchema = z.object({
+    name: z.string().trim().min(1).max(255).optional(),
+});
+
+export const updateBusinessCostCenter = async (
+    client: Client,
+    businessId: string,
+    costCenterId: string,
+    body: UpdateCostCenterBody
+): Promise<CostCenter> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedCostCenterId = uuidSchema.safeParse(costCenterId);
+    if (!parsedBusinessId.success || !parsedCostCenterId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedCostCenterId.error?.issues ?? [])],
+        });
+    }
+
+    const result = bodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .put<CostCenter>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/costcenter/${parsedCostCenterId.data}`,
+            result.data
+        )
+        .then(({ data }) => data);
+};

package/src/updateBusinessProfileStatus.ts

@@ -0,0 +1,22 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    status: z.string().trim().min(1),
+});
+
+export const updateBusinessProfileStatus = async (
+    client: Client,
+    businessId: string,
+    status: string
+): Promise<void> => {
+    const result = schema.safeParse({ businessId, status });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.put<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/profile/user/profile/status/${result.data.status}`
+    );
+};

package/src/updateBusinessUserProfile.ts

@@ -0,0 +1,51 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUserProfile } from './types';
+
+export type UpdateBusinessUserProfileBody = {
+    email?: string;
+    emailConsent?: boolean;
+    costCenterId?: string;
+};
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+const bodySchema = z.object({
+    email: z.string().trim().email().optional(),
+    emailConsent: z.boolean().optional(),
+    costCenterId: z.string().trim().min(1).uuid().optional(),
+});
+
+export const updateBusinessUserProfile = async (
+    client: Client,
+    businessId: string,
+    userId: string,
+    profileId: string,
+    body: UpdateBusinessUserProfileBody
+): Promise<BusinessUserProfile> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    const parsedProfileId = uuidSchema.safeParse(profileId);
+    if (!parsedBusinessId.success || !parsedUserId.success || !parsedProfileId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [
+                ...(parsedBusinessId.error?.issues ?? []),
+                ...(parsedUserId.error?.issues ?? []),
+                ...(parsedProfileId.error?.issues ?? []),
+            ],
+        });
+    }
+
+    const result = bodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .put<BusinessUserProfile>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/profile/${parsedProfileId.data}`,
+            result.data
+        )
+        .then(({ data }) => data);
+};

package/src/updateInvoiceStatus.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { updateInvoiceStatus } from './updateInvoiceStatus';
+
+describe('updateInvoiceStatus', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const INVOICE_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should update invoice status successfully', async () => {
+        postMock.mockResolvedValueOnce({ data: undefined });
+
+        const result = await updateInvoiceStatus(client, INVOICE_ID, 'PAID');
+
+        expect(result).toBeUndefined();
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invoices/${INVOICE_ID}/status/PAID`,
+            {}
+        );
+    });
+
+    test('should throw for empty invoiceId', async () => {
+        await expect(updateInvoiceStatus(client, '', 'PAID')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for non-uuid invoiceId', async () => {
+        await expect(updateInvoiceStatus(client, 'not-a-uuid', 'PAID')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for empty status', async () => {
+        await expect(updateInvoiceStatus(client, INVOICE_ID, '')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for whitespace-only status', async () => {
+        await expect(updateInvoiceStatus(client, INVOICE_ID, '   ')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for whitespace-only invoiceId', async () => {
+        await expect(updateInvoiceStatus(client, '   ', 'PAID')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+});

package/src/updateInvoiceStatus.ts

@@ -0,0 +1,19 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    invoiceId: z.string().trim().min(1).uuid(),
+    status: z.string().trim().min(1),
+});
+
+export const updateInvoiceStatus = async (client: Client, invoiceId: string, status: string): Promise<void> => {
+    const result = schema.safeParse({ invoiceId, status });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${result.data.invoiceId}/status/${result.data.status}`,
+        {}
+    );
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "include": ["src"],
+    "exclude": ["**/*.test.ts"],
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src"
+    }
+}

package/tsdown.config.ts

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

package/vitest.config.ts

@@ -0,0 +1 @@
+export { default } from '../../vitest.config.base.ts';