@accounter/shaam-uniform-format-generator 0.1.0 → 0.1.1

package/dist/cjs/api/generate-report.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * Main API for generating SHAAM uniform format reports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUniformFormatReport = generateUniformFormatReport;
+const encoder_js_1 = require("../generator/format/encoder.js");
+const index_js_1 = require("../generator/records/index.js");
+const errors_js_1 = require("../validation/errors.js");
+const validate_input_js_1 = require("../validation/validate-input.js");
+/**
+ * Generates SHAAM uniform format report files (INI.TXT and BKMVDATA.TXT)
+ * from a high-level JSON input object.
+ *
+ * @param input - The report input data
+ * @param options - Generation options
+ * @returns Report output with generated file content
+ */
+function generateUniformFormatReport(input, options = {}) {
+    // Validate input data first
+    const validationMode = options.validationMode || 'fail-fast';
+    const validationErrors = (0, validate_input_js_1.validateInput)(input, validationMode);
+    if (validationErrors.length > 0) {
+        if (validationMode === 'fail-fast') {
+            // This should have already thrown, but just in case
+            throw new errors_js_1.ShaamFormatError('Validation failed', validationErrors);
+        }
+        // For collect-all mode, we still throw if there are errors
+        // The user can catch and inspect the errors if needed
+        throw new errors_js_1.ShaamFormatError('Input validation failed', validationErrors);
+    }
+    const records = [];
+    const iniRecords = [];
+    const recordCounts = {};
+    let recordNumber = 1;
+    // Helper function to count and add data record
+    const addRecord = (recordType, recordContent) => {
+        records.push(recordContent);
+        recordCounts[recordType] = (recordCounts[recordType] || 0) + 1;
+        recordNumber++;
+    };
+    // Helper function to add INI record
+    const addIniRecord = (recordType, recordContent) => {
+        iniRecords.push(recordContent);
+        recordCounts[recordType] = (recordCounts[recordType] || 0) + 1;
+    };
+    // Generate A000 record for INI.TXT
+    const fileHeaderRecord = {
+        reservedFuture: '',
+        totalRecords: '0', // Will be updated later with actual count
+        vatId: input.business.taxId,
+        softwareRegNumber: '12345678', // TODO: Use actual software registration number
+        softwareName: 'SHAAM Generator',
+        softwareVersion: '1.0.0',
+        vendorVatId: '123456789', // TODO: Use actual vendor VAT ID
+        vendorName: 'Accounter',
+        softwareType: '2', // Multi-year software
+        fileOutputPath: options.fileNameBase || 'report',
+        accountingType: '2', // Double-entry accounting
+        balanceRequired: '1',
+        companyRegId: '',
+        withholdingFileNum: '',
+        reserved1017: '',
+        businessName: input.business.name,
+        businessStreet: '',
+        businessHouseNum: '',
+        businessCity: '',
+        businessZip: '',
+        taxYear: '',
+        startDate: input.business.reportingPeriod.startDate.replace(/-/g, ''),
+        endDate: input.business.reportingPeriod.endDate.replace(/-/g, ''),
+        processStartDate: new Date().toISOString().slice(0, 10).replace(/-/g, ''),
+        processStartTime: new Date().toTimeString().slice(0, 5).replace(':', ''),
+        languageCode: '0', // Hebrew
+        characterEncoding: '1', // ISO-8859-8-i
+        compressionSoftware: '',
+        reserved1031: '',
+        baseCurrency: 'ILS',
+        reserved1033: '',
+        branchInfoFlag: '0', // No branches for now
+        reserved1035: '',
+    };
+    addIniRecord('A000', (0, index_js_1.encodeA000)(fileHeaderRecord));
+    // Add A000Sum records for each record type to INI.TXT
+    // Calculate expected counts based on input data
+    const expectedCounts = {
+        A100: 1,
+        C100: input.documents.length,
+        D110: input.documents.length,
+        D120: input.documents.length,
+        B100: input.journalEntries.length,
+        B110: input.accounts.length,
+        M100: input.inventory.length,
+        Z900: 1,
+    };
+    // Add summary records for each record type
+    for (const [recordType, count] of Object.entries(expectedCounts)) {
+        if (count > 0) {
+            const summaryRecord = {
+                code: recordType,
+                recordCount: count.toString(),
+            };
+            addIniRecord('A000Sum', (0, index_js_1.encodeA000Sum)(summaryRecord));
+        }
+    }
+    // 1. Business metadata - A100 record
+    const businessMetadata = {
+        recordNumber: recordNumber.toString(),
+        vatId: input.business.taxId,
+        reserved: '',
+    };
+    addRecord('A100', (0, index_js_1.encodeA100)(businessMetadata));
+    // TODO: 2. Summaries... (not implemented yet)
+    // 3. For each document in input.documents
+    for (const document of input.documents) {
+        // Document header - C100 record
+        const documentRecord = {
+            code: 'C100',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            documentType: document.type,
+            documentId: document.id,
+            documentIssueDate: document.date.replace(/-/g, ''), // Convert YYYY-MM-DD to YYYYMMDD
+            documentIssueTime: '',
+            customerName: '',
+            customerStreet: '',
+            customerHouseNumber: '',
+            customerCity: '',
+            customerPostCode: '',
+            customerCountry: '',
+            customerCountryCode: '',
+            customerPhone: '',
+            customerVatId: '',
+            documentValueDate: '',
+            foreignCurrencyAmount: '',
+            currencyCode: '',
+            amountBeforeDiscount: '',
+            documentDiscount: '',
+            amountAfterDiscountExcludingVat: '',
+            vatAmount: '',
+            amountIncludingVat: document.amount.toFixed(2), // Format as decimal with 2 places
+            withholdingTaxAmount: '',
+            customerKey: '',
+            matchingField: '',
+            cancelledAttribute1: '',
+            cancelledDocument: '',
+            cancelledAttribute2: '',
+            documentDate: '',
+            branchKey: '',
+            cancelledAttribute3: '',
+            actionExecutor: '',
+            lineConnectingField: '',
+            reserved: '',
+        };
+        addRecord('C100', (0, index_js_1.encodeC100)(documentRecord));
+        // Document line - D110 record
+        const documentLineRecord = {
+            code: 'D110',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            documentType: document.type,
+            documentNumber: document.id,
+            lineNumber: '1',
+            baseDocumentType: '',
+            baseDocumentNumber: '',
+            transactionType: '',
+            internalCatalogCode: '',
+            goodsServiceDescription: document.description || 'Item',
+            manufacturerName: '',
+            serialNumber: '',
+            unitOfMeasureDescription: '',
+            quantity: '1',
+            unitPriceExcludingVat: '',
+            lineDiscount: '',
+            lineTotal: '',
+            vatRatePercent: '',
+            reserved1: '',
+            branchId: '1',
+            reserved2: '',
+            documentDate: document.date.replace(/-/g, ''),
+            headerLinkField: '',
+            baseDocumentBranchId: '',
+            reserved3: '',
+        };
+        addRecord('D110', (0, index_js_1.encodeD110)(documentLineRecord));
+        // Payment record - D120 record (if applicable)
+        const paymentRecord = {
+            code: 'D120',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            documentType: document.type,
+            documentNumber: document.id,
+            lineNumber: '1',
+            paymentMethod: '1', // Default payment method
+            bankNumber: '',
+            branchNumber: '',
+            accountNumber: '',
+            checkNumber: '',
+            paymentDueDate: '',
+            lineAmount: document.amount.toFixed(2), // Format as decimal with 2 places
+            acquirerCode: '',
+            cardBrand: '',
+            creditTransactionType: '',
+            firstPaymentAmount: '',
+            installmentsCount: '',
+            additionalPaymentAmount: '',
+            reserved1: '',
+            branchId: '1',
+            reserved2: '',
+            documentDate: document.date.replace(/-/g, ''),
+            headerLinkField: '',
+            reserved: '',
+        };
+        addRecord('D120', (0, index_js_1.encodeD120)(paymentRecord));
+    }
+    // 4. Journal lines: for each entry and its lines
+    for (const entry of input.journalEntries) {
+        const journalRecord = {
+            code: 'B100',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            transactionNumber: entry.id.replace(/\D/g, '') || '1', // Extract only digits, default to '1'
+            transactionLineNumber: '1',
+            batchNumber: '',
+            transactionType: '',
+            referenceDocument: '',
+            referenceDocumentType: '',
+            referenceDocument2: '',
+            referenceDocumentType2: '',
+            details: entry.description || '',
+            date: entry.date.replace(/-/g, ''),
+            valueDate: entry.date.replace(/-/g, ''), // Same as date for simplicity
+            accountKey: entry.accountId,
+            counterAccountKey: '',
+            debitCreditIndicator: (entry.amount >= 0 ? '1' : '2'),
+            currencyCode: '',
+            transactionAmount: Math.abs(entry.amount).toFixed(2), // Format as decimal with 2 places
+            foreignCurrencyAmount: '',
+            quantityField: '',
+            matchingField1: '',
+            matchingField2: '',
+            branchId: '',
+            entryDate: entry.date.replace(/-/g, ''),
+            operatorUsername: '',
+            reserved: '',
+        };
+        addRecord('B100', (0, index_js_1.encodeB100)(journalRecord));
+    }
+    // 5. Accounts: B110 records
+    for (const account of input.accounts) {
+        const accountRecord = {
+            code: 'B110',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            accountKey: account.id,
+            accountName: account.name,
+            trialBalanceCode: account.type,
+            trialBalanceCodeDescription: account.type,
+            customerSupplierAddressStreet: '',
+            customerSupplierAddressHouseNumber: '',
+            customerSupplierAddressCity: '',
+            customerSupplierAddressZip: '',
+            customerSupplierAddressCountry: '',
+            countryCode: '',
+            parentAccountKey: '',
+            accountOpeningBalance: '0',
+            totalDebits: '0',
+            totalCredits: '0',
+            accountingClassificationCode: '',
+            supplierCustomerTaxId: '',
+            branchId: '',
+            openingBalanceForeignCurrency: '',
+            foreignCurrencyCode: '',
+            reserved: '',
+        };
+        addRecord('B110', (0, index_js_1.encodeB110)(accountRecord));
+    }
+    // 6. Inventory: M100 records
+    for (const item of input.inventory) {
+        const inventoryRecord = {
+            code: 'M100',
+            recordNumber: recordNumber.toString(),
+            vatId: input.business.taxId,
+            universalItemCode: '',
+            supplierItemCode: '',
+            internalItemCode: item.id,
+            itemName: item.name,
+            classificationCode: '',
+            classificationDescription: '',
+            unitOfMeasure: '',
+            openingStock: '0',
+            totalStockIn: '0',
+            totalStockOut: item.quantity.toString(),
+            endPeriodCostNonBonded: '',
+            endPeriodCostBonded: '',
+            reserved: '',
+        };
+        addRecord('M100', (0, index_js_1.encodeM100)(inventoryRecord));
+    }
+    // 7. Closing record: Z900
+    const closingRecord = {
+        recordNumber: recordNumber.toString(),
+        vatId: input.business.taxId,
+        totalRecords: records.length.toString(), // Count of records before Z900 is added
+        reserved: '',
+    };
+    addRecord('Z900', (0, index_js_1.encodeZ900)(closingRecord));
+    // Build iniText and dataText using the assembler
+    const iniText = (0, encoder_js_1.assembleFile)(iniRecords);
+    const dataText = (0, encoder_js_1.assembleFile)(records);
+    // Create virtual File objects
+    const iniFile = new File([iniText], `${options.fileNameBase || 'report'}.INI.TXT`, {
+        type: 'text/plain',
+    });
+    const dataFile = new File([dataText], `${options.fileNameBase || 'report'}.BKMVDATA.TXT`, {
+        type: 'text/plain',
+    });
+    return {
+        iniText,
+        dataText,
+        iniFile,
+        dataFile,
+        summary: {
+            totalRecords: records.length + iniRecords.length,
+            perType: recordCounts,
+        },
+    };
+}

package/dist/cjs/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * SHAAM format constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHAAM_VERSION = void 0;
+/**
+ * SHAAM specification version identifier
+ * Used in fields 1104 (A100) and 1154 (Z900)
+ */
+exports.SHAAM_VERSION = '&OF1.31&';

package/dist/cjs/generator/format/encoder.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Fixed-width formatting utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatField = formatField;
+exports.encodeFixedWidth = encodeFixedWidth;
+exports.formatNumericField = formatNumericField;
+exports.joinFields = joinFields;
+exports.joinRecords = joinRecords;
+exports.joinLinesWithCRLF = joinLinesWithCRLF;
+exports.assembleFile = assembleFile;
+const newline_js_1 = require("../../format/newline.js");
+const padding_js_1 = require("../../format/padding.js");
+/**
+ * Formats a field value with specified width and alignment
+ *
+ * @param value - The value to format
+ * @param width - Target field width
+ * @param align - Alignment ('left' or 'right')
+ * @param padChar - Character to use for padding (default: space)
+ * @returns Formatted fixed-width string
+ */
+function formatField(value, width, align, padChar = ' ') {
+    if (align === 'left') {
+        return (0, padding_js_1.padRight)(value, width, padChar);
+    }
+    return (0, padding_js_1.padLeft)(value, width, padChar);
+}
+/**
+ * Encodes a value to fixed-width format with padding
+ *
+ * @param value - The value to encode
+ * @param width - Target width
+ * @param padChar - Padding character (default: space)
+ * @param align - Alignment ('left' or 'right')
+ * @returns Fixed-width encoded string
+ */
+function encodeFixedWidth(value, width, padChar = ' ', align = 'left') {
+    const str = String(value);
+    return formatField(str, width, align, padChar);
+}
+/**
+ * Helper function to format numeric fields with zero padding
+ */
+function formatNumericField(value, width) {
+    return (0, padding_js_1.padLeft)(value, width, '0');
+}
+/**
+ * Joins an array of field values into a single record line with CRLF ending
+ * This is used by individual record encoders to create their output
+ *
+ * @param fields - Array of formatted field values
+ * @returns Single record line ending with CRLF
+ */
+function joinFields(fields) {
+    return fields.join('') + newline_js_1.CRLF;
+}
+/**
+ * Joins an array of record lines that already have CRLF endings
+ *
+ * @param lines - Array of record lines to join (each line should already end with CRLF)
+ * @returns Joined string
+ */
+function joinRecords(lines) {
+    return lines.join('');
+}
+/**
+ * Joins an array of record lines and adds CRLF to each line
+ *
+ * @param lines - Array of record lines to join (without CRLF endings)
+ * @returns Joined string with CRLF line endings
+ */
+function joinLinesWithCRLF(lines) {
+    return lines.map(line => line + newline_js_1.CRLF).join('');
+}
+/**
+ * Creates a complete SHAAM format file by joining records
+ * This is the main function for assembling final file content
+ *
+ * @param records - Array of encoded record strings (each already ending with CRLF)
+ * @returns Complete file content ready for output
+ */
+function assembleFile(records) {
+    return joinRecords(records);
+}

package/dist/cjs/generator/records/a000-sum.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A000SumInputSchema = exports.A000SumSchema = void 0;
+exports.encodeA000Sum = encodeA000Sum;
+exports.parseA000Sum = parseA000Sum;
+const zod_1 = require("zod");
+const encoder_js_1 = require("../format/encoder.js");
+/**
+ * A000Sum Record Schema - Record count summary for INI.TXT
+ * Fields 1050-1051 based on SHAAM uniform format specification
+ */
+exports.A000SumSchema = zod_1.z.object({
+    // Field 1050: Record Code (4) - Required - Alphanumeric
+    code: zod_1.z.string().min(1).max(4).describe('Record type code being summarized'),
+    // Field 1051: Record Count (15) - Required - Numeric
+    recordCount: zod_1.z
+        .string()
+        .min(1)
+        .max(15)
+        .regex(/^\d+$/)
+        .describe('Total number of records of this type'),
+});
+/**
+ * A000Sum Input Schema - for user input (no auto-generated fields)
+ */
+exports.A000SumInputSchema = exports.A000SumSchema;
+/**
+ * Encodes an A000Sum record to fixed-width string format
+ * Total line width: 19 characters + CRLF
+ */
+function encodeA000Sum(input) {
+    const fullRecord = {
+        ...input,
+    };
+    const fields = [
+        (0, encoder_js_1.formatField)(fullRecord.code, 4, 'left'), // Field 1050: Record code (4)
+        (0, encoder_js_1.formatNumericField)(fullRecord.recordCount, 15), // Field 1051: Record count (15)
+    ];
+    return (0, encoder_js_1.joinFields)(fields);
+}
+/**
+ * Parses a fixed-width A000Sum record line back to object
+ * Expected line length: 19 characters (excluding CRLF)
+ */
+function parseA000Sum(line) {
+    // Remove CRLF if present
+    const cleanLine = line.replace(/\r?\n$/, '');
+    if (cleanLine.length !== 19) {
+        throw new Error(`Invalid A000Sum record length: expected 19 characters, got ${cleanLine.length}`);
+    }
+    let offset = 0;
+    // Extract fields at their fixed positions
+    const code = cleanLine.slice(offset, offset + 4).trim();
+    offset += 4; // Field 1050 (4)
+    const recordCount = cleanLine
+        .slice(offset, offset + 15)
+        .trim()
+        .replace(/^0+/, '') || '0';
+    offset += 15; // Field 1051 (15)
+    const parsed = {
+        code,
+        recordCount,
+    };
+    // Validate against schema
+    return exports.A000SumSchema.parse(parsed);
+}