@vulog/aima-billing 1.1.74 → 1.1.75

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { Client } from '@vulog/aima-client';
+import { UUID } from 'crypto';
 
 type ChargeProductInfo = {
     productId: string;
@@ -14,7 +15,31 @@ type ChargeProductInfo = {
 type Invoice = {
     [key: string]: any;
 };
+type Credit = {
+    initialAmount: number;
+    validityStartDate: string;
+    validityEndDate: string;
+    notes: string;
+    discountCategory: 'CREDITS' | 'PERCENTAGE';
+    oneTimeUsage: boolean;
+    id: UUID;
+    availableAmount: number;
+    usedAmount: number;
+    originId: UUID;
+    entityId: UUID;
+    creditAlreadyUsed: boolean;
+    updateDate: string;
+    type: 'LOCAL' | 'GLOBAL' | 'PERIODIC';
+    usage: 'TRIP' | 'REGISTRATION' | 'PRODUCTS' | 'ALL';
+    [key: string]: any;
+};
 
 declare const chargeProduct: (client: Client, info: ChargeProductInfo) => Promise<Invoice>;
 
-export { type ChargeProductInfo, type Invoice, chargeProduct };
+declare const getUserCreditsByEntityId: (client: Client, id: string) => Promise<Credit>;
+
+interface Payload extends Omit<Credit, 'id' | 'availableAmount' | 'usedAmount' | 'originId' | 'creditAlreadyUsed' | 'updateDate'> {
+}
+declare const addCredits: (client: Client, payload: Payload) => Promise<Credit>;
+
+export { type ChargeProductInfo, type Credit, type Invoice, addCredits, chargeProduct, getUserCreditsByEntityId };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { Client } from '@vulog/aima-client';
+import { UUID } from 'crypto';
 
 type ChargeProductInfo = {
     productId: string;
@@ -14,7 +15,31 @@ type ChargeProductInfo = {
 type Invoice = {
     [key: string]: any;
 };
+type Credit = {
+    initialAmount: number;
+    validityStartDate: string;
+    validityEndDate: string;
+    notes: string;
+    discountCategory: 'CREDITS' | 'PERCENTAGE';
+    oneTimeUsage: boolean;
+    id: UUID;
+    availableAmount: number;
+    usedAmount: number;
+    originId: UUID;
+    entityId: UUID;
+    creditAlreadyUsed: boolean;
+    updateDate: string;
+    type: 'LOCAL' | 'GLOBAL' | 'PERIODIC';
+    usage: 'TRIP' | 'REGISTRATION' | 'PRODUCTS' | 'ALL';
+    [key: string]: any;
+};
 
 declare const chargeProduct: (client: Client, info: ChargeProductInfo) => Promise<Invoice>;
 
-export { type ChargeProductInfo, type Invoice, chargeProduct };
+declare const getUserCreditsByEntityId: (client: Client, id: string) => Promise<Credit>;
+
+interface Payload extends Omit<Credit, 'id' | 'availableAmount' | 'usedAmount' | 'originId' | 'creditAlreadyUsed' | 'updateDate'> {
+}
+declare const addCredits: (client: Client, payload: Payload) => Promise<Credit>;
+
+export { type ChargeProductInfo, type Credit, type Invoice, addCredits, chargeProduct, getUserCreditsByEntityId };

package/dist/index.js

@@ -30,7 +30,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  chargeProduct: () => chargeProduct
+  addCredits: () => addCredits,
+  chargeProduct: () => chargeProduct,
+  getUserCreditsByEntityId: () => getUserCreditsByEntityId
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -56,7 +58,47 @@ var chargeProduct = async (client, info) => {
   }
   return client.post(`/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/invoices/product`, info).then(({ data }) => data);
 };
+
+// src/getUserCreditsByEntityId.ts
+var import_zod2 = require("zod");
+var getUserCreditsByEntityId = async (client, id) => {
+  const result = import_zod2.z.string().trim().min(1).uuid().safeParse(id);
+  if (!result.success) {
+    throw new TypeError("Invalid id", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/wallet/entity/${id}`).then(({ data }) => data);
+};
+
+// src/addCredits.ts
+var import_zod3 = __toESM(require("zod"));
+var schema2 = import_zod3.default.object({
+  initialAmount: import_zod3.default.number().min(0),
+  validityStartDate: import_zod3.default.string().datetime(),
+  validityEndDate: import_zod3.default.string().datetime(),
+  notes: import_zod3.default.string().trim().nullable().optional(),
+  discountCategory: import_zod3.default.enum(["CREDITS", "PERCENTAGE"]),
+  oneTimeUsage: import_zod3.default.boolean().optional(),
+  entityId: import_zod3.default.string().trim().min(1).uuid(),
+  type: import_zod3.default.enum(["LOCAL", "GLOBAL", "PERIODIC"]),
+  usage: import_zod3.default.enum(["TRIP", "REGISTRATION", "PRODUCTS", "ALL"])
+});
+var addCredits = async (client, payload) => {
+  const result = schema2.safeParse(payload);
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/entities/${payload.entityId}/wallets`,
+    result.data
+  ).then(({ data }) => data);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  chargeProduct
+  addCredits,
+  chargeProduct,
+  getUserCreditsByEntityId
 });

package/dist/index.mjs

@@ -20,6 +20,46 @@ var chargeProduct = async (client, info) => {
   }
   return client.post(`/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/invoices/product`, info).then(({ data }) => data);
 };
+
+// src/getUserCreditsByEntityId.ts
+import { z as z2 } from "zod";
+var getUserCreditsByEntityId = async (client, id) => {
+  const result = z2.string().trim().min(1).uuid().safeParse(id);
+  if (!result.success) {
+    throw new TypeError("Invalid id", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/wallet/entity/${id}`).then(({ data }) => data);
+};
+
+// src/addCredits.ts
+import z3 from "zod";
+var schema2 = z3.object({
+  initialAmount: z3.number().min(0),
+  validityStartDate: z3.string().datetime(),
+  validityEndDate: z3.string().datetime(),
+  notes: z3.string().trim().nullable().optional(),
+  discountCategory: z3.enum(["CREDITS", "PERCENTAGE"]),
+  oneTimeUsage: z3.boolean().optional(),
+  entityId: z3.string().trim().min(1).uuid(),
+  type: z3.enum(["LOCAL", "GLOBAL", "PERIODIC"]),
+  usage: z3.enum(["TRIP", "REGISTRATION", "PRODUCTS", "ALL"])
+});
+var addCredits = async (client, payload) => {
+  const result = schema2.safeParse(payload);
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/entities/${payload.entityId}/wallets`,
+    result.data
+  ).then(({ data }) => data);
+};
 export {
-  chargeProduct
+  addCredits,
+  chargeProduct,
+  getUserCreditsByEntityId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-billing",
-    "version": "1.1.74",
+    "version": "1.1.75",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "ISC",
     "dependencies": {
-        "@vulog/aima-client": "1.1.74",
-        "@vulog/aima-core": "1.1.74"
+        "@vulog/aima-client": "1.1.75",
+        "@vulog/aima-core": "1.1.75"
     },
     "peerDependencies": {
         "zod": "^3.24.2"

package/src/addCredits.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, vi, expect } from 'vitest';
+
+import { addCredits } from './addCredits';
+import { Client } from '@vulog/aima-client';
+
+describe('addCredits', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const addCreditsSpy = vi.fn().mockImplementation(addCredits);
+
+    test('Call OK with valid payload', async () => {
+        const payload = {
+            initialAmount: 100,
+            validityStartDate: '2023-01-01T00:00:00Z',
+            validityEndDate: '2024-01-01T00:00:00Z',
+            notes: 'Test credit',
+            discountCategory: 'CREDITS',
+            oneTimeUsage: true,
+            entityId: 'de66ea16-e942-4eaa-9f86-491e62bf59a2',
+            type: 'LOCAL',
+            usage: 'TRIP',
+        };
+
+        const creditResponse = {
+            id: 'credit1',
+            availableAmount: 100,
+            usedAmount: 0,
+            originId: null,
+            creditAlreadyUsed: false,
+            updateDate: new Date().toISOString(),
+            ...payload,
+        };
+
+        postMock.mockResolvedValue({ data: creditResponse });
+
+        await addCreditsSpy(client, payload);
+        expect(addCreditsSpy).toHaveBeenCalledWith(client, payload);
+        expect(addCreditsSpy).toHaveBeenCalledTimes(1);
+        expect(postMock).toHaveBeenCalledTimes(1);
+    });
+
+    test('Should throw TypeError when entityId is not a valid UUID', async () => {
+        const invalidPayload = {
+            initialAmount: 100,
+            validityStartDate: '2023-01-01T00:00:00Z',
+            validityEndDate: '2024-01-01T00:00:00Z',
+            notes: 'Test credit',
+            discountCategory: 'CREDITS',
+            oneTimeUsage: true,
+            entityId: 'invalid-uuid',
+            type: 'LOCAL',
+            usage: 'TRIP',
+        };
+
+        await expect(addCreditsSpy(client, invalidPayload)).rejects.toThrow(TypeError);
+        await expect(addCreditsSpy(client, invalidPayload)).rejects.toThrow('Invalid args');
+    });
+
+    test('Should throw TypeError when initialAmount is negative', async () => {
+        const invalidPayload = {
+            initialAmount: -10,
+            validityStartDate: '2023-01-01T00:00:00Z',
+            validityEndDate: '2024-01-01T00:00:00Z',
+            notes: 'Test credit',
+            discountCategory: 'CREDITS',
+            oneTimeUsage: true,
+            entityId: 'de66ea16-e942-4eaa-9f86-491e62bf59a2',
+            type: 'LOCAL',
+            usage: 'TRIP',
+        };
+
+        await expect(addCreditsSpy(client, invalidPayload)).rejects.toThrow(TypeError);
+    });
+
+    test('Should throw TypeError when dates are invalid', async () => {
+        const invalidPayload = {
+            initialAmount: 100,
+            validityStartDate: 'not-a-date',
+            validityEndDate: '2024-01-01T00:00:00Z',
+            notes: 'Test credit',
+            discountCategory: 'CREDITS',
+            oneTimeUsage: true,
+            entityId: 'de66ea16-e942-4eaa-9f86-491e62bf59a2',
+            type: 'LOCAL',
+            usage: 'TRIP',
+        };
+
+        await expect(addCreditsSpy(client, invalidPayload)).rejects.toThrow(TypeError);
+    });
+
+    test('Should throw TypeError when enum value is invalid', async () => {
+        const invalidPayload = {
+            initialAmount: 100,
+            validityStartDate: '2023-01-01T00:00:00Z',
+            validityEndDate: '2024-01-01T00:00:00Z',
+            notes: 'Test credit',
+            discountCategory: 'INVALID_CATEGORY',
+            oneTimeUsage: true,
+            entityId: 'de66ea16-e942-4eaa-9f86-491e62bf59a2',
+            type: 'LOCAL',
+            usage: 'TRIP',
+        };
+
+        await expect(addCreditsSpy(client, invalidPayload as any)).rejects.toThrow(TypeError);
+    });
+});

package/src/addCredits.ts

@@ -0,0 +1,36 @@
+import { Client } from '@vulog/aima-client';
+
+import z from 'zod';
+
+import type { Credit } from './types';
+
+interface Payload
+    extends Omit<Credit, 'id' | 'availableAmount' | 'usedAmount' | 'originId' | 'creditAlreadyUsed' | 'updateDate'> {}
+
+const schema = z.object({
+    initialAmount: z.number().min(0),
+    validityStartDate: z.string().datetime(),
+    validityEndDate: z.string().datetime(),
+    notes: z.string().trim().nullable().optional(),
+    discountCategory: z.enum(['CREDITS', 'PERCENTAGE']),
+    oneTimeUsage: z.boolean().optional(),
+    entityId: z.string().trim().min(1).uuid(),
+    type: z.enum(['LOCAL', 'GLOBAL', 'PERIODIC']),
+    usage: z.enum(['TRIP', 'REGISTRATION', 'PRODUCTS', 'ALL']),
+});
+
+export const addCredits = async (client: Client, payload: Payload): Promise<Credit> => {
+    const result = schema.safeParse(payload);
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+
+    return client
+        .post<Credit>(
+            `/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/entities/${payload.entityId}/wallets`,
+            result.data
+        )
+        .then(({ data }) => data);
+};

package/src/getUserCreditsByEntityId.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getUserCreditsByEntityId } from './getUserCreditsByEntityId';
+
+describe('getUserCreditsByEntityId', () => {
+    const FLEET_ID = 'FLEET_ID';
+    const ENTITY_ID = 'de66ea16-e942-4eaa-9f86-491e62bf59a2';
+    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(() => {
+        vi.useRealTimers();
+    });
+
+    test('call OK', async () => {
+        const data = {
+            id: ENTITY_ID,
+            credits: [
+                {
+                    id: 'credit-id',
+                    name: 'Test Credit',
+                    description: 'Test Description',
+                    availableAmount: 100,
+                    usedAmount: 50,
+                    originId: 'origin-id',
+                    entityId: ENTITY_ID,
+                    creditAlreadyUsed: false,
+                    updateDate: '2025-01-12T13:35:50.123Z',
+                    type: 'LOCAL',
+                },
+            ],
+        };
+
+        getMock.mockResolvedValueOnce({ data });
+
+        const result = await getUserCreditsByEntityId(client, ENTITY_ID);
+        expect(result).toEqual(data);
+        expect(getMock).toHaveBeenCalledWith(`/boapi/proxy/billing/fleets/${FLEET_ID}/wallet/entity/${ENTITY_ID}`);
+    });
+
+    test('invalid id', async () => {
+        const rejects = expect(() => getUserCreditsByEntityId(client, 'invalid-id')).rejects;
+        await rejects.toThrowError('Invalid id');
+        await rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].code).toBe('invalid_string');
+            expect(error.cause[0]).toHaveProperty('message');
+            expect(error.cause[0].message).toBe('Invalid uuid');
+            return true;
+        });
+    });
+});

package/src/getUserCreditsByEntityId.ts

@@ -0,0 +1,16 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Credit } from './types';
+
+export const getUserCreditsByEntityId = async (client: Client, id: string): Promise<Credit> => {
+    const result = z.string().trim().min(1).uuid().safeParse(id);
+    if (!result.success) {
+        throw new TypeError('Invalid id', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<Credit>(`/boapi/proxy/billing/fleets/${client.clientOptions.fleetId}/wallet/entity/${id}`)
+        .then(({ data }) => data);
+};

package/src/index.ts

@@ -1,2 +1,4 @@
 export * from './chargeProduct';
 export * from './types';
+export * from './getUserCreditsByEntityId';
+export * from './addCredits';

package/src/types.ts

@@ -1,3 +1,5 @@
+import { UUID } from 'crypto';
+
 export type ChargeProductInfo = {
     productId: string;
     serviceId?: string;
@@ -13,3 +15,22 @@ export type ChargeProductInfo = {
 export type Invoice = {
     [key: string]: any;
 };
+
+export type Credit = {
+    initialAmount: number;
+    validityStartDate: string;
+    validityEndDate: string;
+    notes: string;
+    discountCategory: 'CREDITS' | 'PERCENTAGE';
+    oneTimeUsage: boolean;
+    id: UUID;
+    availableAmount: number;
+    usedAmount: number;
+    originId: UUID;
+    entityId: UUID;
+    creditAlreadyUsed: boolean;
+    updateDate: string;
+    type: 'LOCAL' | 'GLOBAL' | 'PERIODIC';
+    usage: 'TRIP' | 'REGISTRATION' | 'PRODUCTS' | 'ALL';
+    [key: string]: any;
+};