@salesforce/lds-runtime-mobile 1.461.0 → 1.463.0

package/sfdc/types/drafts/records/actionHandlers/SideEffectHook.d.ts

@@ -1,19 +1,20 @@
 import type { SideEffect } from '../../sideEffects';
+import type { RecordReader } from '../../../durableStore/MemoizingRecordReader';
 interface BaseSideEffectHook {
     on: 'post' | 'patch' | 'delete';
     apiName: string;
 }
 export interface CreateSideEffectHook extends BaseSideEffectHook {
     on: 'post';
-    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
 }
 export interface UpdateSideEffectHook extends BaseSideEffectHook {
     on: 'patch';
-    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
 }
 export interface DeleteSideEffectHook extends BaseSideEffectHook {
     on: 'delete';
-    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string): Promise<SideEffect[]>;
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields?: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
 }
 export type SideEffectHook = CreateSideEffectHook | UpdateSideEffectHook | DeleteSideEffectHook;
 export {};

package/sfdc/types/drafts/sideEffects/SideEffectHandler.d.ts

@@ -1,5 +1,5 @@
 import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
-import type { CreateRecordSideEffect, DeleteRecordSideEffect, FieldIncrementSideEffect, UpdateRecordSideEffect } from './sideEffects';
+import type { CreateRecordSideEffect, DeleteRecordSideEffect, FieldIncrementSideEffect, FieldSetSideEffect, UpdateRecordSideEffect } from './sideEffects';
 export interface SideEffectHandler<EntryType, EffectType> {
     apply(entry: EntryType | undefined, effect: EffectType): EntryType | undefined;
 }
@@ -16,3 +16,7 @@ export declare class RecordFieldIncrementHandler implements SideEffectHandler<Du
     private logger;
     apply(record: DurableRecordRepresentation | undefined, effect: FieldIncrementSideEffect): DurableRecordRepresentation | undefined;
 }
+export declare class RecordFieldSetHandler implements SideEffectHandler<DurableRecordRepresentation, FieldSetSideEffect> {
+    private logger;
+    apply(record: DurableRecordRepresentation | undefined, effect: FieldSetSideEffect): DurableRecordRepresentation | undefined;
+}

package/sfdc/types/drafts/sideEffects/sideEffects.d.ts

@@ -21,7 +21,12 @@ export interface FieldIncrementSideEffect extends BaseRecordSideEffect {
     fieldName: string;
     value: number;
 }
-export type SideEffect = CreateRecordSideEffect | UpdateRecordSideEffect | DeleteRecordSideEffect | FieldIncrementSideEffect;
+export interface FieldSetSideEffect extends BaseRecordSideEffect {
+    type: 'record-field-set';
+    fieldName: string;
+    value: boolean | number | string | null;
+}
+export type SideEffect = CreateRecordSideEffect | UpdateRecordSideEffect | DeleteRecordSideEffect | FieldIncrementSideEffect | FieldSetSideEffect;
 /**
  * Removes any existing effects on a record and re-applies the given ordered list and returns the record
  * with the updated side effects applied.

package/sfdc/types/durableStore/MemoizingRecordReader.d.ts

@@ -0,0 +1,29 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { DurableRecordStore } from './DurableRecordStore';
+/**
+ * The minimal record-read surface the SFS side-effect hooks depend on. Both
+ * `DurableRecordStore` and `MemoizingRecordReader` satisfy it, so a hook can be handed either
+ * one: the raw store, or a per-action memoizer that dedups reads.
+ */
+export interface RecordReader {
+    getRecord(key: string): Promise<DurableRecordRepresentation | undefined>;
+}
+/**
+ * A read-through cache over `DurableRecordStore.getRecord` scoped to a single draft-action
+ * dispatch. Multiple side-effect hooks fire for one action (e.g. the van-stock and
+ * IsProduct2Serialized ProductConsumed hooks) and are awaited one at a time, so they otherwise
+ * each re-read the same draft record — and the IsProduct2Serialized chain re-reads the same
+ * related ProductItem / Product2 — from the durable store. Sharing one reader across the
+ * action's hooks collapses those repeated reads to a single durable call per key.
+ *
+ * The cache stores the in-flight promise (not the resolved value) so concurrent reads of the
+ * same key share one durable call, and it caches `undefined` results so a miss is not re-fetched.
+ * A reader must not outlive one action dispatch: durable state changes between actions, so a
+ * longer-lived cache would return stale records.
+ */
+export declare class MemoizingRecordReader implements RecordReader {
+    private readonly durableRecordStore;
+    private readonly cache;
+    constructor(durableRecordStore: DurableRecordStore);
+    getRecord(key: string): Promise<DurableRecordRepresentation | undefined>;
+}

package/sfdc/types/sfs/ProductConsumedSideEffects.d.ts

@@ -1,7 +1,7 @@
 import type { SideEffect } from '../drafts/sideEffects';
 import type { CreateSideEffectHook, DeleteSideEffectHook, UpdateSideEffectHook } from '../drafts/records/actionHandlers/SideEffectHook';
 import type { DurableRecordStore } from '../durableStore/DurableRecordStore';
-export declare const instrumentation: any;
+import type { RecordReader } from '../durableStore/MemoizingRecordReader';
 export declare class ProductConsumedCreatedHook implements CreateSideEffectHook {
     on: 'post';
     apiName: string;
@@ -14,7 +14,7 @@ export declare class ProductConsumedUpdatedHook implements UpdateSideEffectHook
     apiName: string;
     private static COUNTER_NAME;
     constructor(durableRecordStore: DurableRecordStore);
-    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
 }
 export declare class ProductConsumedDeletedHook implements DeleteSideEffectHook {
     private readonly durableRecordStore;
@@ -22,5 +22,48 @@ export declare class ProductConsumedDeletedHook implements DeleteSideEffectHook
     apiName: string;
     private static COUNTER_NAME;
     constructor(durableRecordStore: DurableRecordStore);
-    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string): Promise<SideEffect[]>;
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, _fields?: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductConsumed` record.
+ *
+ * `Product2Id` is not createable on `ProductConsumed`, so the draft only carries the
+ * `ProductItemId`. The value is resolved through the related `ProductItem` record (see
+ * `resolveIsProduct2SerializedFromProductItem`): the ProductItem's own
+ * `IsProduct2Serialized` when cached, otherwise `ProductItem.Product2Id` ->
+ * `Product2.IsSerialized`. When the chain cannot be resolved the hook exits without an
+ * effect and the field is left as synthesized (null).
+ */
+export declare class ProductConsumedIsSerializedCreatedHook implements CreateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'post';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductConsumed` record.
+ *
+ * A `patch` body only carries changed fields, so the related `ProductItemId` may be absent.
+ * The id is resolved by preferring the patch body (the link is being reassigned) and falling
+ * back to the original record in the durable store, then the value is resolved through that
+ * `ProductItem` exactly as on create (see `resolveIsProduct2SerializedFromProductItem`).
+ *
+ * When the patch explicitly clears `ProductItemId` (sets it to `null`) the record no longer
+ * derives from any `ProductItem`, so `IsProduct2Serialized` is cleared (set to `null`) rather
+ * than resolved from the now-stale original link. Likewise, when the patch reassigns
+ * `ProductItemId` to a new id whose chain isn't cached, the stored value reflects the old link
+ * and is stale, so it is cleared. When the link is unchanged and its chain cannot be resolved,
+ * the stored value is still correct so the hook exits without an effect and leaves it unchanged.
+ */
+export declare class ProductConsumedIsSerializedUpdatedHook implements UpdateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'patch';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
 }

package/sfdc/types/sfs/ProductItemSideEffects.d.ts

@@ -0,0 +1,46 @@
+import type { SideEffect } from '../drafts/sideEffects';
+import type { CreateSideEffectHook, UpdateSideEffectHook } from '../drafts/records/actionHandlers/SideEffectHook';
+import type { DurableRecordStore } from '../durableStore/DurableRecordStore';
+import type { RecordReader } from '../durableStore/MemoizingRecordReader';
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductItem` record.
+ *
+ * Unlike `ProductConsumed`/`ProductTransfer` — which reach the product through a related
+ * `ProductItem` — a `ProductItem` carries `Product2Id` directly, so the value is resolved as
+ * `Product2Id` -> `Product2.IsSerialized` (see `resolveIsSerializedFromProduct2Id`). When the
+ * chain cannot be resolved the hook exits without an effect and the field is left as
+ * synthesized (null).
+ */
+export declare class ProductItemIsSerializedCreatedHook implements CreateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'post';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductItem` record.
+ *
+ * A `patch` body only carries changed fields, so `Product2Id` may be absent; it is resolved by
+ * preferring the patch body (the product is being reassigned) and falling back to the original
+ * record in the durable store, then resolved as `Product2Id` -> `Product2.IsSerialized` (see
+ * `resolveIsSerializedFromProduct2Id`).
+ *
+ * When the patch explicitly clears `Product2Id` (sets it to `null`) the record no longer
+ * derives from any `Product2`, so `IsProduct2Serialized` is cleared (set to `null`) rather than
+ * resolved from the now-stale original link. Likewise, when the patch reassigns `Product2Id` to
+ * a new id whose `Product2` isn't cached, the stored value reflects the old link and is stale,
+ * so it is cleared. When the link is unchanged and its `Product2` cannot be resolved, the stored
+ * value is still correct so the hook exits without an effect and leaves it unchanged.
+ */
+export declare class ProductItemIsSerializedUpdatedHook implements UpdateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'patch';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}

package/sfdc/types/sfs/ProductTransferSideEffects.d.ts

@@ -0,0 +1,49 @@
+import type { SideEffect } from '../drafts/sideEffects';
+import type { CreateSideEffectHook, UpdateSideEffectHook } from '../drafts/records/actionHandlers/SideEffectHook';
+import type { DurableRecordStore } from '../durableStore/DurableRecordStore';
+import type { RecordReader } from '../durableStore/MemoizingRecordReader';
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductTransfer` record.
+ *
+ * The value is resolved through the related `SourceProductItem` record (a `ProductItem`),
+ * mirroring the `ProductConsumed` hook: the ProductItem's own `IsProduct2Serialized` when
+ * cached, otherwise `ProductItem.Product2Id` -> `Product2.IsSerialized` (see
+ * `resolveIsProduct2SerializedFromProductItem`). When the chain cannot be resolved the hook
+ * exits without an effect and the field is left as synthesized (null).
+ */
+export declare class ProductTransferIsSerializedCreatedHook implements CreateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'post';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductTransfer` record.
+ *
+ * ProductTransfer can only be edited (not created) on mobile, so this is the hook that fires
+ * in practice. A `patch` body only carries changed fields, so the related `SourceProductItemId`
+ * may be absent; the id is resolved by preferring the patch body (the link is being reassigned)
+ * and falling back to the original record in the durable store, then the value is resolved
+ * through that `ProductItem` exactly as on create (see
+ * `resolveIsProduct2SerializedFromProductItem`).
+ *
+ * When the patch explicitly clears `SourceProductItemId` (sets it to `null`) the record no
+ * longer derives from any `ProductItem`, so `IsProduct2Serialized` is cleared (set to `null`)
+ * rather than resolved from the now-stale original link. Likewise, when the patch reassigns
+ * `SourceProductItemId` to a new id whose chain isn't cached, the stored value reflects the old
+ * link and is stale, so it is cleared. When the link is unchanged and its chain cannot be
+ * resolved, the stored value is still correct so the hook exits without an effect and leaves it
+ * unchanged.
+ */
+export declare class ProductTransferIsSerializedUpdatedHook implements UpdateSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'patch';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string, fields: Record<string, any>, reader?: RecordReader): Promise<SideEffect[]>;
+}

package/sfdc/types/sfs/sfsIsProduct2Serialized.d.ts

@@ -0,0 +1,88 @@
+import type { RecordReader } from '../durableStore/MemoizingRecordReader';
+import type { DurableRecordRepresentationFields } from '@salesforce/lds-durable-records';
+export declare const instrumentation: any;
+export declare enum CounterResult {
+    Created = "Created",
+    Exited = "Exited",
+    Error = "Error"
+}
+export declare function incrementCounter(name: string, result: CounterResult): void;
+/**
+ * Reads a string-valued field off a draft-create `fields` map (the raw create body, where
+ * values are the primitives themselves rather than `{ value }` wrappers). Returns `undefined`
+ * when the field is absent or not a string.
+ */
+export declare function getStringDraftField(fields: Record<string, any>, fieldName: string): string | undefined;
+/**
+ * Reads a string-valued field off a durable record's `fields` map (where each value is a
+ * `{ value }` wrapper). Returns `undefined` when the field is absent, null, or not a string.
+ */
+export declare function getStringRecordField(fields: DurableRecordRepresentationFields, fieldName: string): string | undefined;
+/**
+ * The outcome of resolving a related reference id (e.g. `ProductItemId`,
+ * `SourceProductItemId`, `Product2Id`) on a draft edit:
+ *
+ *   - `resolved`  — a usable id was found. `source` records where it came from, because the two
+ *                   cases differ when the id's chain can't be resolved downstream:
+ *                     - `'patch'`    — the link was reassigned to a new id in the patch body. If
+ *                        its chain can't be resolved, the stored `IsProduct2Serialized` reflects
+ *                        the OLD link and is now stale, so the caller must clear it (set null).
+ *                     - `'original'` — the patch left the link untouched and it fell back to the
+ *                        original durable record. If its chain can't be resolved, the stored
+ *                        value is still correct for the unchanged link, so the caller leaves it.
+ *   - `cleared`   — the patch explicitly set the link to `null`; the record no longer derives
+ *                   from any related record, so the caller should clear `IsProduct2Serialized`
+ *                   rather than fall back to the now-stale original id.
+ *   - `unresolved`— no usable id and no explicit clear (link absent from the patch and missing
+ *                   from the original record); the caller exits without an effect.
+ */
+export type ReferenceIdForUpdate = {
+    kind: 'resolved';
+    id: string;
+    source: 'patch' | 'original';
+} | {
+    kind: 'cleared';
+} | {
+    kind: 'unresolved';
+};
+/**
+ * Resolves the reference id that points at a related record for a draft edit.
+ *
+ * On a `patch` the body only carries the fields being changed, so the link field may be
+ * absent, present with a new id, or present but explicitly `null` (the link is being cleared).
+ * These three cases are distinguished via `hasOwnProperty` because they demand different
+ * behavior — falling back to the original durable-store id on an explicit `null` would resolve
+ * `IsProduct2Serialized` from a relationship the record no longer has:
+ *
+ *   - present + string -> `resolved` with the reassigned id.
+ *   - present + null   -> `cleared`.
+ *   - absent           -> fall back to the original record; `resolved` when it carries a usable
+ *                         string, otherwise `unresolved`.
+ */
+export declare function resolveReferenceIdForUpdate(patchFields: Record<string, any>, originalFields: DurableRecordRepresentationFields, fieldName: string): ReferenceIdForUpdate;
+/**
+ * Resolves the server-derived `IsProduct2Serialized` boolean for a draft-created record by
+ * following the related `ProductItem`:
+ *
+ *   1. If the cached `ProductItem` already carries `IsProduct2Serialized`, use it directly
+ *      (it mirrors the linked product's serialization, and avoids a second durable read).
+ *   2. Otherwise fall back to the linked `Product2`:
+ *      `ProductItem.Product2Id` -> `Product2.IsSerialized`.
+ *
+ * All lookups go through the given `RecordReader` (the durable store, or a per-action memoizer
+ * that dedups reads). Returns `undefined` when a link in the chain is missing so the caller can
+ * exit without an effect and leave the field synthesized (null). Callers pass their own
+ * `counterName` so instrumentation is attributed to the owning hook.
+ */
+export declare function resolveIsProduct2SerializedFromProductItem(recordReader: RecordReader, productItemId: string, counterName: string): Promise<boolean | undefined>;
+/**
+ * Resolves the `Product2.IsSerialized` boolean for a given `Product2Id` by reading the linked
+ * `Product2` record through the given `RecordReader`. Used directly by the `ProductItem` hooks
+ * (which carry `Product2Id` themselves) and as the fallback tail of
+ * `resolveIsProduct2SerializedFromProductItem`.
+ *
+ * Returns `undefined` when the `Product2` record is missing so the caller can exit without an
+ * effect and leave the field synthesized (null). Callers pass their own `counterName` so
+ * instrumentation is attributed to the owning hook.
+ */
+export declare function resolveIsSerializedFromProduct2Id(recordReader: RecordReader, product2Id: string, counterName: string): Promise<boolean | undefined>;