@budgetbuddyde/api 0.1.0

package/lib/services/budget.service.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetService = void 0;
+const error_1 = require("../error");
+const budget_schema_1 = require("../types/schemas/budget.schema");
+const entity_service_1 = require("./entity.service");
+class BudgetService extends entity_service_1.EntityService {
+    constructor(host, entityPath = "/api/budget") {
+        super(host, entityPath, {
+            getAll: budget_schema_1.GetAllBudgetsResponse,
+            get: budget_schema_1.GetBudgetResponse,
+            create: budget_schema_1.CreateBudgetResponse,
+            update: budget_schema_1.UpdateBudgetResponse,
+            delete: budget_schema_1.DeleteBudgetResponse,
+        });
+    }
+    async getEstimatedBudget(requestConfig) {
+        var _a;
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/estimated`, this.mergeRequestConfig({
+                method: "GET",
+                credentials: "include",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = budget_schema_1.EstimatedBudgetResponse.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [(_a = parsingResult.data.data) !== null && _a !== void 0 ? _a : [], null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+exports.BudgetService = BudgetService;

package/lib/services/category.service.d.ts

@@ -0,0 +1,24 @@
+import type { TCategory, TCategoryStats, TCategoryVH, TCreateOrUpdateCategoryPayload } from "../types/category.type";
+import type { TResult } from "../types/common";
+import { CreateCategoryResponse, DeleteCategoryResponse, GetAllCategoriesResponse, GetCategoryResponse, UpdateCategoryResponse } from "../types/schemas/category.schema";
+import { EntityService } from "./entity.service";
+export declare class CategoryService extends EntityService<TCreateOrUpdateCategoryPayload, Partial<TCreateOrUpdateCategoryPayload>, typeof GetAllCategoriesResponse, typeof GetCategoryResponse, typeof CreateCategoryResponse, typeof UpdateCategoryResponse, typeof DeleteCategoryResponse> {
+    constructor(host: string, entityPath?: string);
+    getValueHelp(requestConfig?: RequestInit): Promise<TResult<TCategoryVH[]>>;
+    /**
+     * Retrieves the statistics for categories within a specific date range.
+     * @param param0 - The start and end dates for the statistics.
+     * @returns A promise that resolves to an array of expanded category statistics.
+     */
+    getCategoryStats({ from, to, }: {
+        from: Date;
+        to: Date;
+    }, requestConfig?: RequestInit): Promise<TResult<TCategoryStats>>;
+    merge({ source, target, }: {
+        source: TCategory["id"][];
+        target: TCategory["id"];
+    }, requestConfig?: RequestInit): Promise<TResult<{
+        source: Set<TCategory["id"]>;
+        target: TCategory["id"];
+    }>>;
+}

package/lib/services/category.service.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryService = void 0;
+const zod_1 = __importDefault(require("zod"));
+const error_1 = require("../error");
+const category_schema_1 = require("../types/schemas/category.schema");
+const entity_service_1 = require("./entity.service");
+class CategoryService extends entity_service_1.EntityService {
+    constructor(host, entityPath = "/api/category") {
+        super(host, entityPath, {
+            getAll: category_schema_1.GetAllCategoriesResponse,
+            get: category_schema_1.GetCategoryResponse,
+            create: category_schema_1.CreateCategoryResponse,
+            update: category_schema_1.UpdateCategoryResponse,
+            delete: category_schema_1.DeleteCategoryResponse,
+        });
+    }
+    async getValueHelp(requestConfig) {
+        var _a;
+        const [categories, error] = await this.getAll(undefined, requestConfig);
+        if (error) {
+            this.handleError(error);
+        }
+        const valueHelpValues = zod_1.default
+            .array(category_schema_1.CategoryVH)
+            .safeParse((_a = categories === null || categories === void 0 ? void 0 : categories.data) !== null && _a !== void 0 ? _a : []);
+        if (!valueHelpValues.success) {
+            return this.handleZodError(valueHelpValues.error);
+        }
+        return [valueHelpValues.data, null];
+    }
+    /**
+     * Retrieves the statistics for categories within a specific date range.
+     * @param param0 - The start and end dates for the statistics.
+     * @returns A promise that resolves to an array of expanded category statistics.
+     */
+    async getCategoryStats({ from, to, }, requestConfig) {
+        var _a;
+        try {
+            const query = new URLSearchParams();
+            // en-CA format yields YYYY-MM-DD which is ISO 8601 compliant
+            query.append("from", from.toLocaleDateString("en-CA"));
+            query.append("to", to.toLocaleDateString("en-CA"));
+            const response = await fetch(`${this.getBaseRequestPath()}/stats?${query.toString()}`, this.mergeRequestConfig({
+                method: "GET",
+                credentials: "include",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = category_schema_1.CategoryStatsResponse.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [(_a = parsingResult.data.data) !== null && _a !== void 0 ? _a : [], null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async merge({ source, target, }, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/merge`, this.mergeRequestConfig({
+                method: "POST",
+                credentials: "include",
+                headers: new Headers({
+                    "Content-Type": "application/json",
+                    ...((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                }),
+                body: JSON.stringify({ source, target }),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = category_schema_1.MergeCategoriesResponse.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+exports.CategoryService = CategoryService;

package/lib/services/entity.service.d.ts

@@ -0,0 +1,31 @@
+import type { ZodType, z } from "zod";
+import type { TResult } from "../types/common";
+import type { IBaseGetAllQuery } from "../types/interfaces/query.interface";
+type TEntitySchemas<GetAll extends z.ZodType, Get extends z.ZodType, Create extends z.ZodType, Update extends z.ZodType, Delete extends z.ZodType> = {
+    getAll: GetAll;
+    get: Get;
+    create: Create;
+    update: Update;
+    delete: Delete;
+};
+export declare class EntityService<CreatePayload, UpdatePayload, GetAllResult extends ZodType, GetResult extends ZodType, CreateResult extends ZodType, UpdateResult extends ZodType, DeleteResult extends ZodType> {
+    protected host: string;
+    protected basePath: string;
+    protected schemas: TEntitySchemas<GetAllResult, GetResult, CreateResult, UpdateResult, DeleteResult>;
+    constructor(host: string, basePath: string, schemas: TEntitySchemas<GetAllResult, GetResult, CreateResult, UpdateResult, DeleteResult>);
+    protected getBaseRequestPath(): string;
+    protected handleError<T>(e: unknown): TResult<T>;
+    protected handleZodError<T, S>(errors: z.ZodError<S>[] | z.ZodError<S>): TResult<T>;
+    protected mergeRequestConfig(config1: RequestInit, config2?: RequestInit): RequestInit;
+    getAll<Q extends IBaseGetAllQuery>(query?: Q, requestConfig?: RequestInit): Promise<TResult<z.output<GetAllResult>>>;
+    getById(entityId: string, requestConfig?: RequestInit): Promise<TResult<z.output<GetResult>>>;
+    create(payload: CreatePayload, requestConfig?: RequestInit): Promise<TResult<z.output<CreateResult>>>;
+    updateById(entityId: string, payload: UpdatePayload, requestConfig?: RequestInit): Promise<TResult<z.output<UpdateResult>>>;
+    deleteById(entityId: string, requestConfig?: RequestInit): Promise<TResult<z.output<DeleteResult>>>;
+    /**
+     * Checks if the response has a JSON content type.
+     * This method does not verify that the actually content is valid JSON.
+     */
+    protected isJsonResponse(response: Response): boolean;
+}
+export {};

package/lib/services/entity.service.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityService = void 0;
+const error_1 = require("../error");
+class EntityService {
+    constructor(host, basePath, schemas) {
+        this.host = host;
+        this.basePath = basePath;
+        this.schemas = schemas;
+    }
+    getBaseRequestPath() {
+        return `${this.host}${this.basePath}`;
+    }
+    handleError(e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return [null, e instanceof Error ? e : new Error(msg)];
+    }
+    handleZodError(errors) {
+        const msg = Array.isArray(errors)
+            ? errors.map((e) => e.message).join(", ")
+            : errors.message;
+        console.error(`ZodError in ${this.constructor.name}: %s`, msg);
+        return [null, new Error(msg)];
+    }
+    mergeRequestConfig(config1, config2) {
+        return {
+            ...config1,
+            ...config2,
+            headers: new Headers({
+                ...(config1.headers instanceof Headers
+                    ? Object.fromEntries(config1.headers)
+                    : config1.headers),
+                ...((config2 === null || config2 === void 0 ? void 0 : config2.headers) instanceof Headers
+                    ? Object.fromEntries(config2.headers)
+                    : config2 === null || config2 === void 0 ? void 0 : config2.headers),
+            }),
+        };
+    }
+    async getAll(query, requestConfig) {
+        try {
+            const queryParams = new URLSearchParams();
+            if (query !== undefined) {
+                Object.entries(query).forEach(([key, value]) => {
+                    const isDate = value instanceof Date;
+                    queryParams.append(key, isDate
+                        ? // en-CA format yields YYYY-MM-DD which is ISO 8601 compliant
+                            // new Intl.DateTimeFormat("en-CA").format(value)
+                            value.toLocaleDateString("en-CA")
+                        : String(value));
+                });
+            }
+            const response = await fetch(`${this.getBaseRequestPath()}?${queryParams.toString()}`, this.mergeRequestConfig({
+                method: "GET",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                credentials: "include",
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = this.schemas.getAll.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async getById(entityId, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/${entityId}`, this.mergeRequestConfig({
+                method: "GET",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                credentials: "include",
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = this.schemas.get.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async create(payload, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}`, this.mergeRequestConfig({
+                method: "POST",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {
+                    "Content-Type": "application/json",
+                }),
+                credentials: "include",
+                body: JSON.stringify(payload),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = this.schemas.create.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async updateById(entityId, payload, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/${entityId}`, this.mergeRequestConfig({
+                method: "PUT",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {
+                    "Content-Type": "application/json",
+                }),
+                credentials: "include",
+                body: JSON.stringify(payload),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = this.schemas.update.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    async deleteById(entityId, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/${entityId}`, this.mergeRequestConfig({
+                method: "DELETE",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                credentials: "include",
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = this.schemas.delete.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    /**
+     * Checks if the response has a JSON content type.
+     * This method does not verify that the actually content is valid JSON.
+     */
+    isJsonResponse(response) {
+        const contentType = response.headers.get("content-type");
+        return (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json")) || false;
+    }
+}
+exports.EntityService = EntityService;

package/lib/services/paymentMethod.service.d.ts

@@ -0,0 +1,15 @@
+import type { TResult } from "../types/common";
+import type { TCreateOrUpdatePaymentMethodPayload, TPaymentMethod, TPaymentMethodVH } from "../types/paymentMethod.type";
+import { CreatePaymentMethodResponse, DeletePaymentMethodResponse, GetAllPaymentMethodsResponse, GetPaymentMethodResponse, UpdatePaymentMethodResponse } from "../types/schemas/paymentMethod.schema";
+import { EntityService } from "./entity.service";
+export declare class PaymentMethodService extends EntityService<TCreateOrUpdatePaymentMethodPayload, Partial<TCreateOrUpdatePaymentMethodPayload>, typeof GetAllPaymentMethodsResponse, typeof GetPaymentMethodResponse, typeof CreatePaymentMethodResponse, typeof UpdatePaymentMethodResponse, typeof DeletePaymentMethodResponse> {
+    constructor(host: string, entityPath?: string);
+    getValueHelp(requestConfig?: RequestInit): Promise<TResult<TPaymentMethodVH[]>>;
+    merge({ source, target, }: {
+        source: TPaymentMethod["id"][];
+        target: TPaymentMethod["id"];
+    }, requestConfig?: RequestInit): Promise<TResult<{
+        source: Set<TPaymentMethod["id"]>;
+        target: TPaymentMethod["id"];
+    }>>;
+}

package/lib/services/paymentMethod.service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodService = void 0;
+const zod_1 = __importDefault(require("zod"));
+const error_1 = require("../error");
+const paymentMethod_schema_1 = require("../types/schemas/paymentMethod.schema");
+const entity_service_1 = require("./entity.service");
+class PaymentMethodService extends entity_service_1.EntityService {
+    constructor(host, entityPath = "/api/paymentMethod") {
+        super(host, entityPath, {
+            getAll: paymentMethod_schema_1.GetAllPaymentMethodsResponse,
+            get: paymentMethod_schema_1.GetPaymentMethodResponse,
+            create: paymentMethod_schema_1.CreatePaymentMethodResponse,
+            update: paymentMethod_schema_1.UpdatePaymentMethodResponse,
+            delete: paymentMethod_schema_1.DeletePaymentMethodResponse,
+        });
+    }
+    async getValueHelp(requestConfig) {
+        var _a;
+        const [paymentMethods, error] = await this.getAll(undefined, requestConfig);
+        if (error) {
+            this.handleError(error);
+        }
+        const valueHelpValues = zod_1.default
+            .array(paymentMethod_schema_1.PaymentMethodVH)
+            .safeParse((_a = paymentMethods === null || paymentMethods === void 0 ? void 0 : paymentMethods.data) !== null && _a !== void 0 ? _a : []);
+        if (!valueHelpValues.success) {
+            return this.handleZodError(valueHelpValues.error);
+        }
+        return [valueHelpValues.data, null];
+    }
+    async merge({ source, target, }, requestConfig) {
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/merge`, this.mergeRequestConfig({
+                method: "POST",
+                credentials: "include",
+                headers: new Headers({
+                    "Content-Type": "application/json",
+                    ...((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                }),
+                body: JSON.stringify({ source, target }),
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = paymentMethod_schema_1.MergePaymentMethodsResponse.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [parsingResult.data.data, null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+exports.PaymentMethodService = PaymentMethodService;

package/lib/services/recurringPayment.service.d.ts

@@ -0,0 +1,43 @@
+import type { IGetAllRecurringPaymentsQuery } from "../types/interfaces/recurringPayment.interface";
+import type { TCreateOrUpdateRecurringPaymentPayload, TExpandedRecurringPayment } from "../types/recurringPayment.type";
+import { CreateRecurringPaymentResponse, DeleteRecurringPaymentResponse, GetAllRecurringPaymentsResponse, GetRecurringPaymentResponse, UpdateRecurringPaymentResponse } from "../types/schemas/recurringPayment.schema";
+import { EntityService } from "./entity.service";
+export declare class RecurringPaymentService extends EntityService<TCreateOrUpdateRecurringPaymentPayload, Partial<TCreateOrUpdateRecurringPaymentPayload>, typeof GetAllRecurringPaymentsResponse, typeof GetRecurringPaymentResponse, typeof CreateRecurringPaymentResponse, typeof UpdateRecurringPaymentResponse, typeof DeleteRecurringPaymentResponse> {
+    constructor(host: string, entityPath?: string);
+    getAll(query?: IGetAllRecurringPaymentsQuery, requestConfig?: RequestInit): Promise<import("..").TResult<{
+        status: number;
+        data: {
+            id: string & import("zod").$brand<"TransactionID">;
+            ownerId: string & import("zod").$brand<"UserID">;
+            createdAt: string;
+            updatedAt: string;
+            category: {
+                id: string & import("zod").$brand<"CategoryID">;
+                ownerId: string & import("zod").$brand<"UserID">;
+                name: string;
+                description: string | null;
+                createdAt: string;
+                updatedAt: string;
+            };
+            receiver: string;
+            transferAmount: number;
+            information: string | null;
+            paymentMethod: {
+                id: string & import("zod").$brand<"PaymentMethodID">;
+                ownerId: string & import("zod").$brand<"UserID">;
+                name: string;
+                provider: string;
+                address: string;
+                description: string | null;
+                createdAt: string;
+                updatedAt: string;
+            };
+            paused: boolean;
+            executeAt: number;
+        }[] | null;
+        message?: string | undefined;
+        totalCount?: number | undefined;
+        from?: "db" | "cache" | "external" | undefined;
+    }>>;
+    determineNextExecutionDate(executeAt: TExpandedRecurringPayment["executeAt"]): Date;
+}

package/lib/services/recurringPayment.service.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecurringPaymentService = void 0;
+const recurringPayment_schema_1 = require("../types/schemas/recurringPayment.schema");
+const entity_service_1 = require("./entity.service");
+class RecurringPaymentService extends entity_service_1.EntityService {
+    constructor(host, entityPath = "/api/recurringPayment") {
+        super(host, entityPath, {
+            getAll: recurringPayment_schema_1.GetAllRecurringPaymentsResponse,
+            get: recurringPayment_schema_1.GetRecurringPaymentResponse,
+            create: recurringPayment_schema_1.CreateRecurringPaymentResponse,
+            update: recurringPayment_schema_1.UpdateRecurringPaymentResponse,
+            delete: recurringPayment_schema_1.DeleteRecurringPaymentResponse,
+        });
+    }
+    async getAll(query, requestConfig) {
+        return super.getAll(query, requestConfig);
+    }
+    determineNextExecutionDate(executeAt) {
+        const today = new Date();
+        return today.getDate() < executeAt
+            ? new Date(today.getFullYear(), today.getMonth(), executeAt)
+            : new Date(today.getFullYear(), today.getMonth() + 1, executeAt);
+    }
+}
+exports.RecurringPaymentService = RecurringPaymentService;

package/lib/services/transaction.service.d.ts

@@ -0,0 +1,43 @@
+import type { TResult } from "../types/common";
+import type { IGetAllTransactionsQuery } from "../types/interfaces/transaction.interface";
+import { CreateTransactionResponse, DeleteTransactionResponse, GetAllTransactionsResponse, GetTransactionResponse, UpdateTransactionResponse } from "../types/schemas/transaction.schema";
+import type { TCreateOrUpdateTransactionPayload, TReceiverVH } from "../types/transaction.type";
+import { EntityService } from "./entity.service";
+export declare class TransactionService extends EntityService<TCreateOrUpdateTransactionPayload, Partial<TCreateOrUpdateTransactionPayload>, typeof GetAllTransactionsResponse, typeof GetTransactionResponse, typeof CreateTransactionResponse, typeof UpdateTransactionResponse, typeof DeleteTransactionResponse> {
+    constructor(host: string, entityPath?: string);
+    getAll(query?: IGetAllTransactionsQuery, requestConfig?: RequestInit): Promise<TResult<{
+        status: number;
+        data: {
+            id: string & import("zod").$brand<"TransactionID">;
+            ownerId: string & import("zod").$brand<"UserID">;
+            createdAt: string;
+            updatedAt: string;
+            processedAt: string | Date;
+            receiver: string;
+            transferAmount: number;
+            information: string | null;
+            category: {
+                id: string & import("zod").$brand<"CategoryID">;
+                ownerId: string & import("zod").$brand<"UserID">;
+                name: string;
+                description: string | null;
+                createdAt: string;
+                updatedAt: string;
+            };
+            paymentMethod: {
+                id: string & import("zod").$brand<"PaymentMethodID">;
+                ownerId: string & import("zod").$brand<"UserID">;
+                name: string;
+                provider: string;
+                address: string;
+                description: string | null;
+                createdAt: string;
+                updatedAt: string;
+            };
+        }[] | null;
+        message?: string | undefined;
+        totalCount?: number | undefined;
+        from?: "db" | "cache" | "external" | undefined;
+    }>>;
+    getReceiverVH(requestConfig?: RequestInit): Promise<TResult<TReceiverVH[]>>;
+}

package/lib/services/transaction.service.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+const error_1 = require("../error");
+const transaction_schema_1 = require("../types/schemas/transaction.schema");
+const entity_service_1 = require("./entity.service");
+class TransactionService extends entity_service_1.EntityService {
+    constructor(host, entityPath = "/api/transaction") {
+        super(host, entityPath, {
+            getAll: transaction_schema_1.GetAllTransactionsResponse,
+            get: transaction_schema_1.GetTransactionResponse,
+            create: transaction_schema_1.CreateTransactionResponse,
+            update: transaction_schema_1.UpdateTransactionResponse,
+            delete: transaction_schema_1.DeleteTransactionResponse,
+        });
+    }
+    async getAll(query, requestConfig) {
+        return super.getAll(query, requestConfig);
+    }
+    async getReceiverVH(requestConfig) {
+        var _a;
+        try {
+            const response = await fetch(`${this.getBaseRequestPath()}/receiver`, this.mergeRequestConfig({
+                method: "GET",
+                headers: new Headers((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.headers) || {}),
+                credentials: "include",
+            }, requestConfig));
+            if (!response.ok) {
+                throw new error_1.BackendError(response.status, response.statusText);
+            }
+            if (!this.isJsonResponse(response)) {
+                throw new error_1.ResponseNotJsonError();
+            }
+            const data = await response.json();
+            const parsingResult = transaction_schema_1.ReceiverVHResponse.safeParse(data);
+            if (!parsingResult.success) {
+                return this.handleZodError(parsingResult.error);
+            }
+            return [(_a = parsingResult.data.data) !== null && _a !== void 0 ? _a : [], null];
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+exports.TransactionService = TransactionService;

package/lib/transaction.d.ts

@@ -0,0 +1,4 @@
+export * from "./services/transaction.service";
+export * from "./types/interfaces/transaction.interface";
+export * from "./types/schemas/transaction.schema";
+export * from "./types/transaction.type";

package/lib/transaction.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./services/transaction.service"), exports);
+__exportStar(require("./types/interfaces/transaction.interface"), exports);
+__exportStar(require("./types/schemas/transaction.schema"), exports);
+__exportStar(require("./types/transaction.type"), exports);

package/lib/types/budget.type.d.ts

@@ -0,0 +1,5 @@
+import type { TypeOfSchema } from "./common";
+import type * as schema from "./schemas/budget.schema";
+export type TBudget = TypeOfSchema<typeof schema.Budget>;
+export type TCreateOrUpdateBudgetPayload = TypeOfSchema<typeof schema.CreateOrUpdateBudgetPayload>;
+export type TEstimatedBudget = TypeOfSchema<typeof schema.EstimatedBudget>;