@bisondesk/core-sdk 1.0.591 → 1.0.593

package/src/apis/activities.ts

@@ -0,0 +1,97 @@
+import { TENANT_ID_ADMIN_HEADER } from '@bisondesk/commons-sdk/constants';
+import { cleanHeaders, fetchJson, getAdminAuth } from '@bisondesk/commons-sdk/fetch';
+import { NextList } from '@bisondesk/commons-sdk/types';
+import { BusinessEntityIds } from '../constants.js';
+import { Activity, ActivityUpdate, ActivityV2Meta, NewActivity } from '../types/activities.js';
+import { DataRecord } from '../types/utils.js';
+
+export const createActivity = async <Meta = ActivityV2Meta>(
+  tenantId: string,
+  activity: NewActivity<Meta>,
+): Promise<DataRecord<Activity<Meta>>> => {
+  const auth = await getAdminAuth();
+  const response: DataRecord<Activity<Meta>> | undefined = await fetchJson(
+    `${process.env.CORE_API_ORIGIN}/api/activities`,
+    {
+      method: 'POST',
+      headers: cleanHeaders({
+        Authorization: auth,
+        [TENANT_ID_ADMIN_HEADER]: tenantId,
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(activity),
+    },
+  );
+
+  if (response == null) {
+    throw new Error('Activity not created');
+  }
+
+  return response;
+};
+
+export const listActivitiesByRecord = async (
+  tenantId: string,
+  businessEntityId: BusinessEntityIds,
+  recordId: string,
+  nextToken?: string,
+): Promise<NextList<DataRecord<Activity>>> => {
+  const auth = await getAdminAuth();
+  const url = new URL(
+    `/api/activities/${businessEntityId}/${recordId}`,
+    process.env.CORE_API_ORIGIN,
+  );
+  if (nextToken != null) {
+    url.searchParams.append('nextToken', nextToken);
+  }
+
+  const response: NextList<DataRecord<Activity>> | undefined = await fetchJson(url, {
+    headers: cleanHeaders({
+      Authorization: auth,
+      [TENANT_ID_ADMIN_HEADER]: tenantId,
+    }),
+  });
+
+  if (response == null) {
+    throw new Error('Failed to list activities');
+  }
+
+  return response;
+};
+
+export const updateActivity = async (
+  tenantId: string,
+  activityId: string,
+  update: ActivityUpdate,
+): Promise<DataRecord<Activity>> => {
+  const auth = await getAdminAuth();
+  const response: DataRecord<Activity> | undefined = await fetchJson(
+    `${process.env.CORE_API_ORIGIN}/api/activities/${activityId}`,
+    {
+      method: 'PATCH',
+      headers: cleanHeaders({
+        Authorization: auth,
+        [TENANT_ID_ADMIN_HEADER]: tenantId,
+        'Content-Type': 'application/json',
+      }),
+      body: JSON.stringify(update),
+    },
+  );
+
+  if (response == null) {
+    throw new Error('Activity not updated');
+  }
+
+  return response;
+};
+
+export const deleteActivity = async (tenantId: string, activityId: string): Promise<void> => {
+  const auth = await getAdminAuth();
+  await fetchJson(`${process.env.CORE_API_ORIGIN}/api/activities/${activityId}`, {
+    method: 'DELETE',
+    headers: cleanHeaders({
+      Authorization: auth,
+      [TENANT_ID_ADMIN_HEADER]: tenantId,
+    }),
+  });
+};

package/src/types/country-pricing.ts

@@ -1,10 +1,25 @@
 import { Categories } from '../constants.js';
 
+type DeliveryFields =
+  | {
+      /** Flat cost in `currency` per vehicle category, added after conversion. */
+      deliveryCostByCategory: Partial<Record<Categories, number>>;
+      /** Human-readable, e.g., "Iquique (Chile)". */
+      deliveryLocation: string;
+    }
+  | { deliveryCostByCategory?: never; deliveryLocation?: never };
+
 export type CountryPricingRule = {
   countryCode: string; // lower-cased ISO 3166-1 alpha-2 (e.g., "cl")
   currency: string; // ISO 4217 (e.g., "USD")
-  rate: number; // Fixed EUR→currency rate (e.g., 1.08)
-  deliveryCostByCategory: Partial<Record<Categories, number>>; // Flat cost in target currency per vehicle category, added after conversion. At least one category is required.
-  deliveryLocation: string; // Human-readable, e.g., "Iquique (Chile)".
+  /**
+   * Fixed multiplier applied to a price expressed in the owning branch's
+   * currency (`branch.currency`) to produce a price in `rule.currency`.
+   * For a tenant whose primary branch is EUR, a Bolivia rule with
+   * `currency: "USD"` carries `rate ≈ 1.08`. For a tenant whose primary
+   * branch is USD, a Belgium rule with `currency: "EUR"` carries
+   * `rate ≈ 0.92`.
+   */
+  rate: number;
   leasing?: boolean; // Override for leasing visibility
-};
+} & DeliveryFields;

package/src/types/transports.ts

@@ -3,7 +3,7 @@ import { Organization } from './crm.js';
 import { Opportunity } from './opportunities.js';
 import { DeliveryTypes } from './quotes.js';
 import { BaseSearchRequest, SortOrder } from './search.js';
-import { DataRecord, ReferenceData } from './utils.js';
+import { ReferenceData } from './utils.js';
 import { Vehicle, VehiclePurchase } from './vehicles.js';
 
 export enum TransportType {

package/src/types/vehicles.ts

@@ -360,6 +360,7 @@ export type VehicleInternalInfo = {
 };
 
 export type VehicleOriginalInfo = {
+  /** IMMEDIATE source tenant (the predecessor in a sync chain). */
   tenantId: string;
   tenantChain?: string[];
   identification: {
@@ -367,6 +368,7 @@ export type VehicleOriginalInfo = {
     branchId: string;
     stockNumber: string;
     metaId?: string;
+    country: string;
   };
   salesConditions: {
     leasing?: boolean;
@@ -378,6 +380,16 @@ export type VehicleOriginalInfo = {
       available?: boolean;
     };
   };
+  /**
+   * Deepest-origin tenant/branch in a multi-hop sync chain. Carries forward
+   * verbatim across hops so consumers can answer "where did this vehicle
+   * actually originate?" without walking the chain.
+   */
+  owner: {
+    tenantId: string;
+    branchId: string;
+    country: string;
+  };
 };
 
 export type VehicleAxlesInfo = {
@@ -523,7 +535,10 @@ export type VehicleExternalInfo = {
       remarks?: string;
       available?: boolean;
     };
-  };
+  } & (
+    | { deliveryCost: number; deliveryLocation: string }
+    | { deliveryCost?: never; deliveryLocation?: never }
+  );
   superstructure?: VehicleSuperstructure;
   weights?: {
     gvw?: number;
@@ -670,6 +685,7 @@ export enum VehiclePurchaseDeliveryType {
 
 export type VehicleStatus = {
   deleted?: boolean;
+  deletedReason?: string;
 };
 
 export type VehiclePriceList = {

package/src/utils/country-pricing.test.ts

@@ -0,0 +1,82 @@
+import { Categories } from '../constants.js';
+import { CountryPricingRule } from '../types/country-pricing.js';
+import {
+  convertFromBranchCurrency,
+  getApplicableDeliveryCost,
+  shouldApplyDeliveryCost,
+} from './country-pricing.js';
+
+const baseRule: CountryPricingRule = {
+  countryCode: 'bo',
+  currency: 'USD',
+  rate: 1.08,
+  deliveryCostByCategory: { [Categories.Truck]: 500 },
+  deliveryLocation: 'La Paz (Bolivia)',
+};
+
+describe('convertFromBranchCurrency', () => {
+  test('multiplies by rate', () => {
+    expect(convertFromBranchCurrency(1000, { rate: 1.08 })).toBe(1080);
+  });
+
+  test('uses Math.ceil to avoid underselling on partial cents', () => {
+    expect(convertFromBranchCurrency(999.5, { rate: 1.0 })).toBe(1000);
+  });
+});
+
+describe('shouldApplyDeliveryCost', () => {
+  test('returns false when origin equals rule country', () => {
+    expect(shouldApplyDeliveryCost({ countryCode: 'bo' }, 'bo')).toBe(false);
+  });
+
+  test('is case-insensitive', () => {
+    expect(shouldApplyDeliveryCost({ countryCode: 'bo' }, 'BO')).toBe(false);
+    expect(shouldApplyDeliveryCost({ countryCode: 'BO' }, 'bo')).toBe(false);
+  });
+
+  test('returns true when origin differs from rule country', () => {
+    expect(shouldApplyDeliveryCost({ countryCode: 'bo' }, 'be')).toBe(true);
+  });
+
+  test('returns true when origin is undefined (safe default)', () => {
+    expect(shouldApplyDeliveryCost({ countryCode: 'bo' }, undefined)).toBe(true);
+  });
+});
+
+describe('getApplicableDeliveryCost', () => {
+  test('returns undefined when same country, even with a configured cost', () => {
+    expect(getApplicableDeliveryCost(baseRule, Categories.Truck, 'bo')).toBeUndefined();
+  });
+
+  test('returns undefined when category is undefined', () => {
+    expect(getApplicableDeliveryCost(baseRule, undefined, 'be')).toBeUndefined();
+  });
+
+  test('returns the matching cost for a different country and known category', () => {
+    expect(getApplicableDeliveryCost(baseRule, Categories.Truck, 'be')).toBe(500);
+  });
+
+  test('returns 0 when the category is explicitly mapped to 0 (opt-in with no fee)', () => {
+    const zeroFeeRule: CountryPricingRule = {
+      countryCode: 'bo',
+      currency: 'USD',
+      rate: 1.08,
+      deliveryCostByCategory: { [Categories.Truck]: 0 },
+      deliveryLocation: 'Bolivia',
+    };
+    expect(getApplicableDeliveryCost(zeroFeeRule, Categories.Truck, 'be')).toBe(0);
+  });
+
+  test('returns undefined when category has no configured cost', () => {
+    expect(getApplicableDeliveryCost(baseRule, Categories.Van, 'be')).toBeUndefined();
+  });
+
+  test('returns undefined when rule has no deliveryCostByCategory at all', () => {
+    const pureRateRule: CountryPricingRule = {
+      countryCode: 'bo',
+      currency: 'USD',
+      rate: 1.08,
+    };
+    expect(getApplicableDeliveryCost(pureRateRule, Categories.Truck, 'be')).toBeUndefined();
+  });
+});

package/src/utils/country-pricing.ts

@@ -0,0 +1,44 @@
+import { Categories } from '../constants.js';
+import { CountryPricingRule } from '../types/country-pricing.js';
+
+/**
+ * Should the delivery cost defined by `rule` be applied for a vehicle whose
+ * origin branch is in `originCountry`? Returns `false` when the vehicle is
+ * already located in the rule's country (case-insensitive ISO-2 compare).
+ */
+export const shouldApplyDeliveryCost = (
+  rule: Pick<CountryPricingRule, 'countryCode'>,
+  originCountry: string | undefined,
+): boolean => {
+  if (originCountry == null) {
+    return true;
+  }
+  return originCountry.toLowerCase() !== rule.countryCode.toLowerCase();
+};
+
+/**
+ * Look up the per-category delivery cost on the rule. Returns `undefined` when delivery is
+ * not applicable (same-country suppression, missing category, or category not in the rule's
+ * map). Returns the configured number — including `0` — when the rule explicitly covers the
+ * category. A `0` is a legitimate value: the operator has opted in for this category but is
+ * charging no fee on top (e.g. for vehicles already at the rule's `deliveryLocation`).
+ */
+export const getApplicableDeliveryCost = (
+  rule: CountryPricingRule,
+  category: string | undefined,
+  originCountry: string | undefined,
+): number | undefined => {
+  if (!shouldApplyDeliveryCost(rule, originCountry)) {
+    return undefined;
+  }
+  if (category == null) {
+    return undefined;
+  }
+  return rule.deliveryCostByCategory?.[category as Categories];
+};
+
+/** Convert an amount in the owning branch's currency to `rule.currency`. */
+export const convertFromBranchCurrency = (
+  branchAmount: number,
+  rule: Pick<CountryPricingRule, 'rate'>,
+): number => Math.ceil(branchAmount * rule.rate);