@fin.cx/skr 1.0.0

package/dist_ts/index.d.ts

@@ -0,0 +1,10 @@
+export * from './skr.types.js';
+export * from './skr.classes.account.js';
+export * from './skr.classes.transaction.js';
+export * from './skr.classes.journalentry.js';
+export * from './skr.classes.chartofaccounts.js';
+export * from './skr.classes.ledger.js';
+export * from './skr.classes.reports.js';
+export * from './skr.api.js';
+export * from './skr03.data.js';
+export * from './skr04.data.js';

package/dist_ts/index.js

@@ -0,0 +1,11 @@
+export * from './skr.types.js';
+export * from './skr.classes.account.js';
+export * from './skr.classes.transaction.js';
+export * from './skr.classes.journalentry.js';
+export * from './skr.classes.chartofaccounts.js';
+export * from './skr.classes.ledger.js';
+export * from './skr.classes.reports.js';
+export * from './skr.api.js';
+export * from './skr03.data.js';
+export * from './skr04.data.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,5 @@
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartunique from '@push.rocks/smartunique';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartlog from '@push.rocks/smartlog';
+export { smartdata, smartunique, smarttime, smartlog };

package/dist_ts/plugins.js

@@ -0,0 +1,7 @@
+// @push.rocks scope
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartunique from '@push.rocks/smartunique';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartlog from '@push.rocks/smartlog';
+export { smartdata, smartunique, smarttime, smartlog };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFFakQsT0FBTyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLFFBQVEsRUFBRSxDQUFDIn0=

package/dist_ts/skr.api.d.ts

@@ -0,0 +1,181 @@
+import { Account } from './skr.classes.account.js';
+import { Transaction } from './skr.classes.transaction.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import type { IDatabaseConfig, TSKRType, IAccountData, IAccountFilter, ITransactionData, ITransactionFilter, IJournalEntry, IReportParams, ITrialBalanceReport, IIncomeStatement, IBalanceSheet } from './skr.types.js';
+/**
+ * Main API class for SKR accounting operations
+ */
+export declare class SkrApi {
+    private config;
+    private chartOfAccounts;
+    private ledger;
+    private reports;
+    private logger;
+    private initialized;
+    private currentSKRType;
+    constructor(config: IDatabaseConfig);
+    /**
+     * Initialize the API with specified SKR type
+     */
+    initialize(skrType: TSKRType): Promise<void>;
+    /**
+     * Ensure API is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Create a new account
+     */
+    createAccount(accountData: Partial<IAccountData>): Promise<Account>;
+    /**
+     * Get account by number
+     */
+    getAccount(accountNumber: string): Promise<Account | null>;
+    /**
+     * Update an account
+     */
+    updateAccount(accountNumber: string, updates: Partial<IAccountData>): Promise<Account>;
+    /**
+     * Delete an account
+     */
+    deleteAccount(accountNumber: string): Promise<void>;
+    /**
+     * List accounts with optional filter
+     */
+    listAccounts(filter?: IAccountFilter): Promise<Account[]>;
+    /**
+     * Search accounts by term
+     */
+    searchAccounts(searchTerm: string): Promise<Account[]>;
+    /**
+     * Get accounts by class
+     */
+    getAccountsByClass(accountClass: number): Promise<Account[]>;
+    /**
+     * Get accounts by type
+     */
+    getAccountsByType(accountType: IAccountData['accountType']): Promise<Account[]>;
+    /**
+     * Post a simple transaction
+     */
+    postTransaction(transactionData: ITransactionData): Promise<Transaction>;
+    /**
+     * Post a journal entry
+     */
+    postJournalEntry(journalData: IJournalEntry): Promise<JournalEntry>;
+    /**
+     * Get transaction by ID
+     */
+    getTransaction(transactionId: string): Promise<Transaction | null>;
+    /**
+     * List transactions with optional filter
+     */
+    listTransactions(filter?: ITransactionFilter): Promise<Transaction[]>;
+    /**
+     * Get transactions for specific account
+     */
+    getAccountTransactions(accountNumber: string): Promise<Transaction[]>;
+    /**
+     * Reverse a transaction
+     */
+    reverseTransaction(transactionId: string): Promise<Transaction>;
+    /**
+     * Reverse a journal entry
+     */
+    reverseJournalEntry(journalId: string): Promise<JournalEntry>;
+    /**
+     * Generate trial balance
+     */
+    generateTrialBalance(params?: IReportParams): Promise<ITrialBalanceReport>;
+    /**
+     * Generate income statement
+     */
+    generateIncomeStatement(params?: IReportParams): Promise<IIncomeStatement>;
+    /**
+     * Generate balance sheet
+     */
+    generateBalanceSheet(params?: IReportParams): Promise<IBalanceSheet>;
+    /**
+     * Generate general ledger
+     */
+    generateGeneralLedger(params?: IReportParams): Promise<any>;
+    /**
+     * Generate cash flow statement
+     */
+    generateCashFlowStatement(params?: IReportParams): Promise<any>;
+    /**
+     * Export report to CSV
+     */
+    exportReportToCSV(reportType: 'trial_balance' | 'income_statement' | 'balance_sheet', params?: IReportParams): Promise<string>;
+    /**
+     * Export to DATEV format
+     */
+    exportToDATEV(params?: IReportParams): Promise<string>;
+    /**
+     * Close accounting period
+     */
+    closePeriod(period: string, closingAccountNumber?: string): Promise<JournalEntry[]>;
+    /**
+     * Get account balance
+     */
+    getAccountBalance(accountNumber: string, asOfDate?: Date): Promise<any>;
+    /**
+     * Recalculate all account balances
+     */
+    recalculateBalances(): Promise<void>;
+    /**
+     * Import accounts from CSV
+     */
+    importAccountsFromCSV(csvContent: string): Promise<number>;
+    /**
+     * Export accounts to CSV
+     */
+    exportAccountsToCSV(): Promise<string>;
+    /**
+     * Get current SKR type
+     */
+    getSKRType(): TSKRType | null;
+    /**
+     * Get account class description
+     */
+    getAccountClassDescription(accountClass: number): string;
+    /**
+     * Validate double-entry rules
+     */
+    validateDoubleEntry(debitAmount: number, creditAmount: number): boolean;
+    /**
+     * Get unbalanced transactions (for audit)
+     */
+    getUnbalancedTransactions(): Promise<Transaction[]>;
+    /**
+     * Close the API and database connection
+     */
+    close(): Promise<void>;
+    /**
+     * Post multiple transactions
+     */
+    postBatchTransactions(transactions: ITransactionData[]): Promise<Transaction[]>;
+    /**
+     * Create multiple accounts
+     */
+    createBatchAccounts(accounts: IAccountData[]): Promise<Account[]>;
+    /**
+     * Get paginated accounts
+     */
+    getAccountsPaginated(page?: number, pageSize?: number, filter?: IAccountFilter): Promise<{
+        data: Account[];
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+    }>;
+    /**
+     * Get paginated transactions
+     */
+    getTransactionsPaginated(page?: number, pageSize?: number, filter?: ITransactionFilter): Promise<{
+        data: Transaction[];
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+    }>;
+}

package/dist_ts/skr.api.js

@@ -0,0 +1,402 @@
+import * as plugins from './plugins.js';
+import { ChartOfAccounts } from './skr.classes.chartofaccounts.js';
+import { Ledger } from './skr.classes.ledger.js';
+import { Reports } from './skr.classes.reports.js';
+import { Account } from './skr.classes.account.js';
+import { Transaction } from './skr.classes.transaction.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+/**
+ * Main API class for SKR accounting operations
+ */
+export class SkrApi {
+    constructor(config) {
+        this.config = config;
+        this.ledger = null;
+        this.reports = null;
+        this.initialized = false;
+        this.currentSKRType = null;
+        this.chartOfAccounts = new ChartOfAccounts(config);
+        this.logger = new plugins.smartlog.Smartlog({
+            logContext: {
+                company: 'fin.cx',
+                companyunit: 'skr',
+                containerName: 'SkrApi',
+                environment: 'local',
+                runtime: 'node',
+                zone: 'local',
+            },
+        });
+    }
+    /**
+     * Initialize the API with specified SKR type
+     */
+    async initialize(skrType) {
+        this.logger.log('info', `Initializing SKR API with ${skrType}`);
+        // Initialize chart of accounts
+        if (skrType === 'SKR03') {
+            await this.chartOfAccounts.initializeSKR03();
+        }
+        else if (skrType === 'SKR04') {
+            await this.chartOfAccounts.initializeSKR04();
+        }
+        else {
+            throw new Error(`Invalid SKR type: ${skrType}`);
+        }
+        this.currentSKRType = skrType;
+        this.ledger = new Ledger(skrType);
+        this.reports = new Reports(skrType);
+        this.initialized = true;
+        this.logger.log('info', 'SKR API initialized successfully');
+    }
+    /**
+     * Ensure API is initialized
+     */
+    ensureInitialized() {
+        if (!this.initialized || !this.currentSKRType) {
+            throw new Error('API not initialized. Call initialize() first.');
+        }
+    }
+    // ========== Account Management ==========
+    /**
+     * Create a new account
+     */
+    async createAccount(accountData) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.createCustomAccount(accountData);
+    }
+    /**
+     * Get account by number
+     */
+    async getAccount(accountNumber) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getAccountByNumber(accountNumber);
+    }
+    /**
+     * Update an account
+     */
+    async updateAccount(accountNumber, updates) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.updateAccount(accountNumber, updates);
+    }
+    /**
+     * Delete an account
+     */
+    async deleteAccount(accountNumber) {
+        this.ensureInitialized();
+        await this.chartOfAccounts.deleteAccount(accountNumber);
+    }
+    /**
+     * List accounts with optional filter
+     */
+    async listAccounts(filter) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getAllAccounts(filter);
+    }
+    /**
+     * Search accounts by term
+     */
+    async searchAccounts(searchTerm) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.searchAccounts(searchTerm);
+    }
+    /**
+     * Get accounts by class
+     */
+    async getAccountsByClass(accountClass) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getAccountsByClass(accountClass);
+    }
+    /**
+     * Get accounts by type
+     */
+    async getAccountsByType(accountType) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getAccountsByType(accountType);
+    }
+    // ========== Transaction Management ==========
+    /**
+     * Post a simple transaction
+     */
+    async postTransaction(transactionData) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.postTransaction(transactionData);
+    }
+    /**
+     * Post a journal entry
+     */
+    async postJournalEntry(journalData) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.postJournalEntry(journalData);
+    }
+    /**
+     * Get transaction by ID
+     */
+    async getTransaction(transactionId) {
+        this.ensureInitialized();
+        return await Transaction.getTransactionById(transactionId);
+    }
+    /**
+     * List transactions with optional filter
+     */
+    async listTransactions(filter) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getTransactions(filter);
+    }
+    /**
+     * Get transactions for specific account
+     */
+    async getAccountTransactions(accountNumber) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.getAccountTransactions(accountNumber);
+    }
+    /**
+     * Reverse a transaction
+     */
+    async reverseTransaction(transactionId) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.reverseTransaction(transactionId);
+    }
+    /**
+     * Reverse a journal entry
+     */
+    async reverseJournalEntry(journalId) {
+        this.ensureInitialized();
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        return await this.ledger.reverseJournalEntry(journalId);
+    }
+    // ========== Reporting ==========
+    /**
+     * Generate trial balance
+     */
+    async generateTrialBalance(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.getTrialBalance(params);
+    }
+    /**
+     * Generate income statement
+     */
+    async generateIncomeStatement(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.getIncomeStatement(params);
+    }
+    /**
+     * Generate balance sheet
+     */
+    async generateBalanceSheet(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.getBalanceSheet(params);
+    }
+    /**
+     * Generate general ledger
+     */
+    async generateGeneralLedger(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.getGeneralLedger(params);
+    }
+    /**
+     * Generate cash flow statement
+     */
+    async generateCashFlowStatement(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.getCashFlowStatement(params);
+    }
+    /**
+     * Export report to CSV
+     */
+    async exportReportToCSV(reportType, params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.exportToCSV(reportType, params);
+    }
+    /**
+     * Export to DATEV format
+     */
+    async exportToDATEV(params) {
+        this.ensureInitialized();
+        if (!this.reports)
+            throw new Error('Reports not initialized');
+        return await this.reports.exportToDATEV(params);
+    }
+    // ========== Period Management ==========
+    /**
+     * Close accounting period
+     */
+    async closePeriod(period, closingAccountNumber) {
+        this.ensureInitialized();
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        return await this.ledger.closeAccountingPeriod(period, closingAccountNumber);
+    }
+    /**
+     * Get account balance
+     */
+    async getAccountBalance(accountNumber, asOfDate) {
+        this.ensureInitialized();
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        return await this.ledger.getAccountBalance(accountNumber, asOfDate);
+    }
+    /**
+     * Recalculate all account balances
+     */
+    async recalculateBalances() {
+        this.ensureInitialized();
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        await this.ledger.recalculateAllBalances();
+    }
+    // ========== Import/Export ==========
+    /**
+     * Import accounts from CSV
+     */
+    async importAccountsFromCSV(csvContent) {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.importAccountsFromCSV(csvContent);
+    }
+    /**
+     * Export accounts to CSV
+     */
+    async exportAccountsToCSV() {
+        this.ensureInitialized();
+        return await this.chartOfAccounts.exportAccountsToCSV();
+    }
+    // ========== Utility Methods ==========
+    /**
+     * Get current SKR type
+     */
+    getSKRType() {
+        return this.currentSKRType;
+    }
+    /**
+     * Get account class description
+     */
+    getAccountClassDescription(accountClass) {
+        this.ensureInitialized();
+        return this.chartOfAccounts.getAccountClassDescription(accountClass);
+    }
+    /**
+     * Validate double-entry rules
+     */
+    validateDoubleEntry(debitAmount, creditAmount) {
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        return this.ledger.validateDoubleEntry(debitAmount, creditAmount);
+    }
+    /**
+     * Get unbalanced transactions (for audit)
+     */
+    async getUnbalancedTransactions() {
+        this.ensureInitialized();
+        if (!this.ledger)
+            throw new Error('Ledger not initialized');
+        return await this.ledger.getUnbalancedTransactions();
+    }
+    /**
+     * Close the API and database connection
+     */
+    async close() {
+        await this.chartOfAccounts.close();
+        this.initialized = false;
+        this.currentSKRType = null;
+        this.ledger = null;
+        this.reports = null;
+        this.logger.log('info', 'SKR API closed');
+    }
+    // ========== Batch Operations ==========
+    /**
+     * Post multiple transactions
+     */
+    async postBatchTransactions(transactions) {
+        this.ensureInitialized();
+        const results = [];
+        const errors = [];
+        for (let i = 0; i < transactions.length; i++) {
+            try {
+                const transaction = await this.postTransaction(transactions[i]);
+                results.push(transaction);
+            }
+            catch (error) {
+                errors.push({ index: i, error: error.message });
+            }
+        }
+        if (errors.length > 0) {
+            this.logger.log('warn', `Batch transaction posting completed with ${errors.length} errors`);
+            throw new Error(`Batch posting failed for ${errors.length} transactions: ${JSON.stringify(errors)}`);
+        }
+        return results;
+    }
+    /**
+     * Create multiple accounts
+     */
+    async createBatchAccounts(accounts) {
+        this.ensureInitialized();
+        const results = [];
+        const errors = [];
+        for (let i = 0; i < accounts.length; i++) {
+            try {
+                const account = await this.createAccount(accounts[i]);
+                results.push(account);
+            }
+            catch (error) {
+                errors.push({ index: i, error: error.message });
+            }
+        }
+        if (errors.length > 0) {
+            this.logger.log('warn', `Batch account creation completed with ${errors.length} errors`);
+            throw new Error(`Batch creation failed for ${errors.length} accounts: ${JSON.stringify(errors)}`);
+        }
+        return results;
+    }
+    // ========== Pagination Support ==========
+    /**
+     * Get paginated accounts
+     */
+    async getAccountsPaginated(page = 1, pageSize = 50, filter) {
+        this.ensureInitialized();
+        const allAccounts = await this.listAccounts(filter);
+        const total = allAccounts.length;
+        const totalPages = Math.ceil(total / pageSize);
+        const start = (page - 1) * pageSize;
+        const end = start + pageSize;
+        const data = allAccounts.slice(start, end);
+        return {
+            data,
+            total,
+            page,
+            pageSize,
+            totalPages,
+        };
+    }
+    /**
+     * Get paginated transactions
+     */
+    async getTransactionsPaginated(page = 1, pageSize = 50, filter) {
+        this.ensureInitialized();
+        const allTransactions = await this.listTransactions(filter);
+        const total = allTransactions.length;
+        const totalPages = Math.ceil(total / pageSize);
+        const start = (page - 1) * pageSize;
+        const end = start + pageSize;
+        const data = allTransactions.slice(start, end);
+        return {
+            data,
+            total,
+            page,
+            pageSize,
+            totalPages,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.api.js","sourceRoot":"","sources":["../ts/skr.api.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.classes.account.d.ts

@@ -0,0 +1,34 @@
+import * as plugins from './plugins.js';
+import type { TAccountType, TSKRType, IAccountData } from './skr.types.js';
+declare const SmartDataDbDoc: typeof plugins.smartdata.SmartDataDbDoc;
+export declare class Account extends SmartDataDbDoc<Account, Account> {
+    id: string;
+    accountNumber: string;
+    accountName: string;
+    accountClass: number;
+    accountGroup: number;
+    accountSubgroup: number;
+    accountType: TAccountType;
+    skrType: TSKRType;
+    description: string;
+    vatRate: number;
+    balance: number;
+    debitTotal: number;
+    creditTotal: number;
+    isActive: boolean;
+    isSystemAccount: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(data?: Partial<IAccountData>);
+    static createAccount(data: IAccountData): Promise<Account>;
+    static getAccountByNumber(accountNumber: string, skrType: TSKRType): Promise<Account | null>;
+    static getAccountsByClass(accountClass: number, skrType: TSKRType): Promise<Account[]>;
+    static getAccountsByType(accountType: TAccountType, skrType: TSKRType): Promise<Account[]>;
+    static searchAccounts(searchTerm: string, skrType?: TSKRType): Promise<Account[]>;
+    updateBalance(debitAmount?: number, creditAmount?: number): Promise<void>;
+    deactivate(): Promise<void>;
+    activate(): Promise<void>;
+    getNormalBalance(): 'debit' | 'credit';
+    beforeSave(): Promise<void>;
+}
+export {};