@accounter/server 0.0.9-alpha-20251210155614-e6e65aaecafef9e8fedd0b933f613ffcf478cecf → 0.0.9-alpha-20251210171954-c9c0e7693ebe08d3643d9ee2c00c03606a53e334

package/src/__tests__/seed-admin-context.integration.test.ts

@@ -1,240 +1,231 @@
-import { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import pg from 'pg';
-import { testDbConfig } from './helpers/test-db-config.js';
+import { describe, expect, it, beforeAll, afterAll } from 'vitest';
+import { TestDatabase } from './helpers/db-setup.js';
 import { seedAdminCore } from '../../scripts/seed-admin-context.js';
 
 describe('seedAdminCore integration', () => {
-  let pool: pg.Pool;
-  let client: pg.PoolClient;
+  let db: TestDatabase;
 
   beforeAll(async () => {
-    pool = new pg.Pool(testDbConfig);
-    client = await pool.connect();
+    db = new TestDatabase();
+    await db.connect();
   });
 
   afterAll(async () => {
-    client.release();
-    await pool.end();
+    await db.close();
   });
 
-  beforeEach(async () => {
-    await client.query('BEGIN');
-  });
+  it('should create admin business context with all required entities', async () => {
+    await db.withTransaction(async client => {
+      // Execute seed
+      const { adminEntityId } = await seedAdminCore(client);
+
+      // Verify admin entity exists
+      expect(adminEntityId).toBeTruthy();
+      expect(adminEntityId).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      );
 
-  afterEach(async () => {
-    await client.query('ROLLBACK');
-  });
+      // Verify admin financial entity
+      const adminEntity = await client.query(
+        `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
+        [adminEntityId],
+      );
+      expect(adminEntity.rows).toHaveLength(1);
+      expect(adminEntity.rows[0].name).toBe('Admin Business');
+      expect(adminEntity.rows[0].type).toBe('business');
+      expect(adminEntity.rows[0].owner_id).toBe(adminEntityId); // self-owned
+
+      // Verify admin business record
+      const adminBusiness = await client.query(
+        `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
+        [adminEntityId],
+      );
+      expect(adminBusiness.rows).toHaveLength(1);
 
-  it('should create admin business context with all required entities', async () => {
+      // Verify user_context exists and has required fields
+      const userContext = await client.query(
+        `SELECT * FROM accounter_schema.user_context WHERE owner_id = $1`,
+        [adminEntityId],
+      );
+      expect(userContext.rows).toHaveLength(1);
 
-    // Execute seed
-    const { adminEntityId } = await seedAdminCore(client);
-
-    // Verify admin entity exists
-    expect(adminEntityId).toBeTruthy();
-    expect(adminEntityId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-    );
-
-    // Verify admin financial entity
-    const adminEntity = await client.query(
-      `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
-      [adminEntityId],
-    );
-    expect(adminEntity.rows).toHaveLength(1);
-    expect(adminEntity.rows[0].name).toBe('Admin Business');
-    expect(adminEntity.rows[0].type).toBe('business');
-    expect(adminEntity.rows[0].owner_id).toBe(adminEntityId); // self-owned
-
-    // Verify admin business record
-    const adminBusiness = await client.query(
-      `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
-      [adminEntityId],
-    );
-    expect(adminBusiness.rows).toHaveLength(1);
-
-    // Verify user_context exists and has required fields
-    const userContext = await client.query(
-      `SELECT * FROM accounter_schema.user_context WHERE owner_id = $1`,
-      [adminEntityId],
-    );
-    expect(userContext.rows).toHaveLength(1);
-
-    const context = userContext.rows[0];
-
-    // Verify currencies
-    expect(context.default_local_currency).toBe('ILS');
-    expect(context.default_fiat_currency_for_crypto_conversions).toBe('USD');
-
-    // Verify required authority businesses exist
-    const vatBusiness = await client.query(
-      `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
-      [context.vat_business_id],
-    );
-    expect(vatBusiness.rows).toHaveLength(1);
-
-    const taxBusiness = await client.query(
-      `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
-      [context.tax_business_id],
-    );
-    expect(taxBusiness.rows).toHaveLength(1);
-
-    const socialSecurityBusiness = await client.query(
-      `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
-      [context.social_security_business_id],
-    );
-    expect(socialSecurityBusiness.rows).toHaveLength(1);
-
-    // Verify required tax categories exist
-    const requiredTaxCategoryFields = [
-      'default_tax_category_id',
-      'input_vat_tax_category_id',
-      'output_vat_tax_category_id',
-      'tax_expenses_tax_category_id',
-      'exchange_rate_tax_category_id',
-      'income_exchange_rate_tax_category_id',
-      'exchange_rate_revaluation_tax_category_id',
-      'fee_tax_category_id',
-      'general_fee_tax_category_id',
-      'fine_tax_category_id',
-      'untaxable_gifts_tax_category_id',
-      'balance_cancellation_tax_category_id',
-      'development_foreign_tax_category_id',
-      'development_local_tax_category_id',
-      'expenses_to_pay_tax_category_id',
-      'expenses_in_advance_tax_category_id',
-      'income_to_collect_tax_category_id',
-      'income_in_advance_tax_category_id',
-      'salary_excess_expenses_tax_category_id',
-    ];
-
-    for (const field of requiredTaxCategoryFields) {
-      const taxCategoryId = context[field];
-      expect(taxCategoryId).toBeTruthy();
-
-      const taxCategory = await client.query(
-        `SELECT * FROM accounter_schema.tax_categories WHERE id = $1`,
-        [taxCategoryId],
+      const context = userContext.rows[0];
+
+      // Verify currencies
+      expect(context.default_local_currency).toBe('ILS');
+      expect(context.default_fiat_currency_for_crypto_conversions).toBe('USD');
+
+      // Verify required authority businesses exist
+      const vatBusiness = await client.query(
+        `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
+        [context.vat_business_id],
       );
-      expect(taxCategory.rows).toHaveLength(1);
-    }
+      expect(vatBusiness.rows).toHaveLength(1);
+
+      const taxBusiness = await client.query(
+        `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
+        [context.tax_business_id],
+      );
+      expect(taxBusiness.rows).toHaveLength(1);
+
+      const socialSecurityBusiness = await client.query(
+        `SELECT * FROM accounter_schema.businesses WHERE id = $1`,
+        [context.social_security_business_id],
+      );
+      expect(socialSecurityBusiness.rows).toHaveLength(1);
+
+      // Verify required tax categories exist
+      const requiredTaxCategoryFields = [
+        'default_tax_category_id',
+        'input_vat_tax_category_id',
+        'output_vat_tax_category_id',
+        'tax_expenses_tax_category_id',
+        'exchange_rate_tax_category_id',
+        'income_exchange_rate_tax_category_id',
+        'exchange_rate_revaluation_tax_category_id',
+        'fee_tax_category_id',
+        'general_fee_tax_category_id',
+        'fine_tax_category_id',
+        'untaxable_gifts_tax_category_id',
+        'balance_cancellation_tax_category_id',
+        'development_foreign_tax_category_id',
+        'development_local_tax_category_id',
+        'expenses_to_pay_tax_category_id',
+        'expenses_in_advance_tax_category_id',
+        'income_to_collect_tax_category_id',
+        'income_in_advance_tax_category_id',
+        'salary_excess_expenses_tax_category_id',
+      ];
+
+      for (const field of requiredTaxCategoryFields) {
+        const taxCategoryId = context[field];
+        expect(taxCategoryId).toBeTruthy();
+
+        const taxCategory = await client.query(
+          `SELECT * FROM accounter_schema.tax_categories WHERE id = $1`,
+          [taxCategoryId],
+        );
+        expect(taxCategory.rows).toHaveLength(1);
+      }
+    });
   });
 
   it('should be idempotent (safe to call multiple times)', async () => {
-    // Call seed twice in same transaction
-    await seedAdminCore(client);
-    
-    // Count entities before second call
-    const countBefore = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.financial_entities`,
-    );
-    const entitiesBeforeSecondCall = parseInt(countBefore.rows[0].count);
-
-    // Second call should reuse existing entities
-    await seedAdminCore(client);
-
-    // Count entities after second call - should be same
-    const countAfter = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.financial_entities`,
-    );
-    const entitiesAfterSecondCall = parseInt(countAfter.rows[0].count);
-
-    // Idempotent: no new entities created on second call
-    expect(entitiesAfterSecondCall).toBe(entitiesBeforeSecondCall);
-
-    // Verify only one user_context exists
-    const userContextCount = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.user_context`,
-    );
-    expect(userContextCount.rows[0].count).toBe('1');
+    await db.withTransaction(async client => {
+      // Call seed twice in same transaction
+      await seedAdminCore(client);
+
+      // Count entities before second call
+      const countBefore = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.financial_entities`,
+      );
+      const entitiesBeforeSecondCall = parseInt(countBefore.rows[0].count);
+
+      // Second call should reuse existing entities
+      await seedAdminCore(client);
+
+      // Count entities after second call - should be same
+      const countAfter = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.financial_entities`,
+      );
+      const entitiesAfterSecondCall = parseInt(countAfter.rows[0].count);
+
+      // Idempotent: no new entities created on second call
+      expect(entitiesAfterSecondCall).toBe(entitiesBeforeSecondCall);
+
+      // Verify only one user_context exists
+      const userContextCount = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.user_context`,
+      );
+      expect(userContextCount.rows[0].count).toBe('1');
+    });
   });
 
   it('should not leak data between tests (transactional isolation)', async () => {
-    const TEMP_NAME = 'seed-admin-context.integration.test.ts: temp rollback entity';
+    await db.withTransaction(async client => {
+      const TEMP_NAME = 'seed-admin-context.integration.test.ts: temp rollback entity';
 
-    // Insert a throwaway entity inside a transaction
-    const insertEntity = await client.query(
-      `INSERT INTO accounter_schema.financial_entities (name, type)
+      // Insert a throwaway entity inside a transaction
+      const insertEntity = await client.query(
+        `INSERT INTO accounter_schema.financial_entities (name, type)
        VALUES ($1, 'business')
        RETURNING id`,
-      [TEMP_NAME],
-    );
-    const tempId = insertEntity.rows[0].id;
-    await client.query(
-      `INSERT INTO accounter_schema.businesses (id) VALUES ($1)`,
-      [tempId],
-    );
-
-    // Verify exists within the same transaction
-    const inTx = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.financial_entities WHERE name = $1`,
-      [TEMP_NAME],
-    );
-    expect(inTx.rows[0].count).toBe('1');
-
-    // Note: The afterEach hook will rollback this transaction,
-    // and the next test will start with a clean slate
+        [TEMP_NAME],
+      );
+      const tempId = insertEntity.rows[0].id;
+      await client.query(`INSERT INTO accounter_schema.businesses (id) VALUES ($1)`, [tempId]);
+
+      // Verify exists within the same transaction
+      const inTx = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.financial_entities WHERE name = $1`,
+        [TEMP_NAME],
+      );
+      expect(inTx.rows[0].count).toBe('1');
+
+      // Note: withTransaction automatically rolls back at the end,
+      // so the next test will start with a clean slate
+    });
   });
 
   it('should create all expected entity counts', async () => {
-    await seedAdminCore(client);
-
-    // Count businesses (Admin + 3 authorities = 4)
-    const businessCount = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.businesses`,
-    );
-    expect(parseInt(businessCount.rows[0].count)).toBeGreaterThanOrEqual(4);
-
-    // Count tax categories (3 authority + 12 general + 4 cross-year = 19)
-    const taxCategoryCount = await client.query(
-      `SELECT COUNT(*) as count FROM accounter_schema.tax_categories`,
-    );
-    expect(parseInt(taxCategoryCount.rows[0].count)).toBeGreaterThanOrEqual(19);
+    await db.withTransaction(async client => {
+      await seedAdminCore(client);
+
+      // Count businesses (Admin + 3 authorities = 4)
+      const businessCount = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.businesses`,
+      );
+      expect(parseInt(businessCount.rows[0].count)).toBeGreaterThanOrEqual(4);
+
+      // Count tax categories (3 authority + 12 general + 4 cross-year = 19)
+      const taxCategoryCount = await client.query(
+        `SELECT COUNT(*) as count FROM accounter_schema.tax_categories`,
+      );
+      expect(parseInt(taxCategoryCount.rows[0].count)).toBeGreaterThanOrEqual(19);
+    });
   });
 
   it('should validate foreign key relationships', async () => {
-    const { adminEntityId } = await seedAdminCore(client);
-
-    // Get user_context
-    const userContext = await client.query(
-      `SELECT * FROM accounter_schema.user_context WHERE owner_id = $1`,
-      [adminEntityId],
-    );
-
-    const context = userContext.rows[0];
-
-    // Verify all business FKs point to valid financial_entities
-    const businessFields = [
-      'vat_business_id',
-      'tax_business_id',
-      'social_security_business_id',
-    ];
-
-    for (const field of businessFields) {
-      const businessId = context[field];
-      const entity = await client.query(
-        `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
-        [businessId],
-      );
-      expect(entity.rows).toHaveLength(1);
-      expect(entity.rows[0].type).toBe('business');
-    }
-
-    // Verify all tax_category FKs point to valid financial_entities
-    const taxCategoryFields = [
-      'default_tax_category_id',
-      'input_vat_tax_category_id',
-      'output_vat_tax_category_id',
-    ];
-
-    for (const field of taxCategoryFields) {
-      const taxCategoryId = context[field];
-      const entity = await client.query(
-        `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
-        [taxCategoryId],
+    await db.withTransaction(async client => {
+      const { adminEntityId } = await seedAdminCore(client);
+
+      // Get user_context
+      const userContext = await client.query(
+        `SELECT * FROM accounter_schema.user_context WHERE owner_id = $1`,
+        [adminEntityId],
       );
-      expect(entity.rows).toHaveLength(1);
-      expect(entity.rows[0].type).toBe('tax_category');
-    }
+
+      const context = userContext.rows[0];
+
+      // Verify all business FKs point to valid financial_entities
+      const businessFields = ['vat_business_id', 'tax_business_id', 'social_security_business_id'];
+
+      for (const field of businessFields) {
+        const businessId = context[field];
+        const entity = await client.query(
+          `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
+          [businessId],
+        );
+        expect(entity.rows).toHaveLength(1);
+        expect(entity.rows[0].type).toBe('business');
+      }
+
+      // Verify all tax_category FKs point to valid financial_entities
+      const taxCategoryFields = [
+        'default_tax_category_id',
+        'input_vat_tax_category_id',
+        'output_vat_tax_category_id',
+      ];
+
+      for (const field of taxCategoryFields) {
+        const taxCategoryId = context[field];
+        const entity = await client.query(
+          `SELECT * FROM accounter_schema.financial_entities WHERE id = $1`,
+          [taxCategoryId],
+        );
+        expect(entity.rows).toHaveLength(1);
+        expect(entity.rows[0].type).toBe('tax_category');
+      }
+    });
   });
 });

package/src/demo-fixtures/__tests__/deterministic-uuid.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+import { makeUUID } from '../helpers/deterministic-uuid.js';
+
+describe('deterministic-uuid', () => {
+  describe('makeUUID', () => {
+    it('generates same UUID for same inputs', () => {
+      const uuid1 = makeUUID('business', 'acme-consulting-llc');
+      const uuid2 = makeUUID('business', 'acme-consulting-llc');
+
+      expect(uuid1).toBe(uuid2);
+      expect(uuid1).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    });
+
+    it('generates different UUIDs for different names', () => {
+      const uuid1 = makeUUID('business', 'acme-llc');
+      const uuid2 = makeUUID('business', 'acme-corp');
+
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    it('generates different UUIDs for different namespaces', () => {
+      const businessUUID = makeUUID('business', 'acme');
+      const chargeUUID = makeUUID('charge', 'acme');
+
+      expect(businessUUID).not.toBe(chargeUUID);
+    });
+
+    it('includes namespace in composite key', () => {
+      // Same name, different namespace types
+      const bizUUID = makeUUID('business', 'test-entity');
+      const transactionUUID = makeUUID('transaction', 'test-entity');
+      const documentUUID = makeUUID('document', 'test-entity');
+
+      expect(bizUUID).not.toBe(transactionUUID);
+      expect(bizUUID).not.toBe(documentUUID);
+      expect(transactionUUID).not.toBe(documentUUID);
+    });
+
+    it('generates valid UUID v5 format', () => {
+      const uuid = makeUUID('charge', 'monthly-invoice-2024-11');
+
+      // UUID v5 format: xxxxxxxx-xxxx-5xxx-yxxx-xxxxxxxxxxxx
+      // where y is one of [8, 9, a, b]
+      expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    });
+
+    it('handles kebab-case names correctly', () => {
+      const uuid1 = makeUUID('business', 'us-supplier-acme-llc');
+      const uuid2 = makeUUID('business', 'us-supplier-acme-llc');
+
+      expect(uuid1).toBe(uuid2);
+    });
+
+    it('handles numeric components in names', () => {
+      const uuid1 = makeUUID('charge', 'invoice-2024-11-15');
+      const uuid2 = makeUUID('charge', 'invoice-2024-11-15');
+
+      expect(uuid1).toBe(uuid2);
+    });
+
+    it('is case-sensitive for names', () => {
+      const uuid1 = makeUUID('business', 'acme-llc');
+      const uuid2 = makeUUID('business', 'ACME-LLC');
+
+      expect(uuid1).not.toBe(uuid2);
+    });
+
+    it('is case-sensitive for namespaces', () => {
+      const uuid1 = makeUUID('business', 'acme');
+      const uuid2 = makeUUID('Business', 'acme');
+
+      expect(uuid1).not.toBe(uuid2);
+    });
+  });
+});

package/src/demo-fixtures/helpers/deterministic-uuid.ts

@@ -0,0 +1,68 @@
+import { randomUUID } from 'node:crypto';
+import { v5 as uuidv5 } from 'uuid';
+
+/**
+ * Fixed namespace for all demo data (regenerate on schema-breaking changes if needed).
+ * Using standard DNS namespace UUID as recommended by RFC 4122.
+ */
+const DEMO_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+/**
+ * Generate deterministic UUID v5 from semantic name.
+ *
+ * This function creates stable, reproducible UUIDs for demo/staging data entities.
+ * The same namespace + name combination will always produce the same UUID across
+ * deployments, making it safe to reference these IDs in documentation, screenshots,
+ * and external links.
+ *
+ * @param namespace - Entity type: 'business', 'charge', 'transaction', 'document', etc.
+ * @param name - Semantic identifier (kebab-case recommended)
+ * @returns UUID v5 string (e.g., '550e8400-e29b-41d4-a716-446655440000')
+ *
+ * @example
+ * ```typescript
+ * // Business entity
+ * makeUUID('business', 'acme-consulting-llc')
+ * // => Always produces same UUID
+ *
+ * // Charge entity
+ * makeUUID('charge', 'consulting-invoice-2024-11')
+ * // => Stable across deploys
+ *
+ * // Financial account
+ * makeUUID('financial-account', 'bank-usd-account')
+ * // => Different from makeUUID('business', 'bank-usd-account')
+ * ```
+ *
+ * @remarks
+ * **Naming Conventions:**
+ * - Use kebab-case for all semantic names
+ * - Combine entity type + descriptive name ensures no collisions
+ * - Never change a semantic name once deployed (breaks external links)
+ * - For updates to same entity, append version: `acme-consulting-llc-v2`
+ *
+ * **Stability Warning:**
+ * Once a UUID is generated and used in staging/production, the semantic name
+ * MUST NOT be changed. Doing so will generate a different UUID and break:
+ * - External documentation with embedded links
+ * - Screenshots with visible UUIDs
+ * - Any hardcoded references in client applications
+ *
+ * If you need to modify an entity, create a new semantic name with a version suffix.
+ */
+export function makeUUID(namespace: string, name: string): string {
+  const composite = `${namespace}:${name}`;
+  return uuidv5(composite, DEMO_NAMESPACE);
+}
+
+/**
+ * Backward compatible adapter for legacy single-argument API.
+ * - When seed is provided, returns deterministic UUID v5 scoped under 'legacy' namespace
+ * - When seed omitted, returns a random UUID to preserve previous behavior
+ */
+export function makeUUIDLegacy(seed?: string): string {
+  if (seed === undefined || seed === null) {
+    return randomUUID();
+  }
+  return makeUUID('legacy', seed);
+}

package/src/modules/admin-context/{heplers → helpers}/admin-context.helper.ts

@@ -1,11 +1,11 @@
 import { GraphQLError } from 'graphql';
 import { Injector } from 'graphql-modules';
-import { BusinessesProvider } from '../../../modules/financial-entities/providers/businesses.provider.js';
-import { TaxCategoriesProvider } from '../../../modules/financial-entities/providers/tax-categories.provider.js';
+import { BusinessesProvider } from '../../financial-entities/providers/businesses.provider.js';
+import { TaxCategoriesProvider } from '../../financial-entities/providers/tax-categories.provider.js';
 import type {
   IGetAllTaxCategoriesResult,
   IGetBusinessesByIdsResult,
-} from '../../../modules/financial-entities/types.js';
+} from '../../financial-entities/types.js';
 
 export function fetchTaxCategory(
   injector: Injector,

package/src/modules/admin-context/resolvers/admin-context.resolvers.ts

@@ -2,7 +2,7 @@ import { GraphQLError } from 'graphql';
 import { TagsProvider } from '../../../modules/tags/providers/tags.provider.js';
 import { Currency } from '../../../shared/enums.js';
 import { dateToTimelessDateString } from '../../../shared/helpers/index.js';
-import { fetchBusiness, fetchTaxCategory } from '../heplers/admin-context.helper.js';
+import { fetchBusiness, fetchTaxCategory } from '../helpers/admin-context.helper.js';
 import { AdminContextProvider } from '../providers/admin-context.provider.js';
 import type { AdminContextModule } from '../types.js';
 

package/src/modules/business-trips/providers/business-trips.provider.ts

@@ -1,8 +1,8 @@
 import DataLoader from 'dataloader';
 import { Injectable, Scope } from 'graphql-modules';
 import { sql } from '@pgtyped/runtime';
-import { DBProvider } from '../../../modules/app-providers/db.provider.js';
 import { getCacheInstance } from '../../../shared/helpers/index.js';
+import { DBProvider } from '../../app-providers/db.provider.js';
 import type {
   BusinessTripProto,
   IDeleteChargeBusinessTripQuery,

package/src/modules/charges/helpers/common.helper.ts

@@ -28,13 +28,13 @@ export async function calculateTotalAmount(
     getChargeDocumentsMeta(chargeId, injector),
   ]);
 
-  if (charge.type === 'PAYROLL' && transactionsAmount != null) {
+  if (charge.type === 'PAYROLL' && transactionsAmount) {
     return formatFinancialAmount(transactionsAmount, defaultLocalCurrency);
   }
-  if (documentsAmount != null && documentsCurrency) {
+  if (documentsAmount && documentsCurrency) {
     return formatFinancialAmount(documentsAmount, documentsCurrency);
   }
-  if (transactionsAmount != null && transactionsCurrency) {
+  if (transactionsAmount && transactionsCurrency) {
     return formatFinancialAmount(transactionsAmount, transactionsCurrency);
   }
   return null;

package/src/modules/charges/helpers/{merge-charges.hepler.ts → merge-charges.helper.ts}

@@ -1,10 +1,10 @@
 import { GraphQLError } from 'graphql';
 import { Injector } from 'graphql-modules';
-import { BusinessTripEmployeePaymentsProvider } from '../../../modules/business-trips/providers/business-trips-employee-payments.provider.js';
-import { DocumentsProvider } from '../../../modules/documents/providers/documents.provider.js';
-import { LedgerProvider } from '../../../modules/ledger/providers/ledger.provider.js';
-import { MiscExpensesProvider } from '../../../modules/misc-expenses/providers/misc-expenses.provider.js';
-import { TransactionsProvider } from '../../../modules/transactions/providers/transactions.provider.js';
+import { BusinessTripEmployeePaymentsProvider } from '../../business-trips/providers/business-trips-employee-payments.provider.js';
+import { DocumentsProvider } from '../../documents/providers/documents.provider.js';
+import { LedgerProvider } from '../../ledger/providers/ledger.provider.js';
+import { MiscExpensesProvider } from '../../misc-expenses/providers/misc-expenses.provider.js';
+import { TransactionsProvider } from '../../transactions/providers/transactions.provider.js';
 import { deleteCharges } from './delete-charges.helper.js';
 
 export const mergeChargesExecutor = async (

package/src/modules/charges/resolvers/charges.resolver.ts

@@ -26,7 +26,7 @@ import {
   getChargeTransactionsMeta,
 } from '../helpers/common.helper.js';
 import { deleteCharges } from '../helpers/delete-charges.helper.js';
-import { mergeChargesExecutor } from '../helpers/merge-charges.hepler.js';
+import { mergeChargesExecutor } from '../helpers/merge-charges.helper.js';
 import { ChargeSpreadProvider } from '../providers/charge-spread.provider.js';
 import { ChargeRequiredWrapper, ChargesProvider } from '../providers/charges.provider.js';
 import type {