@temboplus/afloat 0.1.77-beta.9 → 0.1.79

package/script/npm/src/src/features/wallet/repository.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletRepo = void 0;
+const base_repository_js_1 = require("../../shared/base_repository.js");
+const contract_js_1 = require("./contract.js");
+const index_js_1 = require("../../models/wallet/index.js");
+const permission_js_1 = require("../../models/permission.js");
+const index_js_2 = require("../../errors/index.js");
+/**
+ * Repository class for managing wallet operations including balance checking,
+ * statement generation, and wallet information retrieval.
+ * @extends {BaseRepository<typeof contract>}
+ */
+class WalletRepo extends base_repository_js_1.BaseRepository {
+    /**
+     * Creates an instance of WalletRepo initialized with the wallet contract.
+     * @param {Object} [options] - Optional configuration
+     * @param {string} [options.root] - Custom API root URL
+     * @param {AfloatAuth} [options.auth] - Auth instance to use
+     */
+    constructor(props) {
+        super("wallet", contract_js_1.contract, {
+            root: props?.root,
+            auth: props?.auth,
+        });
+    }
+    /**
+     * Retrieves the current available balance for the wallet.
+     * @throws {PermissionError} If user lacks the ViewBalance permission
+     * @throws {Error} If the balance fetch operation fails
+     * @returns {Promise<number>} The available balance amount
+     */
+    async getBalance(props) {
+        const auth = this.getAuthForPermissionCheck();
+        const requirePerm = permission_js_1.Permissions.Wallet.ViewBalance;
+        if (!auth.checkPermission(requirePerm)) {
+            throw new index_js_2.PermissionError({
+                message: "You are not authorized to view the account balance.",
+                requiredPermissions: [requirePerm],
+            });
+        }
+        const result = await this.client.getBalance({
+            body: { accountNo: props.accountNo },
+        });
+        if (result.status === 201) {
+            return result.body.availableBalance;
+        }
+        throw new Error("An error occured while fetching balance");
+    }
+    /**
+     * Retrieves all wallets associated with the current context.
+     * @throws {Error} If the wallet fetch operation fails
+     * @returns {Promise<Wallet[]>} Array of wallet objects
+     */
+    async getWallets(args) {
+        const result = await this.client.getWallets({ query: args });
+        if (result.status === 200) {
+            return result.body.map((w) => index_js_1.Wallet.from(w));
+        }
+        throw new Error("An error occured while fetching wallets");
+    }
+    /**
+     * Retrieves wallet statement items for a specified date range and account.
+     * If no range is provided, defaults to the current month (1st to 30th).
+     * @param {Object} props - The statement request properties
+     * @param {Object} [props.range] - Optional date range for the statement
+     * @param {Date} props.range.startDate - Start date for the statement period
+     * @param {Date} props.range.endDate - End date for the statement period
+     * @param {string} [props.accountNo] - Optional account number to fetch statement for
+     * @throws {PermissionError} If user lacks the ViewStatement permission
+     * @throws {Error} If the statement fetch operation fails
+     * @returns {Promise<WalletStatementEntry[]>} Array of statement items for the specified period
+     */
+    async getStatement(props) {
+        const auth = this.getAuthForPermissionCheck();
+        const requirePerm = permission_js_1.Permissions.Wallet.ViewStatement;
+        if (!auth.checkPermission(requirePerm)) {
+            throw new index_js_2.PermissionError({
+                message: "You are not authorized to view the statement.",
+                requiredPermissions: [requirePerm],
+            });
+        }
+        const now = new Date();
+        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+        const monthEnd = new Date(now.getFullYear(), now.getMonth(), 30);
+        const range = props.range !== undefined
+            ? { startDate: props.range.startDate, endDate: props.range.endDate }
+            : { startDate: monthStart, endDate: monthEnd };
+        const body = { ...range, accountNo: props.accountNo };
+        const result = await this.client.getStatement({ body });
+        if (result.status === 201) {
+            return result.body.map((e) => index_js_1.WalletStatementEntry.from(e));
+        }
+        throw new Error("An error occured while fetching statement");
+    }
+}
+exports.WalletRepo = WalletRepo;

package/script/npm/src/src/models/contact/derivatives/contact.d.ts

@@ -0,0 +1,172 @@
+import { type ContactData, type ContactType } from "../schemas.js";
+import { type ContactInfo } from "./contact_info.js";
+/**
+ * Contact class that wraps the Zod schema and provides additional functionality
+ */
+export declare class Contact {
+    private readonly data;
+    /**
+     * Private constructor - use static methods to create instances
+     */
+    private constructor();
+    /**
+     * Unique identifier for the contact
+     */
+    get id(): string;
+    /**
+     * Profile identifier associated with this contact
+     */
+    get profileId(): string;
+    /**
+     * Display name of the contact
+     */
+    get displayName(): string;
+    /**
+     * Type of contact (Bank or Mobile)
+     */
+    get type(): ContactType;
+    /**
+     * Creation timestamp of the contact
+     */
+    get createdAt(): Date;
+    /**
+     * Update timestamp of the contact
+     */
+    get updatedAt(): Date;
+    /**
+     * Detailed contact information based on contact type
+     *
+     * @returns {ContactInfo | undefined} Contact information object:
+     * - MobileContactInfo for mobile money contacts
+     * - BankContactInfo for bank contacts
+     * - undefined if contact information cannot be constructed
+     *
+     * @remarks
+     * For mobile contacts, constructs from phone number
+     * For bank contacts, constructs from SWIFT code and account number
+     */
+    get info(): ContactInfo | undefined;
+    /**
+     * Payment channel for the contact
+     *
+     * @returns {string} Channel information:
+     * - For valid contacts, returns formatted channel from ContactInfo
+     * - For invalid contacts, falls back to account number
+     */
+    get channel(): string;
+    /**
+     * Account number for the contact
+     *
+     * @returns {string} Account number:
+     * - For valid contacts, returns formatted account number from ContactInfo
+     * - For invalid contacts, falls back to raw account number
+     */
+    get accNo(): string;
+    /**
+     * Account name for the contact
+     * Always returns the display name
+     */
+    get accName(): string;
+    /**
+     * Label for the account number field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Phone Number" for mobile contacts
+     * - "Bank Account Number" for bank contacts
+     * - "Account Number" as fallback
+     */
+    get accNoLabel(): string;
+    /**
+     * Label for the channel field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Channel" for mobile contacts
+     * - "Bank" for bank contacts
+     * - "Channel" as fallback
+     */
+    get channelLabel(): string;
+    /**
+     * Label for the account name field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Full Name" for mobile contacts
+     * - "Bank Account Name" for bank contacts
+     * - "Display Name" as fallback
+     */
+    get accNameLabel(): string;
+    /**
+     * Creates a Contact instance from raw data
+     * @throws {ZodError} if validation fails
+     */
+    static create(data: ContactData): Contact;
+    /**
+     * Creates multiple Contact instances from an array of raw data
+     * @throws {ZodError} if validation fails for any item
+     */
+    static createMany(dataArray: ContactData[]): Contact[];
+    /**
+     * Creates a Contact instance from raw data without throwing
+     * @returns {Contact | null} Contact instance or null if validation fails
+     */
+    static createSafe(data: ContactData): Contact | null;
+    /**
+     * Checks if an unknown value contains valid data to construct a Contact instance.
+     * This is useful when validating raw data structures before instantiation.
+     *
+     * @param {unknown} obj - The value containing potential contact data
+     * @returns {obj is Contact} Type predicate indicating if a Contact can be constructed
+     *
+     * @example
+     * ```typescript
+     * const rawData = await fetchFromAPI();
+     * if (Contact.canConstruct(rawData)) {
+     *   const contact = Contact.create(rawData);
+     *   // TypeScript knows contact is valid here
+     *   console.log(contact.displayName);
+     * }
+     * ```
+     *
+     * @throws {never} This method never throws errors
+     *
+     * @remarks
+     * This method performs strict validation against the {@link ContactData} schema.
+     */
+    static canConstruct(obj: unknown): obj is Contact;
+    /**
+     * Validates if an unknown value is a Contact instance.
+     * This is a runtime type guard that ensures proper object structure and data validity.
+     *
+     * @param {unknown} obj - The value to validate
+     * @returns {obj is Contact} Type predicate indicating if the value is a valid Contact
+     *
+     * @example
+     * ```typescript
+     * const maybeContact = getContactFromCache();
+     * if (Contact.is(maybeContact)) {
+     *   // TypeScript knows maybeContact is a Contact here
+     *   console.log(maybeContact.displayName);
+     * }
+     * ```
+     *
+     * @throws {never} This method never throws errors
+     *
+     * @remarks
+     * This method performs a complete structural validation:
+     * 1. Checks if the value is an object
+     * 2. Verifies presence of internal data property
+     * 3. Validates the data against ContactData schema
+     * 4. Ensures the object is a proper Contact instance
+     *
+     * Use this method when:
+     * - Validating cached Contact instances
+     * - Checking serialized Contact objects
+     * - Verifying API responses
+     * - Type narrowing in conditional blocks
+     */
+    static is(obj: unknown): obj is Contact;
+    /**
+     * Converts Payout instance to a plain object
+     */
+    toJSON(): ContactData;
+}
+//# sourceMappingURL=contact.d.ts.map

package/script/npm/src/src/models/contact/derivatives/contact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../../../../../../src/src/models/contact/derivatives/contact.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IAEnC;;OAEG;IACH,OAAO;IAIP;;OAEG;IACH,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,WAAW,CAEtB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,IAAI,CAEpB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,IAAI,CAEpB;IAED;;;;;;;;;;;OAWG;IACH,IAAI,IAAI,IAAI,WAAW,GAAG,SAAS,CAoBlC;IAED;;;;;;OAMG;IACH,IAAI,OAAO,IAAI,MAAM,CAIpB;IAED;;;;;;OAMG;IACH,IAAI,KAAK,IAAI,MAAM,CAIlB;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,MAAM,CAKvB;IAED;;;;;;;OAOG;IACH,IAAI,YAAY,IAAI,MAAM,CAKzB;IAED;;;;;;;OAOG;IACH,IAAI,YAAY,IAAI,MAAM,CAKzB;IAED;;;OAGG;WACW,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAIhD;;;OAGG;WACW,UAAU,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE;IAI7D;;;OAGG;WACW,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,IAAI;IAQ3D;;;;;;;;;;;;;;;;;;;;;OAqBG;WACW,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO;IAUxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;WACW,EAAE,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO;IAO9C;;OAEG;IACH,MAAM,IAAI,WAAW;CAGtB"}

package/script/npm/src/src/models/contact/derivatives/contact.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = void 0;
+const schemas_js_1 = require("../schemas.js");
+const index_js_1 = require("../index.js");
+const frontend_core_1 = require("@temboplus/frontend-core");
+const contact_info_js_1 = require("./contact_info.js");
+/**
+ * Contact class that wraps the Zod schema and provides additional functionality
+ */
+class Contact {
+    /**
+     * Private constructor - use static methods to create instances
+     */
+    constructor(data) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = schemas_js_1.ContactSchemas.contactData.parse(data);
+    }
+    /**
+     * Unique identifier for the contact
+     */
+    get id() {
+        return this.data.id;
+    }
+    /**
+     * Profile identifier associated with this contact
+     */
+    get profileId() {
+        return this.data.profileId;
+    }
+    /**
+     * Display name of the contact
+     */
+    get displayName() {
+        return this.data.displayName;
+    }
+    /**
+     * Type of contact (Bank or Mobile)
+     */
+    get type() {
+        return this.data.type;
+    }
+    /**
+     * Creation timestamp of the contact
+     */
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    /**
+     * Update timestamp of the contact
+     */
+    get updatedAt() {
+        return this.data.updatedAt;
+    }
+    /**
+     * Detailed contact information based on contact type
+     *
+     * @returns {ContactInfo | undefined} Contact information object:
+     * - MobileContactInfo for mobile money contacts
+     * - BankContactInfo for bank contacts
+     * - undefined if contact information cannot be constructed
+     *
+     * @remarks
+     * For mobile contacts, constructs from phone number
+     * For bank contacts, constructs from SWIFT code and account number
+     */
+    get info() {
+        if (this.data.type === "Mobile") {
+            const phone = frontend_core_1.TZPhoneNumber.from(this.data.accountNo);
+            if (phone) {
+                return new index_js_1.MobileContactInfo(this.data.displayName, phone);
+            }
+        }
+        if (this.data.type === "Bank") {
+            const bank = frontend_core_1.Bank.fromSWIFTCode(this.data.channel);
+            if (bank) {
+                return new contact_info_js_1.BankContactInfo(this.data.displayName, bank, this.data.accountNo);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Payment channel for the contact
+     *
+     * @returns {string} Channel information:
+     * - For valid contacts, returns formatted channel from ContactInfo
+     * - For invalid contacts, falls back to account number
+     */
+    get channel() {
+        const info = this.info;
+        if (info)
+            return info.channel;
+        return this.data.accountNo;
+    }
+    /**
+     * Account number for the contact
+     *
+     * @returns {string} Account number:
+     * - For valid contacts, returns formatted account number from ContactInfo
+     * - For invalid contacts, falls back to raw account number
+     */
+    get accNo() {
+        const info = this.info;
+        if (info)
+            return info.accNumber;
+        return this.data.accountNo;
+    }
+    /**
+     * Account name for the contact
+     * Always returns the display name
+     */
+    get accName() {
+        return this.data.displayName;
+    }
+    /**
+     * Label for the account number field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Phone Number" for mobile contacts
+     * - "Bank Account Number" for bank contacts
+     * - "Account Number" as fallback
+     */
+    get accNoLabel() {
+        const info = this.info;
+        if (info instanceof index_js_1.MobileContactInfo)
+            return "Phone Number";
+        if (info instanceof contact_info_js_1.BankContactInfo)
+            return "Bank Account Number";
+        return "Account Number";
+    }
+    /**
+     * Label for the channel field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Channel" for mobile contacts
+     * - "Bank" for bank contacts
+     * - "Channel" as fallback
+     */
+    get channelLabel() {
+        const info = this.info;
+        if (info instanceof index_js_1.MobileContactInfo)
+            return "Channel";
+        if (info instanceof contact_info_js_1.BankContactInfo)
+            return "Bank";
+        return "Channel";
+    }
+    /**
+     * Label for the account name field based on contact type
+     *
+     * @returns {string} Appropriate label:
+     * - "Full Name" for mobile contacts
+     * - "Bank Account Name" for bank contacts
+     * - "Display Name" as fallback
+     */
+    get accNameLabel() {
+        const info = this.info;
+        if (info instanceof index_js_1.MobileContactInfo)
+            return "Full Name";
+        if (info instanceof contact_info_js_1.BankContactInfo)
+            return "Bank Account Name";
+        return "Display Name";
+    }
+    /**
+     * Creates a Contact instance from raw data
+     * @throws {ZodError} if validation fails
+     */
+    static create(data) {
+        return new Contact(data);
+    }
+    /**
+     * Creates multiple Contact instances from an array of raw data
+     * @throws {ZodError} if validation fails for any item
+     */
+    static createMany(dataArray) {
+        return dataArray.map((data) => new Contact(data));
+    }
+    /**
+     * Creates a Contact instance from raw data without throwing
+     * @returns {Contact | null} Contact instance or null if validation fails
+     */
+    static createSafe(data) {
+        try {
+            return new Contact(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Checks if an unknown value contains valid data to construct a Contact instance.
+     * This is useful when validating raw data structures before instantiation.
+     *
+     * @param {unknown} obj - The value containing potential contact data
+     * @returns {obj is Contact} Type predicate indicating if a Contact can be constructed
+     *
+     * @example
+     * ```typescript
+     * const rawData = await fetchFromAPI();
+     * if (Contact.canConstruct(rawData)) {
+     *   const contact = Contact.create(rawData);
+     *   // TypeScript knows contact is valid here
+     *   console.log(contact.displayName);
+     * }
+     * ```
+     *
+     * @throws {never} This method never throws errors
+     *
+     * @remarks
+     * This method performs strict validation against the {@link ContactData} schema.
+     */
+    static canConstruct(obj) {
+        if (!obj || typeof obj !== "object")
+            return false;
+        const result = schemas_js_1.ContactSchemas.contactData.safeParse(obj);
+        if (!result.success)
+            return false;
+        const contact = Contact.createSafe(result.data);
+        return contact !== null;
+    }
+    /**
+     * Validates if an unknown value is a Contact instance.
+     * This is a runtime type guard that ensures proper object structure and data validity.
+     *
+     * @param {unknown} obj - The value to validate
+     * @returns {obj is Contact} Type predicate indicating if the value is a valid Contact
+     *
+     * @example
+     * ```typescript
+     * const maybeContact = getContactFromCache();
+     * if (Contact.is(maybeContact)) {
+     *   // TypeScript knows maybeContact is a Contact here
+     *   console.log(maybeContact.displayName);
+     * }
+     * ```
+     *
+     * @throws {never} This method never throws errors
+     *
+     * @remarks
+     * This method performs a complete structural validation:
+     * 1. Checks if the value is an object
+     * 2. Verifies presence of internal data property
+     * 3. Validates the data against ContactData schema
+     * 4. Ensures the object is a proper Contact instance
+     *
+     * Use this method when:
+     * - Validating cached Contact instances
+     * - Checking serialized Contact objects
+     * - Verifying API responses
+     * - Type narrowing in conditional blocks
+     */
+    static is(obj) {
+        if (!obj || typeof obj !== "object")
+            return false;
+        if (!("data" in obj))
+            return false;
+        return Contact.canConstruct(obj.data);
+    }
+    /**
+     * Converts Payout instance to a plain object
+     */
+    toJSON() {
+        return { ...this.data };
+    }
+}
+exports.Contact = Contact;