@bisondesk/core-sdk 1.0.608 → 1.0.610

package/src/utils/accounting.test.ts

@@ -0,0 +1,115 @@
+import { Branch, Tenant } from '../types/tenants.js';
+import {
+  branchHasAccounting,
+  branchHasAccountingInTenant,
+  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);
+  });
+});
+
+describe('branchHasAccountingInTenant', () => {
+  it('resolves per branch in a mixed tenant', () => {
+    const tenant = makeTenant([
+      makeBranch({ id: 'odoo-branch', accounting: 'odoo' }),
+      makeBranch({ id: 'plain-branch' }),
+    ]);
+    expect(branchHasAccountingInTenant(tenant, 'odoo-branch')).toBe(true);
+    expect(branchHasAccountingInTenant(tenant, 'plain-branch')).toBe(false);
+  });
+
+  it('ignores the deprecated tenant-wide flag and resolves per branch', () => {
+    const tenant = makeTenant([makeBranch({ id: 'plain-branch' })], { exactAccounting: true });
+    expect(branchHasAccountingInTenant(tenant, 'plain-branch')).toBe(false);
+  });
+
+  it('is false for an unknown branch or missing tenant', () => {
+    expect(branchHasAccountingInTenant(makeTenant([makeBranch()]), 'nope')).toBe(false);
+    expect(branchHasAccountingInTenant(undefined, 'b1')).toBe(false);
+  });
+});

package/src/utils/accounting.ts

@@ -0,0 +1,40 @@
+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));
+};
+
+/**
+ * Whether a specific branch books through an accounting integration. Resolves
+ * purely per branch — a tenant can mix accounting and non-accounting branches.
+ * Accounting is carried on the branch (`accounting`, or the deprecated
+ * `exactAccounting`), so the tenant-wide flag is not consulted.
+ */
+export const branchHasAccountingInTenant = (
+  tenant: Tenant | undefined,
+  branchId: string,
+): boolean => {
+  if (tenant == null) {
+    return false;
+  }
+  return branchHasAccounting(tenant.branches.find((b) => b.id === branchId));
+};