@bisondesk/core-sdk 1.0.607 → 1.0.609

package/src/types/reports-sales.ts

@@ -66,6 +66,13 @@ export type SalesReportSalesperson = {
   yoyPct: number | null;
 };
 
+export type SalesReportMake = {
+  /** Vehicle make name from `vehicle.external.general.make` (stored verbatim, e.g. "DAF"). */
+  make: string;
+  units: number;
+  yoyPct: number | null;
+};
+
 /** A conglomerate-flagged organization (there is no group/parent model — each org stands alone). */
 export type SalesReportConglomerateOrg = {
   /** `org.id`. */
@@ -116,6 +123,8 @@ export type SalesReportResponse = {
   };
   /** Top countries by units in the current window. */
   countries: SalesReportCountry[];
+  /** Top vehicle makes by units in the current window (the client slices to its top N). */
+  makes: SalesReportMake[];
   /** All sales people with units in either window (capped; the client list scrolls). */
   salespeople: SalesReportSalesperson[];
   /** Returning-customer tenure shares (4 buckets). */

package/src/types/tenants.ts

@@ -61,12 +61,16 @@ export type Tenant = PublicTenant & {
   };
 };
 
+export type AccountingProvider = 'exact' | 'odoo';
+
 export type Branch = {
   id: string;
   name: string;
   country: string;
   language: string;
+  /* deprecated — use `accounting === 'exact'` instead. Kept until prod cutover. */
   exactAccounting?: boolean;
+  accounting?: AccountingProvider;
   currency: string;
   adminNumberPrefix: string;
   stockNumberPrefix: string;

package/src/types/user-performance.ts

@@ -151,6 +151,7 @@ export type PerformanceVehicle = {
   sellerId?: string;
   purchaseAt?: string;
   purchaserId?: string;
+  customerName?: string;
 };
 
 export type PerformanceVehiclesRequest = {

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));
+};