Ohada Lib

Une bibliothèque comptable OHADA / SYSCOHADA Révisé, pensée pour les développeurs. Transformez les événements métier d'une PME (ventes, achats, dépenses, etc.) en écritures comptables équilibrées et conformes, sans avoir à manipuler manuellement les débits et les crédits.

Fonctionnalités Principales

• Conformité OHADA : Génération d'écritures respectant le SYSCOHADA Révisé.
• Façades Métier Intuitives : Ventes, Achats, Dépenses (OPEX), Investissements (CAPEX), Virements, Inventaire et Financement.
• Support Multi-Moyens de Paiement : Caisse (Cash), Banque (Bank) et Mobile Money.
• Précision Décimale : Calculs financiers fiables basés sur decimal.js.
• Typage Strict : Écrit intégralement en TypeScript.
• Adaptation Locale : Configuration par défaut adaptée à la RDC (CDF, TVA à 16%), entièrement paramétrable.
• Format Prêt pour Base de Données : Exportation via .toFlatEntries() idéal pour Firestore, SQL ou MongoDB.

Installation

npm install @drcmind/ohada-lib

Initialisation

Instanciez la bibliothèque en passant une configuration optionnelle (les valeurs par défaut sont CDF pour la devise et 16% pour la TVA).

import { Ohada } from '@drcmind/ohada-lib';

const ohada = new Ohada({
  currencyCode: 'CDF',
  defaultVatRate: 0.16,
  // Vous pouvez surcharger le plan comptable par défaut :
  // accountMapping: { salesRevenue: '7011', treasuryCash: '5711', ... }
});

Aperçu des APIs (Façades Métier)

1. Ventes (Sales)

Le cycle complet d'une vente (facturation, paiement, livraison).

// Constatation de la vente (Facturation)
const facture = ohada.sale.constate({
  saleId: 'SALE-001',
  items: [
    { name: 'Produit A', quantity: 2, price: 50000 },
    { name: 'Service B', quantity: 1, price: 20000, isTaxFree: true }
  ]
});

// Paiement (Multi-wallets : Cash, Bank, Mobile)
const paiement = ohada.sale.pay({
  saleId: 'SALE-001',
  payments: [
    { amount: 50000, walletType: 'CASH' },
    { amount: 66000, walletType: 'MOBILE' }
  ]
});

// Sortie de stock
const livraison = ohada.sale.deliver({
  saleId: 'SALE-001',
  inventoryValue: 70000
});

2. Dépenses OPEX & Investissements CAPEX

Enregistrement en une seule étape (Constatation + Paiement).

// Dépense d'exploitation (Ex: Frais internet)
const opex = ohada.expense.record({
  expenseAccountCode: '6241',
  amountHT: 100000,
  vatAmount: 16000,
  walletType: 'BANK',
  description: 'Paiement abonnement Internet'
});

// Achat d'une immobilisation (Ex: Ordinateur)
const capex = ohada.capex.record({
  assetAccountCode: '2441',
  amountHT: 500000,
  vatAmount: 80000,
  walletType: 'BANK',
  description: 'Achat MacBook'
});

3. Achats Fournisseurs (Purchases)

Cycle d'achat : de la constatation au règlement.

// Facture fournisseur
const achat = ohada.purchase.constate({
  amountHT: 100000,
  freightAmount: 5000, // Frais de transport
  vatAmount: 16800,
  description: 'Achat de marchandises'
});

// Réception en stock
const entreeStock = ohada.purchase.receive({
  inventoryValue: 105000
});

// Règlement du fournisseur
const reglement = ohada.purchase.pay({
  payments: [{ amount: 121800, walletType: 'BANK' }]
});

4. Virements Internes (Transfers)

Mouvement de fonds entre vos comptes avec traçabilité (Compte 585).

// Renflouer la caisse depuis la banque
const virement = ohada.transfer.execute({
  amount: 200000,
  fromWalletType: 'BANK',
  toWalletType: 'CASH'
});

5. Inventaire & Stocks (Inventory)

Ajustements, dépréciations et pertes de stock.

// Enregistrement d'un vol ou d'une casse
const perte = ohada.inventory.recordLoss({
  amount: 45000,
  description: 'Vol de stock'
});

// Dotation aux dépréciations
const depreciation = ohada.inventory.depreciate({
  amount: 15000,
  description: 'Obsolescence'
});

6. Financement (Emprunts)

Gestion des prêts reçus et de leurs remboursements.

// Réception d'un emprunt
const pret = ohada.financing.receiveLoan({
  amount: 10000000,
  walletType: 'BANK'
});

// Remboursement (Principal + Intérêts)
const remboursement = ohada.financing.repayLoan({
  principalAmount: 500000,
  interestAmount: 40000,
  walletType: 'BANK'
});

7. Onboarding & Soldes Initiaux

Injection des soldes d'ouverture au lancement du système. Calcule automatiquement le Capital (1011).

const ouverture = ohada.onboarding.generateOpeningBalances({
  assets: {
    '2111': 20000000, // Terrains
    '5211': 5000000   // Banque
  },
  liabilities: {
    '162': 1000000    // Emprunts
  }
});

Cas Pratiques (Use Cases)

Voici quelques exemples montrant comment combiner les différentes façades pour gérer des scénarios métier réels du quotidien d'une PME.

Scénario 1 : Vente au comptant avec paiement par Mobile Money

Un client achète des marchandises pour 100 000 FC HT (TVA 16%) et paie immédiatement via M-Pesa. Les marchandises sortent immédiatement du stock (valeur d'achat estimée à 70 000 FC).

// 1. Facturation
ohada.sale.constate({
  saleId: 'FAC-001',
  items: [{ name: 'Marchandises', quantity: 1, price: 100000 }] // Total TTC: 116 000
});

// 2. Paiement M-Pesa
ohada.sale.pay({
  saleId: 'FAC-001',
  payments: [{ amount: 116000, walletType: 'MOBILE' }]
});

// 3. Sortie de stock
ohada.sale.deliver({
  saleId: 'FAC-001',
  inventoryValue: 70000
});

Scénario 2 : Achat de fournitures de bureau payé par la Petite Caisse

L'entreprise achète du papier et des stylos pour 50 000 FC HT (TVA 16%) et règle directement le fournisseur en espèces depuis la caisse.

// 1. Constatation de la dépense
ohada.expense.record({
  expenseAccountCode: '6044', // Achats de fournitures de bureau
  amountHT: 50000,
  vatAmount: 8000,
  walletType: 'CASH', // Paiement immédiat par la petite caisse
  description: 'Achat RAM de papier'
});
// La librairie génère automatiquement :
// - Débit 6044 (50 000)
// - Débit 445 (8 000)
// - Crédit 4011 (58 000)
// - Débit 4011 (58 000)
// - Crédit 5711 (58 000)

Scénario 3 : Renflouement de la Petite Caisse depuis la Banque

La caisse est presque vide. Le comptable effectue un retrait de 500 000 FC à la banque pour alimenter la petite caisse de l'entreprise.

ohada.transfer.execute({
  amount: 500000,
  fromWalletType: 'BANK',
  toWalletType: 'CASH'
});
// La librairie génère automatiquement les écritures transitant par le compte 585 (Virements de fonds) pour une traçabilité parfaite.

Scénario 4 : Perte de stock suite à une inondation

Suite à un dégât des eaux, des marchandises d'une valeur d'achat de 250 000 FC sont déclarées irrécupérables.

ohada.inventory.recordLoss({
  amount: 250000,
  description: 'Perte de marchandises suite inondation'
});
// - Débit 6031 (Variation des stocks - Charge)
// - Crédit 311 (Stock de marchandises)

Intégration Base de données (Firestore / SQL)

Chaque façade retourne une instance de AccountingTransaction. Appelez la méthode toFlatEntries() pour obtenir un tableau plat facilement insérable dans n'importe quelle base de données (ex: collections Firestore, tables SQL).

const facture = ohada.sale.constate({ /* ... */ });

// Récupération au format plat :
const entries = facture.toFlatEntries();
/*
[
  { ohadaAccountCode: '4111', typeMouvement: 'DEBIT', amount: 116000, label: '...' },
  { ohadaAccountCode: '7011', typeMouvement: 'CREDIT', amount: 100000, label: '...' },
  { ohadaAccountCode: '4431', typeMouvement: 'CREDIT', amount: 16000, label: '...' }
]
*/

// Exemple Firestore :
const batch = db.batch();
entries.forEach(entry => {
  const docRef = db.collection(`companies/C1/accountingEntries`).doc();
  batch.set(docRef, {
    ...entry,
    transactionId: facture.id,
    occurredAt: facture.occurredAt
  });
});
await batch.commit();

Documentation

• Site de documentation : https://Drc-Mind.github.io/ohda-lib/

License

ISC