@salesforce/lds-runtime-mobile 1.319.0 → 1.321.0

package/sfdc/types/graphql/syntheticFields.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentNode } from '@luvio/graphql-parser';
+import type { DraftFunctions } from './types';
+import type { GraphQLRepresentationData } from '@salesforce/lds-adapters-uiapi';
+import type { ObjectInfoService, ObjectInfoMap } from './types';
+export declare function injectSyntheticFields(originalAST: DocumentNode, objectInfoService: ObjectInfoService, draftFunctions: DraftFunctions, variables?: Record<string, any>): Promise<{
+    modifiedAST: DocumentNode;
+    objectInfos: ObjectInfoMap;
+    unmappedDraftIDs: Set<string>;
+}>;
+export declare function removeSyntheticFields(result: GraphQLRepresentationData, query: DocumentNode): GraphQLRepresentationData;

package/sfdc/types/graphql/typeguards.d.ts

@@ -0,0 +1,19 @@
+import type { FieldNode, ObjectFieldNode, OperationDefinitionNode, SelectionNode, ASTNode, DefinitionNode, ObjectValueNode, InlineFragmentNode, StringValueNode, VariableNode, IntValueNode } from '@luvio/graphql-parser';
+import type { DateTimeInput } from './dateTimePredication';
+import type { CompoundPredicate, PredicateValue, SinglePredicate, NotPredicate } from './query';
+export declare function isObjectValueNode(node: ASTNode): node is ObjectValueNode;
+export declare function isStringValueNode(node: ASTNode): node is StringValueNode;
+export declare function isIntValueNode(node: ASTNode): node is IntValueNode;
+export declare function isVariableNode(node: ASTNode): node is VariableNode;
+export declare function isObjectFieldNode(node: ASTNode): node is ObjectFieldNode;
+export declare function isFieldNode(node: ASTNode): node is FieldNode;
+export declare function isFieldOrInlineFragmentNode(node: ASTNode): node is FieldNode | InlineFragmentNode;
+export declare function isInlineFragmentNode(node: ASTNode): node is InlineFragmentNode;
+export declare function isCompoundPredicate(predicate: PredicateValue): predicate is CompoundPredicate;
+export declare function isSinglePredicate(predicate: PredicateValue): predicate is SinglePredicate;
+export declare function isNotPredicate(predicate: PredicateValue): predicate is NotPredicate;
+export declare function isDateTimeInput(object: any): object is DateTimeInput;
+export declare function nodeIsNamed(name: string): (node: FieldNode) => boolean;
+export declare function extractFieldSelections(accu: SelectionNode[], item: FieldNode): SelectionNode[];
+export declare function extractSelections(accu: SelectionNode[], item: FieldNode | InlineFragmentNode): SelectionNode[];
+export declare function isOperationDefinitionNode(node: DefinitionNode): node is OperationDefinitionNode;

package/sfdc/types/instrumentation/instrumentPrimingSession.d.ts

@@ -1,2 +1,2 @@
-import type { PrimingSession } from '@salesforce/lds-priming';
+import type { PrimingSession } from '../priming';
 export declare function instrumentPrimingSession(session: PrimingSession): PrimingSession;

package/sfdc/types/instrumentation/metrics.d.ts

@@ -1,4 +1,4 @@
-import type { QueryInstrumentation } from '@salesforce/lds-graphql-local-evaluation/dist/types/instrumentLimits';
+import type { QueryInstrumentation } from '../graphql/instrumentLimits';
 export declare const O11Y_NAMESPACE_LDS_MOBILE = "lds-mobile";
 export declare const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = "draft-queue-total-mergeActions-calls";
 export declare const ldsMobileInstrumentation: import("o11y/dist/modules/o11y/client/interfaces").Instrumentation;

package/sfdc/types/main.d.ts

@@ -5,3 +5,4 @@ export type { ObjectInfoService } from './utils/ObjectInfoService';
 export type { ObservabilityContext } from '@salesforce/nimbus-plugin-lds';
 export { registerReportObserver } from './instrumentation/instrumentMobileAdapter';
 export { reportGraphqlQueryParseError } from './instrumentation/metrics';
+export type { PrimingSession } from './priming';

package/sfdc/types/priming/ConflictPool.d.ts

@@ -0,0 +1,31 @@
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { PrimingStore } from './PrimingStore';
+import type { PrimingWork } from './types';
+import type { ObjectInfoLoader } from './ObjectInfoLoader';
+type ConflictResolutionError = 'object-info-missing';
+interface ConflictResolutionResult {
+    additionalWork: PrimingWork;
+    recordsToWrite: DurableRecordRepresentation[];
+    resolvedRecords: string[];
+    recordsNeedingRefetch: Map<string, {
+        ids: string[];
+        fields: string[];
+    }>;
+    errors: {
+        id: string;
+        reason: ConflictResolutionError;
+    }[];
+}
+/**
+ * A pool of workers that resolve conflicts between incoming records and records in the store.
+ */
+export declare class ConflictPool {
+    private readonly store;
+    private readonly objectInfoLoader;
+    private pool;
+    constructor(store: PrimingStore, objectInfoLoader: ObjectInfoLoader);
+    enqueueConflictedRecords(records: DurableRecordRepresentation[], abortController: LdsAbortController): Promise<ConflictResolutionResult>;
+    private resolveConflicts;
+}
+export {};

package/sfdc/types/priming/Emitter.d.ts

@@ -0,0 +1,16 @@
+type EventPayloadMap = {
+    [eventName: string]: any;
+};
+type EventCallback<T extends keyof EventPayloadMap> = (payload: EventPayloadMap[T]) => void;
+export declare abstract class EventEmitter<T extends EventPayloadMap> {
+    private listeners;
+    private addListener;
+    private removeListener;
+    on<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    once<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    off<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    protected emit<K extends Extract<keyof T, string>>(eventName: K, payload: T[K]): boolean;
+    protected listenerCount<K extends Extract<keyof T, string>>(eventName: K): number;
+    protected rawListeners<K extends Extract<keyof T, string>>(eventName: K): { [K_1 in keyof T]: EventCallback<K_1>[]; }[K];
+}
+export {};

package/sfdc/types/priming/LdsPrimingRecordRefresher.d.ts

@@ -1,6 +1,6 @@
 import type { Adapter } from '@luvio/engine';
 import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
-import type { LdsRecordRefresher } from '@salesforce/lds-priming';
+import type { LdsRecordRefresher } from '../priming';
 export declare class LdsPrimingRecordRefresher implements LdsRecordRefresher {
     private getRecordsAdapter;
     constructor(getRecordsAdapter: Adapter<GetRecordsConfig, BatchRepresentation>);

package/sfdc/types/priming/LdsRecordRefresher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * When the priming session cannot resolve a record due to an unsupported conflict (i.e. draft conflict or spanning record conflict) the record
+ * must be refreshed via a tradition LDS adapter.
+ */
+export interface LdsRecordRefresher {
+    /**
+     * Refreshes a set of records through an LDS adapter
+     * @param records a map of apiName to ids and fields being requested
+     */
+    loadRecords(records: Map<string, {
+        ids: string[];
+        fields: string[];
+    }>): Promise<{
+        loaded: string[];
+        errored: string[];
+    }>;
+}

package/sfdc/types/priming/NimbusPrimingNetworkAdapter.d.ts

@@ -1,10 +1,10 @@
-import { type PrimingNetworkAdapter } from '@salesforce/lds-priming';
-import type { GraphQLRepresentation, GraphQLInputRepresentation, ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
+import { type PrimingNetworkAdapter } from '../priming';
+import type { ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
 import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { Request, Response } from '@salesforce/nimbus-plugin-lds';
 export declare class NimbusPrimingNetworkAdapter implements PrimingNetworkAdapter {
     private sendRequestWithAbort;
-    postBatchGraphQL(configs: GraphQLInputRepresentation[], abortController: LdsAbortController): Promise<GraphQLRepresentation[]>;
-    postGraphQL(query: string, variables: Record<string, any>, abortController: LdsAbortController): Promise<GraphQLRepresentation>;
+    sendRequest(request: Request, abortController: LdsAbortController): Promise<Response>;
     getObjectInfoDirectory(abortController: LdsAbortController): Promise<ObjectInfoDirectoryRepresentation>;
     getObjectInfos(apiName: string[], abortController: LdsAbortController): Promise<Map<string, ObjectInfoRepresentation>>;
 }

package/sfdc/types/priming/ObjectInfoLoader.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
+interface ObjectInfoStatus {
+    expiration: number;
+}
+export interface ObjectInfoLoader {
+    getObjectInfos(apiNames: string[]): Promise<Record<string, ObjectInfoRepresentation>>;
+    getObjectInfoDirectory(): Promise<ObjectInfoDirectoryRepresentation | undefined>;
+    getCachedObjectInfoStatus(): Promise<Map<string, ObjectInfoStatus>>;
+}
+export {};

package/sfdc/types/priming/PrimingNetworkAdapter.d.ts

@@ -0,0 +1,5 @@
+import type { Request, Response } from '@salesforce/nimbus-plugin-lds';
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+export interface PrimingNetworkAdapter {
+    sendRequest(request: Request, abortController: LdsAbortController): Promise<Response>;
+}

package/sfdc/types/priming/PrimingNetworkError.d.ts

@@ -0,0 +1,5 @@
+export declare class PrimingNetworkError extends Error {
+    httpCode: number;
+    constructor(message: string, httpCode: number);
+    isServiceProtectionError(): Boolean;
+}

package/sfdc/types/priming/PrimingSession.d.ts

@@ -0,0 +1,67 @@
+import type { RecordIngestor } from './RecordIngestor';
+import type { RecordLoader } from './recordLoaders';
+import type { PrimingWork } from './types';
+import type { ObjectInfoLoader } from './ObjectInfoLoader';
+import type { PrimingStore } from './PrimingStore';
+import type { LdsRecordRefresher } from './LdsRecordRefresher';
+import { EventEmitter } from './Emitter';
+export interface PrimingSessionConfig {
+    store: PrimingStore;
+    recordLoader: RecordLoader;
+    recordIngestor: RecordIngestor;
+    objectInfoLoader: ObjectInfoLoader;
+    ldsRecordRefresher: LdsRecordRefresher;
+    batchSize?: number;
+    concurrency?: number;
+}
+export interface PrimingEvents {
+    error: EventErrorPayload;
+    primed: EventPrimedPayload;
+    conflict: ConflictEventPayload;
+    'metadata-fetched': {
+        availableTypes: string[];
+        unavailableTypes: string[];
+        duration: number;
+    };
+    'batch-starting': {
+        queuedTime: number;
+    };
+    'batch-fetched': {
+        ids: string[];
+        duration: number;
+    };
+    'batch-written': {
+        written: string[];
+        conflicted: string[];
+        errors: string[];
+        duration: number;
+    };
+}
+interface EventErrorPayload {
+    ids: string[];
+    code: 'precondition-error' | 'service-protection-error' | 'not-found' | 'service-unavailable' | 'unknown' | 'canceled';
+    message: string;
+}
+interface ConflictEventPayload {
+    ids: string[];
+    resolution: 'priming-merge' | 'priming-refresh' | 'lds-refresh';
+}
+type EventPrimedPayload = Array<string>;
+export declare class PrimingSession extends EventEmitter<PrimingEvents> {
+    private batchSize;
+    private concurrency;
+    private recordLoader;
+    private recordIngestor;
+    private objectInfoLoader;
+    private networkWorkerPool;
+    private conflictPool;
+    private ldsRecordRefresher;
+    constructor(config: PrimingSessionConfig);
+    enqueue(work: PrimingWork): Promise<void>;
+    cancel(): void;
+    private enqueueBatches;
+    private processFetchedRecords;
+    private handleWriteConflicts;
+    private fetchMetadata;
+}
+export {};

package/sfdc/types/priming/PrimingStore.d.ts

@@ -0,0 +1,27 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { StoreMetadata } from '@luvio/engine';
+export interface RecordWithMetadata {
+    record: DurableRecordRepresentation;
+    metadata: StoreMetadata;
+}
+export interface WriteResult {
+    written: string[];
+    conflicted: string[];
+    errors: {
+        ids: string[];
+        message: string;
+    }[];
+}
+export interface PrimingStore {
+    /**
+     * Writes records to the store
+     * @param records list of records to insert
+     * @returns list of ids that were written and list of ids that were not written due to already being present in the store
+     */
+    writeRecords(records: RecordWithMetadata[], overwrite: boolean): Promise<WriteResult>;
+    /**
+     * Reads records from the store
+     * @param ids
+     */
+    readRecords(ids: string[]): Promise<RecordWithMetadata[]>;
+}

package/sfdc/types/priming/RecordIngestor.d.ts

@@ -0,0 +1,14 @@
+import type { Luvio } from '@luvio/engine';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { PrimingStore, WriteResult } from './PrimingStore';
+export declare class RecordIngestor {
+    private store;
+    private getLuvio;
+    constructor(store: PrimingStore, getLuvio: () => Luvio);
+    /**
+     * Inserts records into the store
+     * @param syntheticRecords list of records to insert
+     * @returns list of ids that were written and list of ids that were not written due to already being present in the store
+     */
+    insertRecords(syntheticRecords: DurableRecordRepresentation[], overwrite?: boolean): Promise<WriteResult>;
+}

package/sfdc/types/priming/SqlitePrimingStore.d.ts

@@ -1,4 +1,4 @@
-import type { PrimingStore, RecordWithMetadata, WriteResult } from '@salesforce/lds-priming';
+import type { PrimingStore, RecordWithMetadata, WriteResult } from '../priming';
 import type { Luvio } from '@luvio/engine';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 export declare class SqlitePrimingStore implements PrimingStore {

package/sfdc/types/priming/index.d.ts

@@ -0,0 +1,10 @@
+export { PrimingSession } from './PrimingSession';
+export { RecordIngestor } from './RecordIngestor';
+export { PrimingStore, RecordWithMetadata, WriteResult } from './PrimingStore';
+export { MetadataHandler } from './metadata/MetadataHandler';
+export { PrimingNetworkError } from './PrimingNetworkError';
+export { RecordLoaderGraphQL, RecordLoaderGraphQLBatch, RecordLoaderSOQLComposite, } from './recordLoaders';
+export type { RecordLoader } from './recordLoaders';
+export type { LdsRecordRefresher } from './LdsRecordRefresher';
+export type { PrimingEvents } from './PrimingSession';
+export type { PrimingNetworkAdapter } from './PrimingNetworkAdapter';

package/sfdc/types/priming/metadata/MetadataHandler.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from '../Emitter';
+import type { ObjectInfoLoader } from '../ObjectInfoLoader';
+export interface MetadataEvents {
+    progress: number;
+    error: MetadataError;
+    starting: {
+        cached: Set<string>;
+        expired: Set<string>;
+        missing: Set<string>;
+    };
+    primed: {
+        apiNames: Set<string>;
+    };
+    complete: {
+        apiNames: Map<string, CacheStatus>;
+    };
+}
+interface ErrorCouldNotFetchDirectory {
+    type: 'directory-error';
+}
+interface ErrorCouldNotFetchObjectInfos {
+    type: 'object-info-error';
+    apiNames: Set<string>;
+}
+interface ErrorAlreadyStarted {
+    type: 'already-started';
+}
+type MetadataError = ErrorCouldNotFetchDirectory | ErrorCouldNotFetchObjectInfos | ErrorAlreadyStarted;
+type CacheStatus = 'not-cached' | 'cached' | 'expired' | 'fetching' | 'error';
+export declare class MetadataHandler extends EventEmitter<MetadataEvents> {
+    private objectInfoLoader;
+    private config;
+    private apiNames;
+    private progress;
+    private started;
+    private workPool;
+    private batchSize;
+    private concurrency;
+    constructor(objectInfoLoader: ObjectInfoLoader, config: {
+        batchSize?: number;
+        concurrency?: number;
+    });
+    start(): Promise<void>;
+    cancel(): void;
+    private getBatches;
+    private executeBatchedWork;
+    private updateProgress;
+}
+export {};

package/sfdc/types/priming/primingSessionFactory.d.ts

@@ -1,4 +1,4 @@
-import { PrimingSession } from '@salesforce/lds-priming';
+import { PrimingSession } from '../priming';
 import type { Adapter, Luvio } from '@luvio/engine';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 import type { ObjectInfoService } from '../main';

package/sfdc/types/priming/recordLoaders/NetworkRecordLoader.d.ts

@@ -0,0 +1,16 @@
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { Request } from '@salesforce/nimbus-plugin-lds';
+import type { AvailableTypedBatch } from '../types';
+import type { RecordFetchResult, RecordLoader } from './RecordLoader';
+import type { PrimingNetworkAdapter } from '../PrimingNetworkAdapter';
+export declare abstract class NetworkRecordLoader implements RecordLoader {
+    private readonly networkAdapter;
+    constructor(networkAdapter: PrimingNetworkAdapter);
+    fetchRecordData(batch: AvailableTypedBatch, abortController: LdsAbortController): Promise<RecordFetchResult[]>;
+    private sendRequest;
+    protected abstract makeRequest<T>(batch: AvailableTypedBatch): {
+        request: Request;
+        context: T;
+    };
+    protected abstract generateFetchResults<T>(body: any, batchInput: AvailableTypedBatch, context: T): RecordFetchResult[];
+}

package/sfdc/types/priming/recordLoaders/RecordLoader.d.ts

@@ -0,0 +1,19 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { AvailableTypedBatch } from '../types';
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+interface RecordFetchResultSuccess {
+    ok: true;
+    records: DurableRecordRepresentation[];
+    missingIds: string[];
+}
+interface RecordFetchResultFailure {
+    ok: false;
+    error: 'network-error' | 'service-protection-error' | 'request-error' | 'unknown';
+    messages: string[];
+    missingIds: string[];
+}
+export type RecordFetchResult = RecordFetchResultSuccess | RecordFetchResultFailure;
+export interface RecordLoader {
+    fetchRecordData(batch: AvailableTypedBatch, abortController: LdsAbortController): Promise<RecordFetchResult[]>;
+}
+export {};

package/sfdc/types/priming/recordLoaders/RecordLoaderGraphQL.d.ts

@@ -0,0 +1,37 @@
+import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { Request } from '@salesforce/nimbus-plugin-lds';
+import type { RecordFetchResult } from './RecordLoader';
+import type { AvailableTypedBatch, TypedBatch } from '../types';
+import { NetworkRecordLoader } from './NetworkRecordLoader';
+type GraphQLNode = {
+    Id: string;
+    ApiName: string;
+    DisplayValue: {
+        value: string | null;
+    };
+    LastModifiedById: {
+        value: string | null;
+    };
+    LastModifiedDate: {
+        value: string | null;
+    };
+    RecordTypeId: {
+        value: string | null;
+    };
+    SystemModstamp: {
+        value: string | null;
+    };
+    WeakEtag: number;
+    [field: string]: any;
+};
+export declare class RecordLoaderGraphQL extends NetworkRecordLoader {
+    protected makeRequest(batch: TypedBatch): {
+        request: Request;
+        context: any;
+    };
+    protected generateFetchResults(repResult: any, batchInput: AvailableTypedBatch, _context: any): RecordFetchResult[];
+    protected generateGraphQLQuery(type: string, fields: string[]): string;
+    protected generateDurableRecordRepresentation(node: GraphQLNode, objectInfo: ObjectInfoRepresentation): DurableRecordRepresentation;
+}
+export {};

package/sfdc/types/priming/recordLoaders/RecordLoaderGraphQLBatch.d.ts

@@ -0,0 +1,11 @@
+import type { Request } from '@salesforce/nimbus-plugin-lds';
+import type { AvailableTypedBatch, TypedBatch } from '../types';
+import type { RecordFetchResult } from './RecordLoader';
+import { RecordLoaderGraphQL } from './RecordLoaderGraphQL';
+export declare class RecordLoaderGraphQLBatch extends RecordLoaderGraphQL {
+    makeRequest(batch: TypedBatch): {
+        request: Request;
+        context: string[][];
+    };
+    protected generateFetchResults(body: any, batchInput: AvailableTypedBatch, context: string[][]): RecordFetchResult[];
+}

package/sfdc/types/priming/recordLoaders/RecordLoaderSOQLComposite.d.ts

@@ -0,0 +1,14 @@
+import type { Request } from '@salesforce/nimbus-plugin-lds';
+import type { RecordFetchResult } from './RecordLoader';
+import type { AvailableTypedBatch } from '../types';
+import { NetworkRecordLoader } from './NetworkRecordLoader';
+export declare class RecordLoaderSOQLComposite extends NetworkRecordLoader {
+    makeRequest(batch: AvailableTypedBatch): {
+        request: Request;
+        context: any;
+    };
+    protected generateFetchResults(batchResult: any, batchInput: AvailableTypedBatch, rawContext: any): RecordFetchResult[];
+    generateSelect(batch: AvailableTypedBatch): string;
+    generateWhere(ids: string[]): string;
+    private generateFetchResultForSoql;
+}

package/sfdc/types/priming/recordLoaders/SoqlRecordConverter.d.ts

@@ -0,0 +1,32 @@
+import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+export interface RecordTypeInfo {
+    available: boolean;
+    defaultRecordTypeMapping: boolean;
+    master: boolean;
+    name: string;
+    recordTypeId: string;
+}
+export declare class SoqlRecordConverter {
+    objectType: string;
+    records: Record<string, any>[];
+    recordTypeInfos: Map<string, RecordTypeInfo>;
+    fieldTypeMapping: Map<string, string>;
+    masterRecordTypeInfo: RecordTypeInfo | null;
+    filteredFields: Array<string>;
+    /**
+     *
+     * Use the objectInfo to build a map of record types (and find the master/default type),
+     * as well as get a list of all fields and data types.
+     *
+     * @param objectInfo ObjectInfo information from server.
+     * @param records The records to process from soql endpoint.
+     * @returns instance of SoqlRecordConverter.
+     */
+    static get(objectInfo: ObjectInfoRepresentation, records: Record<string, any>[]): SoqlRecordConverter;
+    constructor(objectType: string, records: Record<string, any>[], recordTypeInfos: Map<string, RecordTypeInfo>, fieldTypeMapping: Map<string, string>, masterRecordTypeInfo: RecordTypeInfo | null);
+    convert(): DurableRecordRepresentation[];
+    private convertRecord;
+    private weakEtag;
+    private formatFieldValueIfNeeded;
+}

package/sfdc/types/priming/recordLoaders/api.d.ts

@@ -0,0 +1,2 @@
+export declare const apiVersion = "v63.0";
+export declare const basePath: string;

package/sfdc/types/priming/recordLoaders/index.d.ts

@@ -0,0 +1,4 @@
+export type { RecordLoader, RecordFetchResult } from './RecordLoader';
+export { RecordLoaderGraphQL } from './RecordLoaderGraphQL';
+export { RecordLoaderGraphQLBatch } from './RecordLoaderGraphQLBatch';
+export { RecordLoaderSOQLComposite } from './RecordLoaderSOQLComposite';

package/sfdc/types/priming/typedBatch.d.ts

@@ -0,0 +1,3 @@
+import type { TypedBatch, PrimingWork } from './types';
+export declare function chunk<T = any>(arr: T[], chunkSize: number): T[][];
+export declare function generateTypedBatches(work: PrimingWork, batchSize: number): TypedBatch[];

package/sfdc/types/priming/utils/merge.d.ts

@@ -0,0 +1,31 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+type MergeCode = 'success' | 'conflict-missing-fields' | 'conflict-drafts' | 'conflict-spanning-record';
+export interface MergeResultSuccess {
+    ok: true;
+    code: MergeCode;
+    needsWrite: boolean;
+    record: DurableRecordRepresentation;
+}
+export interface MergeResultConflict {
+    ok: false;
+    code: MergeCode;
+    hasDraft: boolean;
+    fieldUnion: string[];
+}
+type MergeResult = MergeResultSuccess | MergeResultConflict;
+/**
+ * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
+ *
+ * IMPORTANT NOTE: this is not a suitable function to use for general merging of two DurableRecordRepresentation since it
+ * makes the assumption that the incoming record ONLY contains scalar field values and no spanning records. The same is not
+ * necessarily true for the existing record as it may have been populated in the cache outside of a priming session.
+ * This function should not be moved out of the priming module!
+ *
+ * @param existingRecord Existing record in the durable store
+ * @param incomingRecord Incoming record from the priming session
+ * @param objectInfo Object info for the incoming record type
+ * @returns Merge result describing the success or failure of the merge operation
+ */
+export declare function mergeRecord(existingRecord: DurableRecordRepresentation, incomingRecord: DurableRecordRepresentation, objectInfo: ObjectInfoRepresentation): MergeResult;
+export {};

package/sfdc/types/runtime.d.ts

@@ -2,7 +2,7 @@ import { Luvio, Environment } from '@luvio/engine';
 import { DraftManager } from '@salesforce/lds-drafts';
 import type { DraftQueue } from '@salesforce/lds-drafts';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
-import type { PrimingSession } from '@salesforce/lds-priming';
+import type { PrimingSession } from './priming';
 export interface Runtime {
     luvio: Luvio;
     internalLuvio: Luvio;

package/sfdc/types/utils/language.d.ts

@@ -1,29 +1,57 @@
-declare const keys: {
-    (o: object): string[];
-    (o: {}): string[];
-}, create: {
-    (o: object | null): any;
-    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
-}, assign: {
+declare const assign: {
     <T extends {}, U>(target: T, source: U): T & U;
     <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
     <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
     (target: object, ...sources: any[]): any;
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
 }, entries: {
     <T>(o: {
         [s: string]: T;
     } | ArrayLike<T>): [string, T][];
     (o: {}): [string, any][];
+}, freeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, isFrozen: (o: any) => boolean, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
 };
-declare const stringify: {
-    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
-    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
-}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
-declare const push: (...items: any[]) => number, join: (separator?: string | undefined) => string, slice: (start?: number | undefined, end?: number | undefined) => any[], shift: () => any;
-declare const isArray: (arg: any) => arg is any[], from: {
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
+declare const split: {
+    (separator: string | RegExp, limit?: number | undefined): string[];
+    (splitter: {
+        [Symbol.split](string: string, limit?: number | undefined): string[];
+    }, limit?: number | undefined): string[];
+}, endsWith: (searchString: string, endPosition?: number | undefined) => boolean;
+declare const from: {
     <T>(arrayLike: ArrayLike<T>): T[];
     <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
     <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
     <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+}, isArray: (arg: any) => arg is any[];
+declare const concat: {
+    (...items: ConcatArray<any>[]): any[];
+    (...items: any[]): any[];
+}, filter: {
+    <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[];
+    (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[];
+}, includes: (searchElement: any, fromIndex?: number | undefined) => boolean, push: (...items: any[]) => number, reduce: {
+    (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+    (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+    <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+}, shift: () => any, slice: (start?: number | undefined, end?: number | undefined) => any[];
+declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
 };
-export { keys as ObjectKeys, create as ObjectCreate, assign as ObjectAssign, entries as ObjectEntries, push as ArrayPrototypePush, join as ArrayPrototypeJoin, slice as ArrayPrototypeSlice, shift as ArrayPrototypeShift, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, parse as JSONParse, };
+export { assign as ObjectAssign, create as ObjectCreate, entries as ObjectEntries, freeze as ObjectFreeze, isFrozen as ObjectIsFrozen, keys as ObjectKeys, values as ObjectValues, hasOwnProperty as ObjectPrototypeHasOwnProperty, from as ArrayFrom, isArray as ArrayIsArray, concat as ArrayPrototypeConcat, filter as ArrayPrototypeFilter, includes as ArrayPrototypeIncludes, push as ArrayPrototypePush, reduce as ArrayPrototypeReduce, shift as ArrayPrototypeShift, slice as ArrayPrototypeSlice, split as StringPrototypeSplit, endsWith as StringPrototypeEndsWith, parse as JSONParse, stringify as JSONStringify, };