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

package/tests/records/z900.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, it } from 'vitest';
+import { SHAAM_VERSION } from '../../src/constants';
+import { encodeZ900, parseZ900, Z900Schema, type Z900 } from '../../src/generator/records/z900';
+
+describe('Z900 Record', () => {
+  const validZ900: Z900 = {
+    code: 'Z900',
+    recordNumber: '123',
+    vatId: '987654321',
+    uniqueId: '123456789012345',
+    totalRecords: '1000',
+    reserved: '',
+  };
+
+  describe('Z900Schema validation', () => {
+    it('should validate a correct Z900 record', () => {
+      expect(() => Z900Schema.parse(validZ900)).not.toThrow();
+    });
+
+    it('should require code to be exactly "Z900"', () => {
+      const invalidRecord = { ...validZ900, code: 'Z800' };
+      expect(() => Z900Schema.parse(invalidRecord)).toThrow();
+    });
+
+    it('should require recordNumber to be non-empty and max 9 characters', () => {
+      expect(() => Z900Schema.parse({ ...validZ900, recordNumber: '' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, recordNumber: '1234567890' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, recordNumber: '123456789' })).not.toThrow();
+    });
+
+    it('should require vatId to be non-empty and max 9 characters', () => {
+      expect(() => Z900Schema.parse({ ...validZ900, vatId: '' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, vatId: '1234567890' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, vatId: '123456789' })).not.toThrow();
+    });
+
+    it('should require uniqueId to be non-empty and max 15 characters', () => {
+      expect(() => Z900Schema.parse({ ...validZ900, uniqueId: '' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, uniqueId: '1234567890123456' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, uniqueId: '123456789012345' })).not.toThrow();
+    });
+
+    it('should require totalRecords to be non-empty and max 15 characters', () => {
+      expect(() => Z900Schema.parse({ ...validZ900, totalRecords: '' })).toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, totalRecords: '1234567890123456' })).toThrow();
+      expect(() =>
+        Z900Schema.parse({ ...validZ900, totalRecords: '123456789012345' }),
+      ).not.toThrow();
+    });
+
+    it('should validate reserved field', () => {
+      expect(() => Z900Schema.parse({ ...validZ900, reserved: '' })).not.toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, reserved: 'Reserved data' })).not.toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, reserved: 'A'.repeat(50) })).not.toThrow();
+      expect(() => Z900Schema.parse({ ...validZ900, reserved: 'A'.repeat(51) })).toThrow();
+    });
+
+    it('should set default empty string for reserved field when missing', () => {
+      const { reserved: _reserved, ...recordWithoutReserved } = validZ900;
+      const parsed = Z900Schema.parse(recordWithoutReserved);
+      expect(parsed.reserved).toBe('');
+    });
+  });
+
+  describe('encodeZ900', () => {
+    it('should encode a Z900 record to fixed-width format', () => {
+      const encoded = encodeZ900(validZ900);
+
+      // Should end with CRLF
+      expect(encoded).toMatch(/\r\n$/);
+
+      // Remove CRLF for length check
+      const withoutCRLF = encoded.replace(/\r\n$/, '');
+      expect(withoutCRLF).toHaveLength(110);
+
+      // Check field positions and padding
+      expect(withoutCRLF.slice(0, 4)).toBe('Z900'); // code (4)
+      expect(withoutCRLF.slice(4, 13)).toBe('000000123'); // recordNumber zero-padded (9)
+      expect(withoutCRLF.slice(13, 22)).toBe('987654321'); // vatId zero-padded (9)
+      expect(withoutCRLF.slice(22, 37)).toBe('123456789012345'); // uniqueId zero-padded (15)
+      expect(withoutCRLF.slice(37, 45)).toBe(SHAAM_VERSION); // static SHAAM version (8)
+      expect(withoutCRLF.slice(45, 60)).toBe('000000000001000'); // totalRecords zero-padded (15)
+      expect(withoutCRLF.slice(60, 110)).toBe(' '.repeat(50)); // reserved left-aligned (50)
+    });
+
+    it('should handle maximum length fields', () => {
+      const maxLengthRecord: Z900 = {
+        code: 'Z900',
+        recordNumber: '123456789', // 9 chars
+        vatId: '123456789', // 9 chars
+        uniqueId: '123456789012345', // 15 chars
+        totalRecords: '123456789012345', // 15 chars
+        reserved: 'A'.repeat(50), // 50 chars
+      };
+
+      const encoded = encodeZ900(maxLengthRecord);
+      const withoutCRLF = encoded.replace(/\r\n$/, '');
+      expect(withoutCRLF).toHaveLength(110);
+
+      expect(withoutCRLF.slice(0, 4)).toBe('Z900');
+      expect(withoutCRLF.slice(4, 13)).toBe('123456789');
+      expect(withoutCRLF.slice(13, 22)).toBe('123456789');
+      expect(withoutCRLF.slice(22, 37)).toBe('123456789012345');
+      expect(withoutCRLF.slice(37, 45)).toBe(SHAAM_VERSION);
+      expect(withoutCRLF.slice(45, 60)).toBe('123456789012345');
+      expect(withoutCRLF.slice(60, 110)).toBe('A'.repeat(50));
+    });
+
+    it('should truncate fields that exceed maximum length', () => {
+      const oversizedRecord: Z900 = {
+        code: 'Z900',
+        recordNumber: '1234567890', // 10 chars (max 9)
+        vatId: '1234567890', // 10 chars (max 9)
+        uniqueId: '1234567890123456', // 16 chars (max 15)
+        totalRecords: '1234567890123456', // 16 chars (max 15)
+        reserved: 'A'.repeat(60), // 60 chars (max 50)
+      };
+
+      const encoded = encodeZ900(oversizedRecord);
+      const withoutCRLF = encoded.replace(/\r\n$/, '');
+      expect(withoutCRLF).toHaveLength(110);
+
+      expect(withoutCRLF.slice(4, 13)).toBe('123456789'); // truncated from right
+      expect(withoutCRLF.slice(13, 22)).toBe('123456789'); // truncated
+      expect(withoutCRLF.slice(22, 37)).toBe('123456789012345'); // truncated
+      expect(withoutCRLF.slice(37, 45)).toBe(SHAAM_VERSION); // always the constant
+      expect(withoutCRLF.slice(45, 60)).toBe('123456789012345'); // truncated from right
+      expect(withoutCRLF.slice(60, 110)).toBe('A'.repeat(50)); // truncated
+    });
+  });
+
+  describe('parseZ900', () => {
+    it('should parse a valid Z900 record line', () => {
+      const line =
+        'Z900000000123987654321123456789012345' +
+        SHAAM_VERSION +
+        '000000000001000' +
+        ' '.repeat(50) +
+        '\r\n';
+      const parsed = parseZ900(line);
+
+      expect(parsed).toEqual({
+        code: 'Z900',
+        recordNumber: '123',
+        vatId: '987654321',
+        uniqueId: '123456789012345',
+        totalRecords: '1000',
+        reserved: '',
+      });
+    });
+
+    it('should parse line without CRLF', () => {
+      const line =
+        'Z900000000123987654321123456789012345' +
+        SHAAM_VERSION +
+        '000000000001000' +
+        ' '.repeat(50);
+      const parsed = parseZ900(line);
+
+      expect(parsed.code).toBe('Z900');
+      expect(parsed.recordNumber).toBe('123');
+    });
+
+    it('should throw error for invalid line length', () => {
+      const shortLine = 'Z900' + ' '.repeat(50);
+      expect(() => parseZ900(shortLine)).toThrow(
+        'Invalid Z900 record length: expected 110 characters, got 54',
+      );
+
+      const longLine = 'Z900' + ' '.repeat(200);
+      expect(() => parseZ900(longLine)).toThrow(
+        'Invalid Z900 record length: expected 110 characters, got 204',
+      );
+    });
+
+    it('should throw error for invalid record code', () => {
+      const invalidLine = 'Z800' + ' '.repeat(106) + '\r\n';
+      expect(() => parseZ900(invalidLine)).toThrow(
+        'Invalid Z900 record code: expected "Z900", got "Z800"',
+      );
+    });
+
+    it('should throw error for invalid SHAAM version', () => {
+      const invalidLine =
+        'Z900000000123987654321123456789012345INVALID 000000000001000' + ' '.repeat(50) + '\r\n';
+      expect(() => parseZ900(invalidLine)).toThrow('Invalid SHAAM version');
+    });
+
+    it('should handle fields with trailing spaces correctly', () => {
+      const line =
+        'Z900000000123000123456000000000123456' +
+        SHAAM_VERSION +
+        '000000000009999' +
+        ' '.repeat(50) +
+        '\r\n';
+      const parsed = parseZ900(line);
+
+      expect(parsed.vatId).toBe('123456');
+      expect(parsed.uniqueId).toBe('123456');
+      expect(parsed.totalRecords).toBe('9999');
+      expect(parsed.reserved).toBe('');
+    });
+  });
+
+  describe('Round-trip encoding and parsing', () => {
+    it('should maintain data integrity through encode -> parse cycle', () => {
+      const original = validZ900;
+      const encoded = encodeZ900(original);
+      const parsed = parseZ900(encoded);
+
+      expect(parsed).toEqual(original);
+    });
+
+    it('should handle round-trip with maximum length fields', () => {
+      const original: Z900 = {
+        code: 'Z900',
+        recordNumber: '999999999',
+        vatId: '999888777',
+        uniqueId: '999888777666555',
+        totalRecords: '999888777666555',
+        reserved: 'A'.repeat(50),
+      };
+
+      const encoded = encodeZ900(original);
+      const parsed = parseZ900(encoded);
+
+      expect(parsed).toEqual(original);
+    });
+
+    it('should handle round-trip with minimal fields', () => {
+      const original: Z900 = {
+        code: 'Z900',
+        recordNumber: '1',
+        vatId: '1',
+        uniqueId: '1',
+        totalRecords: '1',
+        reserved: '',
+      };
+
+      const encoded = encodeZ900(original);
+      const parsed = parseZ900(encoded);
+
+      expect(parsed).toEqual(original);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should throw validation error for invalid parsed data', () => {
+      // Create a line that parses but fails schema validation
+      const invalidLine = 'Z900         ' + ' '.repeat(97); // empty recordNumber
+      expect(() => parseZ900(invalidLine)).toThrow();
+    });
+  });
+});

package/tests/types/enums.test.ts

@@ -0,0 +1,290 @@
+import { describe, expect, it } from 'vitest';
+import {
+  AccountingTypeEnum,
+  AccountingTypeLabels,
+  BalanceRequiredEnum,
+  BranchInfoFlagEnum,
+  CharacterEncodingEnum,
+  CountryCodeEnum,
+  CountryLabels,
+  CurrencyCodeEnum,
+  CurrencyLabels,
+  DebitCreditIndicatorEnum,
+  DebitCreditIndicatorLabels,
+  // Enums
+  DocumentTypeEnum,
+  // Labels
+  DocumentTypeLabels,
+  DocumentTypeLabelsEn,
+  LanguageCodeEnum,
+  PaymentMethodEnum,
+  PaymentMethodLabels,
+  RecordTypeEnum,
+  // Constants and utilities
+  SHAAM_CONSTANTS,
+  ShaamEnumSchemas,
+  ShaamLabels,
+  SoftwareTypeEnum,
+  SoftwareTypeLabels,
+  TrialBalanceCodeEnum,
+  TrialBalanceCodeLabels,
+  type AccountingType,
+  type CountryCode,
+  type CurrencyCode,
+  type DebitCreditIndicator,
+  // Types
+  type DocumentType,
+  type PaymentMethod,
+  type RecordType,
+  type SoftwareType,
+  type TrialBalanceCode,
+} from '../../src/types/enums';
+
+describe('SHAAM Format Enums', () => {
+  describe('DocumentTypeEnum', () => {
+    it('should validate correct document types', () => {
+      expect(DocumentTypeEnum.parse('320')).toBe('320');
+      expect(DocumentTypeEnum.parse('100')).toBe('100');
+      expect(DocumentTypeEnum.parse('710')).toBe('710');
+    });
+
+    it('should reject invalid document types', () => {
+      expect(() => DocumentTypeEnum.parse('999')).toThrow();
+      expect(() => DocumentTypeEnum.parse('ABC')).toThrow();
+      expect(() => DocumentTypeEnum.parse('')).toThrow();
+    });
+
+    it('should have corresponding labels', () => {
+      expect(DocumentTypeLabels['320']).toBe('חשבונית מס קבלה');
+      expect(DocumentTypeLabelsEn['320']).toBe('Receipt Tax Invoice');
+      expect(DocumentTypeLabels['100']).toBe('הזמנה');
+      expect(DocumentTypeLabelsEn['100']).toBe('Order');
+    });
+  });
+
+  describe('CurrencyCodeEnum', () => {
+    it('should validate common currency codes', () => {
+      expect(CurrencyCodeEnum.parse('ILS')).toBe('ILS');
+      expect(CurrencyCodeEnum.parse('USD')).toBe('USD');
+      expect(CurrencyCodeEnum.parse('EUR')).toBe('EUR');
+    });
+
+    it('should reject invalid currency codes', () => {
+      expect(() => CurrencyCodeEnum.parse('XXX')).toThrow();
+      expect(() => CurrencyCodeEnum.parse('123')).toThrow();
+      expect(() => CurrencyCodeEnum.parse('')).toThrow();
+    });
+
+    it('should have Hebrew labels', () => {
+      expect(CurrencyLabels['ILS']).toBe('שקל חדש');
+      expect(CurrencyLabels['USD']).toBe('דולר אמריקאי');
+      expect(CurrencyLabels['EUR']).toBe('יורו');
+    });
+  });
+
+  describe('RecordTypeEnum', () => {
+    it('should validate all SHAAM record types', () => {
+      const expectedTypes: RecordType[] = [
+        'A000',
+        'A100',
+        'B100',
+        'B110',
+        'C100',
+        'D110',
+        'D120',
+        'M100',
+        'Z900',
+      ];
+
+      for (const type of expectedTypes) {
+        expect(RecordTypeEnum.parse(type)).toBe(type);
+      }
+    });
+
+    it('should reject invalid record types', () => {
+      expect(() => RecordTypeEnum.parse('X999')).toThrow();
+      expect(() => RecordTypeEnum.parse('A999')).toThrow();
+      expect(() => RecordTypeEnum.parse('')).toThrow();
+    });
+  });
+
+  describe('SoftwareTypeEnum', () => {
+    it('should validate software types', () => {
+      expect(SoftwareTypeEnum.parse('1')).toBe('1');
+      expect(SoftwareTypeEnum.parse('2')).toBe('2');
+    });
+
+    it('should have descriptive labels', () => {
+      expect(SoftwareTypeLabels['1']).toBe('Single-year');
+      expect(SoftwareTypeLabels['2']).toBe('Multi-year');
+    });
+  });
+
+  describe('AccountingTypeEnum', () => {
+    it('should validate accounting types', () => {
+      expect(AccountingTypeEnum.parse('0')).toBe('0');
+      expect(AccountingTypeEnum.parse('1')).toBe('1');
+      expect(AccountingTypeEnum.parse('2')).toBe('2');
+    });
+
+    it('should have descriptive labels', () => {
+      expect(AccountingTypeLabels['0']).toBe('N/A');
+      expect(AccountingTypeLabels['1']).toBe('Single-entry');
+      expect(AccountingTypeLabels['2']).toBe('Double-entry');
+    });
+  });
+
+  describe('DebitCreditIndicatorEnum', () => {
+    it('should validate debit/credit indicators', () => {
+      expect(DebitCreditIndicatorEnum.parse('1')).toBe('1');
+      expect(DebitCreditIndicatorEnum.parse('2')).toBe('2');
+    });
+
+    it('should have descriptive labels', () => {
+      expect(DebitCreditIndicatorLabels['1']).toBe('Debit');
+      expect(DebitCreditIndicatorLabels['2']).toBe('Credit');
+    });
+  });
+
+  describe('PaymentMethodEnum', () => {
+    it('should validate payment methods', () => {
+      expect(PaymentMethodEnum.parse('1')).toBe('1');
+      expect(PaymentMethodEnum.parse('3')).toBe('3');
+      expect(PaymentMethodEnum.parse('4')).toBe('4');
+    });
+
+    it('should have descriptive labels', () => {
+      expect(PaymentMethodLabels['1']).toBe('Cash');
+      expect(PaymentMethodLabels['3']).toBe('Credit Card');
+      expect(PaymentMethodLabels['4']).toBe('Bank Transfer');
+    });
+  });
+
+  describe('TrialBalanceCodeEnum', () => {
+    it('should validate trial balance codes', () => {
+      expect(TrialBalanceCodeEnum.parse('Asset')).toBe('Asset');
+      expect(TrialBalanceCodeEnum.parse('Liability')).toBe('Liability');
+      expect(TrialBalanceCodeEnum.parse('Revenue')).toBe('Revenue');
+    });
+
+    it('should have Hebrew labels', () => {
+      expect(TrialBalanceCodeLabels['Asset']).toBe('נכסים');
+      expect(TrialBalanceCodeLabels['Liability']).toBe('התחייבויות');
+      expect(TrialBalanceCodeLabels['Revenue']).toBe('הכנסות');
+    });
+  });
+
+  describe('CountryCodeEnum', () => {
+    it('should validate common country codes', () => {
+      expect(CountryCodeEnum.parse('IL')).toBe('IL');
+      expect(CountryCodeEnum.parse('US')).toBe('US');
+      expect(CountryCodeEnum.parse('DE')).toBe('DE');
+    });
+
+    it('should have Hebrew labels', () => {
+      expect(CountryLabels['IL']).toBe('ישראל');
+      expect(CountryLabels['US']).toBe('ארצות הברית');
+      expect(CountryLabels['DE']).toBe('גרמניה');
+    });
+  });
+
+  describe('SHAAM_CONSTANTS', () => {
+    it('should have correct default values', () => {
+      expect(SHAAM_CONSTANTS.VERSION).toBe('&OF1.31&');
+      expect(SHAAM_CONSTANTS.DEFAULT_CURRENCY).toBe('ILS');
+      expect(SHAAM_CONSTANTS.DEFAULT_LANGUAGE).toBe('0');
+      expect(SHAAM_CONSTANTS.DEFAULT_ENCODING).toBe('1');
+      expect(SHAAM_CONSTANTS.DEFAULT_SOFTWARE_TYPE).toBe('2');
+      expect(SHAAM_CONSTANTS.DEFAULT_ACCOUNTING_TYPE).toBe('2');
+      expect(SHAAM_CONSTANTS.DEFAULT_BALANCE_REQUIRED).toBe('1');
+      expect(SHAAM_CONSTANTS.DEFAULT_BRANCH_INFO).toBe('0');
+    });
+
+    it('should have constants that validate against their enums', () => {
+      expect(CurrencyCodeEnum.parse(SHAAM_CONSTANTS.DEFAULT_CURRENCY)).toBe('ILS');
+      expect(LanguageCodeEnum.parse(SHAAM_CONSTANTS.DEFAULT_LANGUAGE)).toBe('0');
+      expect(CharacterEncodingEnum.parse(SHAAM_CONSTANTS.DEFAULT_ENCODING)).toBe('1');
+      expect(SoftwareTypeEnum.parse(SHAAM_CONSTANTS.DEFAULT_SOFTWARE_TYPE)).toBe('2');
+      expect(AccountingTypeEnum.parse(SHAAM_CONSTANTS.DEFAULT_ACCOUNTING_TYPE)).toBe('2');
+      expect(BalanceRequiredEnum.parse(SHAAM_CONSTANTS.DEFAULT_BALANCE_REQUIRED)).toBe('1');
+      expect(BranchInfoFlagEnum.parse(SHAAM_CONSTANTS.DEFAULT_BRANCH_INFO)).toBe('0');
+    });
+  });
+
+  describe('ShaamEnumSchemas', () => {
+    it('should provide access to all enum schemas', () => {
+      expect(ShaamEnumSchemas.DocumentType).toBe(DocumentTypeEnum);
+      expect(ShaamEnumSchemas.CurrencyCode).toBe(CurrencyCodeEnum);
+      expect(ShaamEnumSchemas.RecordType).toBe(RecordTypeEnum);
+      expect(ShaamEnumSchemas.SoftwareType).toBe(SoftwareTypeEnum);
+      expect(ShaamEnumSchemas.AccountingType).toBe(AccountingTypeEnum);
+    });
+  });
+
+  describe('ShaamLabels', () => {
+    it('should provide access to all label mappings', () => {
+      expect(ShaamLabels.DocumentType).toBe(DocumentTypeLabels);
+      expect(ShaamLabels.DocumentTypeEn).toBe(DocumentTypeLabelsEn);
+      expect(ShaamLabels.Currency).toBe(CurrencyLabels);
+      expect(ShaamLabels.Country).toBe(CountryLabels);
+      expect(ShaamLabels.SoftwareType).toBe(SoftwareTypeLabels);
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should enforce correct types at compile time', () => {
+      // These should compile without errors
+      const docType: DocumentType = '320';
+      const currency: CurrencyCode = 'ILS';
+      const recordType: RecordType = 'A100';
+      const softwareType: SoftwareType = '2';
+      const accountingType: AccountingType = '2';
+      const debitCredit: DebitCreditIndicator = '1';
+      const paymentMethod: PaymentMethod = '3';
+      const trialBalance: TrialBalanceCode = 'Asset';
+      const country: CountryCode = 'IL';
+
+      // Verify they hold the expected values
+      expect(docType).toBe('320');
+      expect(currency).toBe('ILS');
+      expect(recordType).toBe('A100');
+      expect(softwareType).toBe('2');
+      expect(accountingType).toBe('2');
+      expect(debitCredit).toBe('1');
+      expect(paymentMethod).toBe('3');
+      expect(trialBalance).toBe('Asset');
+      expect(country).toBe('IL');
+    });
+  });
+
+  describe('Coverage and Completeness', () => {
+    it('should have all document types covered in both label sets', () => {
+      const docTypes = DocumentTypeEnum.options;
+
+      for (const type of docTypes) {
+        expect(DocumentTypeLabels[type]).toBeDefined();
+        expect(DocumentTypeLabelsEn[type]).toBeDefined();
+        expect(typeof DocumentTypeLabels[type]).toBe('string');
+        expect(typeof DocumentTypeLabelsEn[type]).toBe('string');
+      }
+    });
+
+    it('should have all currencies covered in labels', () => {
+      const currencies = CurrencyCodeEnum.options;
+
+      for (const currency of currencies) {
+        expect(CurrencyLabels[currency]).toBeDefined();
+        expect(typeof CurrencyLabels[currency]).toBe('string');
+      }
+    });
+
+    it('should have all countries covered in labels', () => {
+      const countries = CountryCodeEnum.options;
+
+      for (const country of countries) {
+        expect(CountryLabels[country]).toBeDefined();
+        expect(typeof CountryLabels[country]).toBe('string');
+      }
+    });
+  });
+});