Feat/ecurrency overdraft toggle (#819)

* fix: correct envDir path in Vite configuration

* feat: add allowNegativeGroupOnly feature to currency management

* feat: implement overdraft validation for group members and enhance negative balance checks

Author: Bekiboo

platforms/ecurrency/api/src/controllers/CurrencyController.ts

@@ -15,13 +15,14 @@ export class CurrencyController {
                 return res.status(401).json({ error: "Authentication required" });
             }
 
-            const { name, description, groupId, allowNegative, maxNegativeBalance } = req.body;
+            const { name, description, groupId, allowNegative, maxNegativeBalance, allowNegativeGroupOnly } = req.body;
 
             if (!name || !groupId) {
                 return res.status(400).json({ error: "Name and groupId are required" });
             }
 
             const allowNegativeFlag = Boolean(allowNegative);
+            const allowNegativeGroupOnlyFlag = Boolean(allowNegativeGroupOnly);
             let normalizedMaxNegative: number | null = null;
 
             if (maxNegativeBalance !== undefined && maxNegativeBalance !== null && maxNegativeBalance !== "") {
@@ -48,7 +49,8 @@ export class CurrencyController {
                 req.user.id,
                 allowNegativeFlag,
                 normalizedMaxNegative,
-                description
+                description,
+                allowNegativeGroupOnlyFlag
             );
 
             res.status(201).json({
@@ -58,6 +60,7 @@ export class CurrencyController {
                 ename: currency.ename,
                 groupId: currency.groupId,
                 allowNegative: currency.allowNegative,
+                allowNegativeGroupOnly: currency.allowNegativeGroupOnly,
                 maxNegativeBalance: currency.maxNegativeBalance,
                 createdBy: currency.createdBy,
                 createdAt: currency.createdAt,
@@ -81,6 +84,7 @@ export class CurrencyController {
                 ename: currency.ename,
                 groupId: currency.groupId,
                 allowNegative: currency.allowNegative,
+                allowNegativeGroupOnly: currency.allowNegativeGroupOnly,
                 maxNegativeBalance: currency.maxNegativeBalance,
                 createdBy: currency.createdBy,
                 createdAt: currency.createdAt,
@@ -108,6 +112,7 @@ export class CurrencyController {
                 ename: currency.ename,
                 groupId: currency.groupId,
                 allowNegative: currency.allowNegative,
+                allowNegativeGroupOnly: currency.allowNegativeGroupOnly,
                 maxNegativeBalance: currency.maxNegativeBalance,
                 createdBy: currency.createdBy,
                 createdAt: currency.createdAt,
@@ -130,6 +135,7 @@ export class CurrencyController {
                 ename: currency.ename,
                 groupId: currency.groupId,
                 allowNegative: currency.allowNegative,
+                allowNegativeGroupOnly: currency.allowNegativeGroupOnly,
                 maxNegativeBalance: currency.maxNegativeBalance,
                 createdBy: currency.createdBy,
                 createdAt: currency.createdAt,

platforms/ecurrency/api/src/controllers/LedgerController.ts

@@ -51,6 +51,7 @@ export class LedgerController {
                         name: b.currency.name,
                         ename: b.currency.ename,
                         allowNegative: b.currency.allowNegative,
+                        allowNegativeGroupOnly: b.currency.allowNegativeGroupOnly,
                     },
                     balance: b.balance,
                 })));

platforms/ecurrency/api/src/database/entities/Currency.ts

@@ -39,6 +39,9 @@ export class Currency {
     @Column("decimal", { precision: 18, scale: 2, nullable: true })
     maxNegativeBalance!: number | null;
 
+    @Column({ default: false })
+    allowNegativeGroupOnly!: boolean;
+
     @Column()
     createdBy!: string;
 

platforms/ecurrency/api/src/database/migrations/1771523000000-add-allow-negative-group-only.ts

@@ -0,0 +1,11 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddAllowNegativeGroupOnly1771523000000 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "currencies" ADD "allowNegativeGroupOnly" boolean NOT NULL DEFAULT false`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "currencies" DROP COLUMN "allowNegativeGroupOnly"`);
+    }
+}

platforms/ecurrency/api/src/services/CurrencyService.ts

@@ -23,7 +23,8 @@ export class CurrencyService {
         createdBy: string,
         allowNegative: boolean = false,
         maxNegativeBalance: number | null = null,
-        description?: string
+        description?: string,
+        allowNegativeGroupOnly: boolean = false
     ): Promise<Currency> {
         // Verify user is group admin
         const isAdmin = await this.groupService.isGroupAdmin(groupId, createdBy);
@@ -46,6 +47,10 @@ export class CurrencyService {
             }
         }
 
+        if (allowNegativeGroupOnly && !allowNegative) {
+            throw new Error("Cannot restrict overdraft to group members when negative balances are disabled");
+        }
+
         const currency = this.currencyRepository.create({
             name,
             description,
@@ -54,6 +59,7 @@ export class CurrencyService {
             createdBy,
             allowNegative,
             maxNegativeBalance,
+            allowNegativeGroupOnly,
         });
 
         const savedCurrency = await this.currencyRepository.save(currency);

platforms/ecurrency/api/src/services/GroupService.ts

@@ -234,5 +234,19 @@ export class GroupService {
         if (!group) return false;
         return group.admins.some(admin => admin.id === userId);
     }
+
+    async isUserInGroup(groupId: string, userId: string): Promise<boolean> {
+        const group = await this.groupRepository.findOne({
+            where: { id: groupId },
+            relations: ["members", "participants", "admins"]
+        });
+        if (!group) return false;
+        
+        // Check if user is the owner, a member, participant, or admin
+        return group.owner === userId ||
+               group.members.some(m => m.id === userId) ||
+               group.participants.some(p => p.id === userId) ||
+               group.admins.some(a => a.id === userId);
+    }
 }
 

platforms/ecurrency/api/src/services/LedgerService.ts

@@ -5,15 +5,18 @@ import { Currency } from "../database/entities/Currency";
 import { User } from "../database/entities/User";
 import { Group } from "../database/entities/Group";
 import { TransactionNotificationService } from "./TransactionNotificationService";
+import { GroupService } from "./GroupService";
 import crypto from "crypto";
 
 export class LedgerService {
     ledgerRepository: Repository<Ledger>;
     currencyRepository: Repository<Currency>;
+    groupService: GroupService;
 
     constructor() {
         this.ledgerRepository = AppDataSource.getRepository(Ledger);
         this.currencyRepository = AppDataSource.getRepository(Currency);
+        this.groupService = new GroupService();
     }
 
     private computeHash(payload: any): string {
@@ -28,6 +31,23 @@ export class LedgerService {
         return prev?.hash ?? null;
     }
 
+    /**
+     * Validates whether a debit of `amount` from `currentBalance` is allowed
+     * given the currency's negative-balance settings.
+     */
+    private validateNegativeAllowance(currency: Currency, currentBalance: number, amount: number): void {
+        if (!currency.allowNegative && currentBalance < amount) {
+            throw new Error("Insufficient balance. This currency does not allow negative balances.");
+        }
+
+        if (currency.allowNegative && currency.maxNegativeBalance !== null && currency.maxNegativeBalance !== undefined) {
+            const newBalance = currentBalance - amount;
+            if (newBalance < Number(currency.maxNegativeBalance)) {
+                throw new Error(`Insufficient balance. This currency allows negative balances down to ${currency.maxNegativeBalance}.`);
+            }
+        }
+    }
+
     async getAccountBalance(currencyId: string, accountId: string, accountType: AccountType): Promise<number> {
         const latestEntry = await this.ledgerRepository.findOne({
             where: {
@@ -132,16 +152,23 @@ export class LedgerService {
 
         const currentBalance = await this.getAccountBalance(currencyId, fromAccountId, fromAccountType);
 
-        // Validate debit bounds
-        if (!currency.allowNegative && currentBalance < amount) {
-            throw new Error("Insufficient balance. This currency does not allow negative balances.");
-        }
-
-        if (currency.allowNegative && currency.maxNegativeBalance !== null && currency.maxNegativeBalance !== undefined) {
-            const newBalance = currentBalance - amount;
-            if (newBalance < Number(currency.maxNegativeBalance)) {
-                throw new Error(`Insufficient balance. This currency allows negative balances down to ${currency.maxNegativeBalance}.`);
+        // Validate debit bounds.
+        // When allowNegativeGroupOnly is true, only group members may overdraft;
+        // non-members are limited to their current balance. Note: the invariant
+        // allowNegativeGroupOnly ⇒ allowNegative is enforced at creation time
+        // in CurrencyService.createCurrency.
+        if (currency.allowNegativeGroupOnly && fromAccountType === AccountType.USER) {
+            const isMember = await this.groupService.isUserInGroup(currency.groupId, fromAccountId);
+
+            if (!isMember) {
+                if (currentBalance < amount) {
+                    throw new Error("Insufficient balance. Only group members can have negative balances for this currency.");
+                }
+            } else {
+                this.validateNegativeAllowance(currency, currentBalance, amount);
             }
+        } else {
+            this.validateNegativeAllowance(currency, currentBalance, amount);
         }
 
         // Create debit entry (from sender's account)

platforms/ecurrency/client/client/src/components/currency/create-currency-modal.tsx

@@ -16,6 +16,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
   const [description, setDescription] = useState("");
   const [groupId, setGroupId] = useState("");
   const [allowNegative, setAllowNegative] = useState(false);
+  const [allowNegativeGroupOnly, setAllowNegativeGroupOnly] = useState(false);
   const [maxNegativeInput, setMaxNegativeInput] = useState("");
   const [error, setError] = useState<string | null>(null);
   const queryClient = useQueryClient();
@@ -28,6 +29,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
       description?: string;
       groupId: string;
       allowNegative: boolean;
+      allowNegativeGroupOnly: boolean;
       maxNegativeBalance: number | null;
     }) => {
       const response = await apiClient.post("/api/currencies", data);
@@ -40,6 +42,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
       setDescription("");
       setGroupId("");
       setAllowNegative(false);
+      setAllowNegativeGroupOnly(false);
       setMaxNegativeInput("");
       setError(null);
       onOpenChange(false);
@@ -91,6 +94,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
               description,
               groupId,
               allowNegative,
+              allowNegativeGroupOnly,
               maxNegativeBalance: maxNegativeValue,
             });
           }}
@@ -142,6 +146,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
                 type="button"
                 onClick={() => {
                   setAllowNegative(false);
+                  setAllowNegativeGroupOnly(false);
                   setMaxNegativeInput("");
                 }}
                 className={`p-4 border-2 rounded-lg text-left transition-all ${
@@ -173,8 +178,24 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
           </div>
 
           {allowNegative && (
-            <div>
-              <label className="block text-sm font-medium mb-1">Max negative balance (absolute value)</label>
+            <>
+              <div>
+                <label className="flex items-center gap-2 cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={allowNegativeGroupOnly}
+                    onChange={(e) => setAllowNegativeGroupOnly(e.target.checked)}
+                    className="w-4 h-4 rounded border-gray-300"
+                  />
+                  <span className="text-sm font-medium">Restrict overdraft to group members only</span>
+                </label>
+                <p className="text-xs text-muted-foreground mt-1 ml-6">
+                  When enabled, only users who are members of the currency's group can have negative balances. Non-members must maintain a positive balance.
+                </p>
+              </div>
+              
+              <div>
+                <label className="block text-sm font-medium mb-1">Max negative balance (absolute value)</label>
               <input
                 type="number"
                 min={0}
@@ -189,6 +210,7 @@ export default function CreateCurrencyModal({ open, onOpenChange, groups }: Crea
                 Limit how far any account can go below zero (max {MAX_NEGATIVE_LIMIT.toLocaleString()}).
               </p>
             </div>
+            </>
           )}
 
           {error && (

platforms/ecurrency/client/client/src/components/currency/transfer-modal.tsx

@@ -244,7 +244,9 @@ export default function TransferModal({ open, onOpenChange, fromCurrencyId, acco
             )}
             {fromCurrencyData && fromCurrencyData.allowNegative && (
               <p className="text-sm text-muted-foreground mt-1">
-                Negative balances are allowed for this currency
+                {fromCurrencyData.allowNegativeGroupOnly
+                  ? "Negative balances allowed for group members"
+                  : "Negative balances are allowed for this currency"}
               </p>
             )}
           </div>
@@ -353,15 +355,6 @@ export default function TransferModal({ open, onOpenChange, fromCurrencyId, acco
             </div>
           )}
 
-          {/* Mutation Error */}
-          {transferMutation.isError && (
-            <div className="bg-red-50 border border-red-200 text-red-700 px-4 py-3 rounded-lg">
-              {transferMutation.error instanceof Error
-                ? transferMutation.error.message
-                : "An error occurred while processing the transfer"}
-            </div>
-          )}
-
           <div className="flex gap-2 justify-end pt-4">
             <button
               type="button"

platforms/ecurrency/client/client/src/pages/dashboard.tsx

@@ -224,7 +224,9 @@ export default function Dashboard() {
                   <div className="text-xs text-white/80 mt-1">{formatEName(balance.currency.ename)}</div>
                   {balance.currency.allowNegative !== undefined && (
                     <div className="text-xs px-2 py-0.5 rounded bg-white/20 text-white/90 mt-1 inline-block">
-                      {balance.currency.allowNegative ? "Negative Allowed" : "No Negative"}
+                      {balance.currency.allowNegative
+                        ? (balance.currency.allowNegativeGroupOnly ? "Negative Allowed (Members only)" : "Negative Allowed")
+                        : "No Negative"}
                     </div>
                   )}
                 </div>