@salesforce/lds-runtime-mobile 1.318.0 → 1.320.0

package/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/types/priming/recordLoaders/api.d.ts

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

package/dist/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/dist/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/dist/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/dist/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.318.0",
+    "version": "1.320.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",
@@ -32,25 +32,23 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-mobile"
     },
     "dependencies": {
-        "@salesforce/lds-adapters-uiapi": "^1.318.0",
-        "@salesforce/lds-bindings": "^1.318.0",
-        "@salesforce/lds-instrumentation": "^1.318.0",
-        "@salesforce/lds-priming": "^1.318.0",
+        "@salesforce/lds-adapters-uiapi": "^1.320.0",
+        "@salesforce/lds-bindings": "^1.320.0",
+        "@salesforce/lds-instrumentation": "^1.320.0",
         "@salesforce/user": "0.0.21",
         "o11y": "250.7.0"
     },
     "devDependencies": {
-        "@salesforce/lds-adapters-graphql": "^1.318.0",
-        "@salesforce/lds-drafts": "^1.318.0",
-        "@salesforce/lds-durable-records": "^1.318.0",
-        "@salesforce/lds-graphql-local-evaluation": "^1.318.0",
-        "@salesforce/lds-network-adapter": "^1.318.0",
-        "@salesforce/lds-network-nimbus": "^1.318.0",
-        "@salesforce/lds-store-binary": "^1.318.0",
-        "@salesforce/lds-store-nimbus": "^1.318.0",
-        "@salesforce/lds-store-sql": "^1.318.0",
-        "@salesforce/lds-utils-adapters": "^1.318.0",
-        "@salesforce/nimbus-plugin-lds": "^1.318.0",
+        "@salesforce/lds-adapters-graphql": "^1.320.0",
+        "@salesforce/lds-drafts": "^1.320.0",
+        "@salesforce/lds-durable-records": "^1.320.0",
+        "@salesforce/lds-network-adapter": "^1.320.0",
+        "@salesforce/lds-network-nimbus": "^1.320.0",
+        "@salesforce/lds-store-binary": "^1.320.0",
+        "@salesforce/lds-store-nimbus": "^1.320.0",
+        "@salesforce/lds-store-sql": "^1.320.0",
+        "@salesforce/lds-utils-adapters": "^1.320.0",
+        "@salesforce/nimbus-plugin-lds": "^1.320.0",
         "babel-plugin-dynamic-import-node": "^2.3.3",
         "wait-for-expect": "^3.0.2"
     },