🥮 mooncakes.io
    Sign in

    moonbit-accounting

    Generate financial statements from normalized accounting entries.

    accounting
    financial-report
    ledger
    moonbit
    Download zip
    Author
    Version
    0.3.0
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    23

    No dependencies

    #moonbit-accounting

    Deterministic financial reporting for MoonBit applications. It accepts normalized entries and explicit mappings, then produces stable reports.

    ///|
    test "readme example" {
      let mappings = [AccountMapping::new("sales", "Revenue", IncomeStatement)]
      let entries = [Entry::new("sales", "2026-Q2", 0, 1200)]
      let report = generate(IncomeStatement, "2026-Q2", entries, mappings)
      assert_eq(report.total, 1200)
      assert_eq(report.line("Revenue"), Some(1200))
    }

    Amounts are integer minor units. Reports can be rendered as CSV, JSON, Markdown, or HTML. Validation, comparison periods, dimensions, budgets, consolidation, ratios, trends, anomaly detection, and account catalogues are available from the same dependency-free package, together with CSV import, journal validation, trial balances, reconciliation, and report packs.

    moon check --target all --deny-warn
moon test --target all
moon run cmd/main

    See README.md for architecture, CLI, benchmark, CI, and license details.

    Amount

    source
    type Amount = Int

    A signed amount in the smallest currency unit (for example, cents).

    AccountClass

    source
    pub enum AccountClass {
      Asset
      Liability
      Equity
      Revenue
      Expense
    } derive(Eq, 
    Debug    )

    A compact standard chart helps applications bootstrap mappings.

    AccountDefinition

    source
    pub struct AccountDefinition {
      code : String
      name : String
      class : AccountClass
      normal_debit : Bool
    } derive(Eq, 
    Debug    )

    AccountDefinition::new

    source
    fn AccountDefinition::new(code : String, name : String, class : AccountClass, normal_debit : Bool) -> AccountDefinition

    AccountMapping

    source
    pub struct AccountMapping {
      account : String
      line : String
      kind : StatementKind
      factor : Int
    } derive(Eq, 
    Debug    )

    AccountMapping::new

    source
    fn AccountMapping::new(account : String, line : String, kind : StatementKind, factor? : Int) -> AccountMapping

    AgingBucket

    source
    pub struct AgingBucket {
      label : String
      amount : Int
      entries : Int
    } derive(Eq, 
    Debug    )

    Receivable aging uses quarter periods and integer minor units.

    Anomaly

    source
    pub struct Anomaly {
      kind : AnomalyKind
      account : String
      period : String
      amount : Int
      detail : String
    } derive(Eq, 
    Debug    )

    AnomalyKind

    source
    pub(all) enum AnomalyKind {
      LargeDebit
      LargeCredit
      UnmappedAccount
      InvalidPeriod
      DuplicateEntry
    } derive(Eq, 
    Debug    )

    BatchValidation

    source
    pub enum BatchValidation {
      BalancedBatch
      UnbalancedBatch(Int)
      EmptyBatch
    } derive(Eq, 
    Debug    )

    BenchmarkResult

    source
    pub struct BenchmarkResult {
      entries : Int
      mappings : Int
      lines : Int
      total : Int
      elapsed_ms : Int
    } derive(Eq, 
    Debug    )

    Deterministic fixture generation keeps benchmark comparisons meaningful.

    BudgetLine

    source
    pub struct BudgetLine {
      line : String
      amount : Int
    } derive(Eq, 
    Debug    )

    BudgetLine::new

    source
    fn BudgetLine::new(line : String, amount : Int) -> BudgetLine

    BudgetVariance

    source
    pub struct BudgetVariance {
      line : String
      budget : Int
      actual : Int
      variance : Int
      favorable : Bool
    } derive(Eq, 
    Debug    )

    CashFlowKind

    source
    pub(all) enum CashFlowKind {
      Operating
      Investing
      Financing
      Unclassified
    } derive(Eq, 
    Debug    )

    CashFlowLine

    source
    pub struct CashFlowLine {
      kind : CashFlowKind
      amount : Int
      entries : Int
    } derive(Eq, 
    Debug    )

    CashFlowRule

    source
    pub struct CashFlowRule {
      account : String
      kind : CashFlowKind
      factor : Int
    } derive(Eq, 
    Debug    )

    CashFlowRule::new

    source
    fn CashFlowRule::new(account : String, kind : CashFlowKind, factor? : Int) -> CashFlowRule

    CashRecord

    source
    pub struct CashRecord {
      reference : String
      amount : Int
    } derive(Eq, 
    Debug    )

    Reconciliation compares normalized balances with an external statement.

    CashRecord::new

    source
    fn CashRecord::new(reference : String, amount : Int) -> CashRecord

    CsvImportResult

    source
    pub struct CsvImportResult {
      entries : Array[Entry]
      errors : Array[String]
    } derive(Eq, 
    Debug    )

    A small dependency-free importer for normalized CSV exchange files.

    Currency

    source
    pub struct Currency {
      code : String
      name : String
      minor_units : Int
    } derive(Eq, 
    Debug    )

    ISO-like currency metadata used by callers that need explicit scale.

    Currency::new

    source
    fn Currency::new(code : String, name : String, minor_units : Int) -> Currency

    DatasetIssue

    source
    pub enum DatasetIssue {
      InvalidEntry(Int, EntryValidation)
      UnmappedEntry(Int, String)
      DuplicateEntry(Int, Int)
    } derive(Eq, 
    Debug    )

    Dataset validation combines structural and mapping checks for importers.

    DimensionLine

    source
    pub struct DimensionLine {
      dimension : String
      amount : Int
      entries : Int
    } derive(Eq, 
    Debug    )

    DimensionTotal

    source
    pub struct DimensionTotal {
      dimension : String
      amount : Int
      entries : Int
    } derive(Eq, 
    Debug    )

    Deterministic scalar metrics for dashboards and reports.

    EliminationRule

    source
    pub struct EliminationRule {
      debit_account : String
      credit_account : String
    } derive(Eq, 
    Debug    )

    A rule identifies reciprocal intercompany balances to remove.

    EliminationRule::new

    source
    fn EliminationRule::new(debit_account : String, credit_account : String) -> EliminationRule

    Entity

    source
    pub struct Entity {
      name : String
      entries : Array[Entry]
    } derive(Eq, 
    Debug    )

    Entity::new

    source
    fn Entity::new(name : String, entries : Array[Entry]) -> Entity

    Entry

    source
    pub struct Entry {
      account : String
      period : String
      debit : Int
      credit : Int
      cash : Bool
      dimension : String
    } derive(Eq, 
    Debug    )

    Entry::new

    source
    fn Entry::new(account : String, period : String, debit : Int, credit : Int, cash? : Bool) -> Entry

    Entry::new_with_dimension

    source
    fn Entry::new_with_dimension(account : String, period : String, debit : Int, credit : Int, dimension : String, cash? : Bool) -> Entry

    EntryValidation

    source
    pub enum EntryValidation {
      ValidEntry
      EmptyAccount
      InvalidEntryPeriod(String)
      NegativeAmount
      UnbalancedEntry
    } derive(Eq, 
    Debug    )

    Validation errors are explicit so importers can reject bad source data.

    ExchangeRate

    source
    pub struct ExchangeRate {
      from : String
      to : String
      numerator : Int
      denominator : Int
    } derive(Eq, 
    Debug    )

    Explicit exchange rates keep conversion policy outside report generation.

    ExchangeRate::new

    source
    fn ExchangeRate::new(from : String, to : String, numerator : Int, denominator : Int) -> ExchangeRate

    ForecastPoint

    source
    pub struct ForecastPoint {
      period : Int
      amount : Int
      source_average : Int
    } derive(Eq, 
    Debug    )

    Forecasts are intentionally transparent run-rate projections.

    HealthScore

    source
    pub struct HealthScore {
      liquidity : Int
      profitability : Int
      leverage : Int
      overall : Int
    } derive(Eq, 
    Debug    )

    JournalEntry

    source
    pub struct JournalEntry {
      id : String
      period : String
      description : String
      lines : Array[JournalLine]
    } derive(Eq, 
    Debug    )

    JournalEntry::add_line

    source
    fn JournalEntry::add_line(self : JournalEntry, line : JournalLine) -> Unit

    JournalEntry::new

    source
    fn JournalEntry::new(id : String, period : String, description : String) -> JournalEntry

    JournalLine

    source
    pub struct JournalLine {
      account : String
      debit : Int
      credit : Int
    } derive(Eq, 
    Debug    )

    Journal entries preserve source-document boundaries before normalization.

    JournalLine::new

    source
    fn JournalLine::new(account : String, debit : Int, credit : Int) -> JournalLine

    JournalValidation

    source
    pub enum JournalValidation {
      BalancedJournal
      EmptyJournal
      InvalidJournalPeriod
      UnbalancedJournal(Int)
      InvalidJournalLine(String)
    } derive(Eq, 
    Debug    )

    LineItem

    source
    pub struct LineItem {
      line : String
      amount : Int
      entries : Int
    } derive(Eq, 
    Debug    )

    MappingValidation

    source
    pub enum MappingValidation {
      ValidMappings
      DuplicateAccount(String)
    } derive(Eq, 
    Debug    )

    PeriodResult

    source
    pub enum PeriodResult {
      ValidPeriod(String)
      InvalidPeriod(String)
    } derive(Eq, 
    Debug    )

    RatioSet

    source
    pub struct RatioSet {
      current_ratio : Int?
      quick_ratio : Int?
      gross_margin : Int?
      operating_margin : Int?
      debt_ratio : Int?
      return_on_assets : Int?
    } derive(Eq, 
    Debug    )

    Financial analysis primitives operate on integer minor units.

    ReconciliationResult

    source
    pub struct ReconciliationResult {
      matched : Int
      outstanding_ledger : Int
      outstanding_statement : Int
      ledger_total : Int
      statement_total : Int
      difference : Int
    } derive(Eq, 
    Debug    )

    Report

    source
    pub struct Report {
      kind : StatementKind
      period : String
      lines : Array[LineItem]
      total : Int
    } derive(Eq, 
    Debug    )

    Report::line

    source
    fn Report::line(self : Report, name : String) -> Int?

    Report::to_csv

    source
    fn Report::to_csv(self : Report) -> String

    Report::to_html

    source
    fn Report::to_html(self : Report) -> String

    Report::to_json

    source
    fn Report::to_json(self : Report) -> String

    Report::to_markdown

    source
    fn Report::to_markdown(self : Report) -> String

    ReportComparison

    source
    pub struct ReportComparison {
      current : Report
      prior : Report
      total_variance : Int
    } derive(Eq, 
    Debug    )

    ReportPack

    source
    pub struct ReportPack {
      period : String
      reports : Array[Report]
    } derive(Eq, 
    Debug    )

    A report pack groups the statements normally shown together.

    ReportPack::to_markdown

    source
    fn ReportPack::to_markdown(self : ReportPack) -> String

    StatementKind

    source
    pub(all) enum StatementKind {
      BalanceSheet
      IncomeStatement
      CashFlowStatement
      Management
    } derive(Eq, 
    Debug    )

    TaxRule

    source
    pub struct TaxRule {
      account : String
      treatment : TaxTreatment
    } derive(Eq, 
    Debug    )

    TaxRule::new

    source
    fn TaxRule::new(account : String, treatment : TaxTreatment) -> TaxRule

    TaxSummary

    source
    pub struct TaxSummary {
      period : String
      revenue : Int
      deductions : Int
      base : Int
      rate : Int
      tax : Int
    } derive(Eq, 
    Debug    )

    TaxTreatment

    source
    pub(all) enum TaxTreatment {
      TaxableRevenue
      DeductibleExpense
      Exempt
    } derive(Eq, 
    Debug    )

    Tax rules express how normalized accounts contribute to a tax base.

    TrendPoint

    source
    pub struct TrendPoint {
      period : String
      amount : Int
      change : Int
      direction : String
    } derive(Eq, 
    Debug    )

    TrialBalance

    source
    pub struct TrialBalance {
      lines : Array[TrialBalanceLine]
      total_debit : Int
      total_credit : Int
      balanced : Bool
    } derive(Eq, 
    Debug    )

    TrialBalanceLine

    source
    pub struct TrialBalanceLine {
      account : String
      debit : Int
      credit : Int
      balance : Int
    } derive(Eq, 
    Debug    )

    Variance

    source
    pub struct Variance {
      line : String
      current : Int
      prior : Int
      absolute : Int
      percent : Int?
    } derive(Eq, 
    Debug    )

    account_balance

    source
    fn account_balance(entries : Array[Entry], account : String, period? : String) -> Int

    age_receivables

    source
    fn age_receivables(entries : Array[Entry], account : String, as_of : String) -> Array[AgingBucket]

    analyze_ratios

    source
    fn analyze_ratios(assets : Int, current_assets : Int, inventory : Int, liabilities : Int, revenue : Int, cost : Int, operating_expense : Int, net_income : Int) -> RatioSet

    benchmark_fixture

    source
    fn benchmark_fixture(size : Int) -> (Array[Entry], Array[AccountMapping])

    benchmark_summary

    source
    fn benchmark_summary(result : BenchmarkResult) -> String

    budget_variance

    source
    fn budget_variance(budget : Array[BudgetLine], actual : Array[BudgetLine]) -> Array[BudgetVariance]

    build_report_pack

    source
    fn build_report_pack(period : String, entries : Array[Entry], mappings : Array[AccountMapping]) -> ReportPack

    burn_rate

    source
    fn burn_rate(expenses : Array[Int], periods : Int) -> Int?

    cash_flow

    source
    fn cash_flow(period : String, entries : Array[Entry], rules : Array[CashFlowRule]) -> Array[CashFlowLine]

    compare_period

    source
    fn compare_period(left : String, right : String) -> Int

    compare_reports

    source
    fn compare_reports(kind : StatementKind, current_period : String, prior_period : String, entries : Array[Entry], mappings : Array[AccountMapping]) -> ReportComparison

    compound_change

    source
    fn compound_change(first : Int, last : Int, periods : Int) -> Int?

    consolidate

    source
    fn consolidate(period : String, entities : Array[Entity], mappings : Array[AccountMapping]) -> Report

    consolidate_with_eliminations

    source
    fn consolidate_with_eliminations(period : String, entities : Array[Entity], mappings : Array[AccountMapping], rules : Array[EliminationRule]) -> Report

    convert_amount

    source
    fn convert_amount(amount : Int, from : Currency?, to : Currency?, rate : ExchangeRate) -> Int?

    convert_entries

    source
    fn convert_entries(entries : Array[Entry], from : Currency?, to : Currency?, rate : ExchangeRate) -> Array[Entry]

    convert_entry

    source
    fn convert_entry(entry : Entry, from : Currency?, to : Currency?, rate : ExchangeRate) -> Entry?

    convert_minor

    source
    fn convert_minor(amount : Int, from : Currency, to : Currency, rate_numerator : Int, rate_denominator : Int) -> Int?

    currency

    source
    fn currency(code : String) -> Currency?

    currency_codes

    source
    fn currency_codes() -> Array[String]

    detect_invalid_periods

    source
    fn detect_invalid_periods(entries : Array[Entry]) -> Array[Anomaly]

    detect_large_entries

    source
    fn detect_large_entries(entries : Array[Entry], threshold : Int) -> Array[Anomaly]

    detect_unmapped

    source
    fn detect_unmapped(entries : Array[Entry], mappings : Array[AccountMapping]) -> Array[Anomaly]

    entries_for_period

    source
    fn entries_for_period(entries : Array[Entry], period : String) -> Array[Entry]

    escape_html

    source
    fn escape_html(value : String) -> String

    Escape text for HTML contexts without relying on a runtime or DOM.

    find_trial_line

    source
    fn find_trial_line(balance : TrialBalance, account : String) -> TrialBalanceLine?

    flatten_journal

    source
    fn flatten_journal(journal : JournalEntry) -> Array[Entry]

    forecast_linear

    source
    fn forecast_linear(history : Array[Int], periods : Int) -> Array[ForecastPoint]

    forecast_run_rate

    source
    fn forecast_run_rate(history : Array[Int], periods : Int) -> Array[ForecastPoint]

    forecast_total

    source
    fn forecast_total(points : Array[ForecastPoint]) -> Int

    generate

    source
    fn generate(kind : StatementKind, period : String, entries : Array[Entry], mappings : Array[AccountMapping], comparison? : String) -> Report

    generate_by_dimension

    source
    fn generate_by_dimension(kind : StatementKind, period : String, entries : Array[Entry], mappings : Array[AccountMapping]) -> Array[DimensionLine]

    generate_many

    source
    fn generate_many(kind : StatementKind, periods : Array[String], entries : Array[Entry], mappings : Array[AccountMapping]) -> Array[Report]

    Build a stable report for each requested period.

    group_by_dimension

    source
    fn group_by_dimension(entries : Array[Entry], period : String) -> Array[DimensionTotal]

    growth_percent

    source
    fn growth_percent(previous : Int, current : Int) -> Int?

    health_score

    source
    fn health_score(ratios : RatioSet) -> HealthScore

    import_entries_csv

    source
    fn import_entries_csv(csv : String) -> CsvImportResult

    journal_totals

    source
    fn journal_totals(journal : JournalEntry) -> (Int, Int)

    latest_report

    source
    fn latest_report(reports : Array[Report]) -> Report?

    lowest_report

    source
    fn lowest_report(reports : Array[Report]) -> Report?

    moving_average

    source
    fn moving_average(values : Array[Int], window : Int) -> Array[Int]

    net_margin

    source
    fn net_margin(revenue : Int, expenses : Int) -> Int?

    period_delta

    source
    fn period_delta(reports : Array[Report]) -> Array[Int]

    period_distance

    source
    fn period_distance(older : String, newer : String) -> Int

    period_totals

    source
    fn period_totals(reports : Array[Report]) -> Array[(String, Int)]

    reconcile_cash

    source
    fn reconcile_cash(ledger : Array[CashRecord], statement : Array[CashRecord]) -> ReconciliationResult

    reconciliation_is_balanced

    source
    fn reconciliation_is_balanced(result : ReconciliationResult) -> Bool

    render_variances

    source
    fn render_variances(variances : Array[Variance]) -> String

    report_document

    source
    fn report_document(report : Report, title : String) -> String

    report_variances

    source
    fn report_variances(current : Report, prior : Report) -> Array[Variance]

    run_benchmark

    source
    fn run_benchmark(size : Int) -> BenchmarkResult

    safe_ratio

    source
    fn safe_ratio(numerator : Int, denominator : Int) -> Int?

    standard_account

    source
    fn standard_account(code : String) -> AccountDefinition?

    standard_chart

    source
    fn standard_chart() -> Array[AccountDefinition]

    tax_amount

    source
    fn tax_amount(base : Int, rate : Int) -> Int

    tax_summary

    source
    fn tax_summary(entries : Array[Entry], period : String, rules : Array[TaxRule], rate~ : Int) -> TaxSummary

    trend_points

    source
    fn trend_points(values : Array[(String, Int)]) -> Array[TrendPoint]

    trial_balance

    source
    fn trial_balance(entries : Array[Entry], period? : String) -> TrialBalance

    valid_entries

    source
    fn valid_entries(entries : Array[Entry], mappings : Array[AccountMapping]) -> Array[Entry]

    validate_batch

    source
    fn validate_batch(entries : Array[Entry]) -> BatchValidation

    validate_dataset

    source
    fn validate_dataset(entries : Array[Entry], mappings : Array[AccountMapping]) -> Array[DatasetIssue]

    validate_entry

    source
    fn validate_entry(entry : Entry) -> EntryValidation

    validate_journal

    source
    fn validate_journal(journal : JournalEntry) -> JournalValidation

    validate_mappings

    source
    fn validate_mappings(mappings : Array[AccountMapping]) -> MappingValidation

    validate_period

    source
    fn validate_period(period : String) -> PeriodResult

    variance

    source
    fn variance(line : String, current : Int, prior : Int) -> Variance

    weighted_average

    source
    fn weighted_average(values : Array[(Int, Int)]) -> Int?

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io