@bisondesk/core-sdk 1.0.608 → 1.0.609

package/src/utils/accounting.test.ts

@@ -0,0 +1,89 @@
+import { Branch, Tenant } from '../types/tenants.js';
+import { branchHasAccounting, branchProvider, tenantHasAccounting } from './accounting.js';
+
+const makeBranch = (overrides: Partial<Branch> = {}): Branch => ({
+  id: 'b1',
+  name: 'Branch 1',
+  country: 'ci',
+  language: 'fr',
+  currency: 'XOF',
+  adminNumberPrefix: '',
+  stockNumberPrefix: '',
+  vatNumber: '',
+  vatRates: { standard: '18' },
+  location: { country: 'ci' },
+  ...overrides,
+});
+
+const makeTenant = (branches: Branch[], overrides: Partial<Tenant> = {}): Tenant =>
+  ({
+    id: 't',
+    name: 't',
+    region: 'eu-west-1',
+    defaultCountry: 'ci',
+    defaultCurrency: 'XOF',
+    defaultLanguage: 'fr',
+    subdomains: ['t'],
+    languages: ['fr'],
+    emailDomain: 'example.com',
+    branches: branches as [Branch, ...Branch[]],
+    modules: [],
+    opportunities: { types: [] },
+    ...overrides,
+  }) as Tenant;
+
+describe('branchProvider', () => {
+  it('returns undefined for missing branch', () => {
+    expect(branchProvider(undefined)).toBeUndefined();
+  });
+
+  it('prefers the new discriminator over the legacy boolean', () => {
+    const branch = makeBranch({ accounting: 'odoo', exactAccounting: true });
+    expect(branchProvider(branch)).toBe('odoo');
+  });
+
+  it('falls back to legacy boolean as exact', () => {
+    const branch = makeBranch({ exactAccounting: true });
+    expect(branchProvider(branch)).toBe('exact');
+  });
+
+  it('returns undefined when neither field is set', () => {
+    expect(branchProvider(makeBranch())).toBeUndefined();
+  });
+
+  it('returns undefined when legacy boolean is false', () => {
+    expect(branchProvider(makeBranch({ exactAccounting: false }))).toBeUndefined();
+  });
+});
+
+describe('branchHasAccounting', () => {
+  it('is true when accounting is set', () => {
+    expect(branchHasAccounting(makeBranch({ accounting: 'odoo' }))).toBe(true);
+  });
+
+  it('is true when legacy exactAccounting is true', () => {
+    expect(branchHasAccounting(makeBranch({ exactAccounting: true }))).toBe(true);
+  });
+
+  it('is false otherwise', () => {
+    expect(branchHasAccounting(makeBranch())).toBe(false);
+    expect(branchHasAccounting(undefined)).toBe(false);
+  });
+});
+
+describe('tenantHasAccounting', () => {
+  it('is true when tenant-level legacy flag is set', () => {
+    const tenant = makeTenant([makeBranch()], { exactAccounting: true });
+    expect(tenantHasAccounting(tenant)).toBe(true);
+  });
+
+  it('is true when any branch has accounting', () => {
+    const tenant = makeTenant([makeBranch(), makeBranch({ id: 'b2', accounting: 'odoo' })]);
+    expect(tenantHasAccounting(tenant)).toBe(true);
+  });
+
+  it('is false when no branch has accounting and tenant flag is not set', () => {
+    expect(tenantHasAccounting(makeTenant([makeBranch()]))).toBe(false);
+    expect(tenantHasAccounting(undefined)).toBe(false);
+  });
+});

package/src/utils/accounting.ts

@@ -0,0 +1,24 @@
+import { AccountingProvider, Branch, Tenant } from '../types/tenants.js';
+
+export const branchProvider = (branch: Branch | undefined): AccountingProvider | undefined => {
+  if (branch == null) {
+    return undefined;
+  }
+  if (branch.accounting != null) {
+    return branch.accounting;
+  }
+  return branch.exactAccounting ? 'exact' : undefined;
+};
+
+export const branchHasAccounting = (branch: Branch | undefined): boolean =>
+  branchProvider(branch) != null;
+
+export const tenantHasAccounting = (tenant: Tenant | undefined): boolean => {
+  if (tenant == null) {
+    return false;
+  }
+  if (tenant.exactAccounting) {
+    return true;
+  }
+  return tenant.branches.some((b) => branchHasAccounting(b));
+};