@opencxh/domain 1.246.0 → 1.248.0

package/dist/entities/business-entity/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/entities/business-entity/types.d.ts

@@ -0,0 +1,74 @@
+import { PostalAddress } from '../organization/types';
+/**
+ * The service-bus key `apps/organization` answers with its administrations.
+ *
+ * Here and not as a literal in each consumer: the key belongs to the record, and a consumer that
+ * spells it itself is a consumer that keeps spelling it after the owner renames it.
+ */
+export declare const BUSINESS_ENTITY_LIST_SERVICE = "organization.business-entities.list";
+/**
+ * One set of books with one letterhead: a BV, a VOF, a foreign branch.
+ *
+ * Two of these in one workspace is the Odoo/Exact "divisions" model — one inbox, one CRM, one
+ * team, two sets of books. It is deliberately **not** a second tenant (that is
+ * `Organization.parentId`, and it splits the inbox and the CRM too) and **not** a rung of
+ * {@link OwnerScope}: an entity says which party issues a document and which books it lands in,
+ * never who may read it.
+ *
+ * Absent is the normal case. An organisation with one entity is an organisation that never sees
+ * the concept, and that path must keep working — which is why no field here is required beyond
+ * the name, and why no existing row anywhere needs a write.
+ */
+export interface BusinessEntity {
+    id: string;
+    organizationId: string;
+    /** The legal name, as it goes on the paper. */
+    name: string;
+    /** Short code for the badge and, from the numbering phase, the default number prefix. */
+    code?: string;
+    address?: PostalAddress;
+    /**
+     * The three identifications that belong together and today live on two different objects —
+     * `billing.vatNumber` / `billing.kvkNumber` on the organisation, `houseStyle.iban` beside it.
+     * The reason they were split ("a second copy is the one that goes stale") falls away here.
+     */
+    vatNumber?: string;
+    kvkNumber?: string;
+    iban?: string;
+    /** Inline data-URI, same rule as `Organization.logo`. */
+    logo?: string;
+    accentColor?: string;
+    footerText?: string;
+    /**
+     * The language this entity writes in.
+     *
+     * The floor of `recipientLocale`, which never had one: `Organization` carries no locale, so the
+     * whole ladder was dead at its one call site. It belongs here and not on the tenant — a Dutch
+     * BV and its Belgian sister write different default languages under one workspace.
+     */
+    locale?: string;
+    /** One per entity: an administration is set up per country and per currency. */
+    currency?: string;
+    /** The one a new document lands on. Exactly one row carries it. */
+    isDefault?: boolean;
+    /** Archived, never deleted: an issued quote names the entity it went out as. */
+    archived?: boolean;
+    order?: number;
+    createdBy: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** What {@link businessEntitySender} reads. Structural, so the document layer keeps pointing here. */
+export type BusinessEntityLike = Pick<BusinessEntity, "name" | "address" | "vatNumber" | "kvkNumber" | "iban" | "logo" | "footerText">;
+/**
+ * Does this row belong to this entity?
+ *
+ * Master data is owned by **exactly one** entity — two administrations with the same offering
+ * keep two rows. An unset owner means the **default** entity, and that is what makes this cost no
+ * backfill: every product written before entities existed keeps showing up where it always did,
+ * and the first save stamps it for real.
+ *
+ * The check runs in memory because the rows are loaded whole anyway, and because "the field is
+ * unset" is not expressible as a filter on this platform — there is no `$exists`.
+ */
+export declare function belongsToEntity(rowEntityId: string | undefined, entityId: string, isDefaultEntity: boolean): boolean;

package/dist/entities/business-entity/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/catalog/types.d.ts

@@ -50,6 +50,14 @@ export interface Product {
     costPriceCents?: Cents;
     /** Who we buy it from. A `Company` in crm, so free — and all a later purchase order needs. */
     supplierCompanyId?: string;
+    /**
+     * The administration this belongs to. Unset = the default one — see `belongsToEntity`.
+     *
+     * Exactly one, not a list: two administrations that both sell this keep two rows, with their
+     * own sku, their own price and their own ledger category. That is the price of a hard split and
+     * it is what was chosen.
+     */
+    businessEntityId?: string;
     archived?: boolean;
     order?: number;
     createdBy: string;
@@ -91,6 +99,8 @@ export interface PriceRule {
      * contract price is not a second pricing mechanism, it is a price rule with an owner and a term.
      */
     contractId?: string;
+    /** The administration this rule belongs to. Unset = the default one. */
+    businessEntityId?: string;
     createdBy: string;
     createdAt?: number;
 }

package/dist/entities/document-template/types.d.ts

@@ -1,4 +1,5 @@
 import { DocumentBlock } from '../../platform/document-blocks';
+import { BusinessEntityLike } from '../business-entity/types';
 import { PostalAddress } from '../organization/types';
 /**
  * A document template: the blocks a generated document is built from.
@@ -104,11 +105,19 @@ export interface DocumentSender {
     logo?: string;
 }
 /**
- * An organisation's details as a letterhead.
+ * A sending entity's details as a letterhead.
  *
- * Every field is optional on `Organization`, so every line here is conditional: a half-filled
- * organisation gets a short letterhead, never `undefined, undefined`. The billing name wins over
- * the display name — what is on a quote is the legal entity.
+ * Every field is optional, so every line here is conditional: a half-filled entity gets a short
+ * letterhead, never `undefined, undefined`. **Nothing is inherited from the organisation** — a
+ * second BV that has not filled in its own KvK number prints no number rather than the first
+ * BV's, because this is a legal document. The issue gate catches the hole instead.
+ */
+export declare function businessEntitySender(entity: BusinessEntityLike | null | undefined): DocumentSender;
+/**
+ * The organisation as a letterhead. One caller left: the seed that gives an organisation its
+ * first `BusinessEntity`. An adapter and not a second line-builder, so the two can never drift.
+ *
+ * The billing name wins over the display name — what is on a quote is the legal entity.
  */
 export declare function organizationSender(organization: OrganizationLike | null | undefined): DocumentSender;
 /**

package/dist/entities/money/tax.d.ts

@@ -7,6 +7,15 @@
  */
 export interface TaxRate {
     key: string;
+    /**
+     * Which sending entity this rate belongs to. Empty = every entity.
+     *
+     * A scalar and **not** a list, unlike the rest of the master data: a Belgian sister entity does
+     * not need the `low` rate *hidden*, it needs a different percentage for the same key. That is an
+     * override, and a membership list cannot express one. An entity's own row shadows the shared row
+     * with the same key.
+     */
+    businessEntityId?: string;
     /** i18n key, not text — the same rule as `FIXED_TYPES` in work. */
     label: string;
     /** Whole percent as written on the invoice: `21`, not `0.21`. */

package/dist/entities/transaction/keys.d.ts

@@ -14,3 +14,20 @@ export declare function transactionScopeKey(kindKey: string, id: string): string
 export declare function productScopeKey(id: string): string;
 /** Is this scopeKey one of ours, and which id does it point at? */
 export declare function transactionIdFromScope(scopeKey: string): string | undefined;
+/**
+ * A transaction's file keys: itself, and the customer it is for.
+ *
+ * That second one is what puts a quote in the customer file without anybody linking it by hand:
+ * the relation hub matches on shared keys, so `company:<id>` on the quote makes it a *derived*
+ * row under that company — a lead, not a statement.
+ *
+ * Bounded by the row itself, on purpose. These ride along on every authorisation, including every
+ * memory write; a list that grows with the transaction would be paid for on each one.
+ */
+export declare function transactionDossierKeys(transaction: {
+    id: string;
+    kindKey: string;
+    companyId?: string;
+    contactId?: string;
+    dealItemId?: string;
+}): string[];

package/dist/entities/transaction/keys.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entities/transaction/types.d.ts

@@ -25,6 +25,13 @@ export interface Transaction {
     /** Version within the same quote. A sent quote is revised, never edited. */
     version: number;
     previousVersionId?: string;
+    /**
+     * Which sending entity issues this — whose letterhead, whose books, whose number series.
+     *
+     * Empty means the organisation's default. Frozen at issue: it is not in
+     * {@link FROZEN_WRITABLE_FIELDS}, so changing it on a sent document is already refused.
+     */
+    businessEntityId?: string;
     companyId: string;
     contactId?: string;
     /** The work item (the deal) this belongs to. Optional: not every quote has a deal. */