@salesforce/lds-runtime-mobile 0.1.0-dev1

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

@@ -0,0 +1,14 @@
+import type { ObservabilityContext, 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, observabilityContext?: ObservabilityContext): {
+        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 = "v66.0";
+export declare const basePath: string;

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

@@ -0,0 +1,4 @@
+export type { RecordLoader, RecordFetchResult, RecordFetchResultSuccessWithPagination, } 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,32 @@
+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;
+export declare const skippedCompoundFieldTypes: string[];
+/**
+ * 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

@@ -0,0 +1,24 @@
+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 './priming';
+export interface Runtime {
+    luvio: Luvio;
+    internalLuvio: Luvio;
+    environment: Environment;
+    draftQueue: DraftQueue;
+    draftManager: DraftManager;
+    createPrimingSession: (config: {
+        concurrency?: number;
+        batchSize?: number;
+    }) => PrimingSession;
+    nimbusSqliteStore: NimbusSqliteStore;
+}
+export type RuntimeConfig = {
+    primeUser?: boolean;
+};
+/**
+ * This returns the LDS on Mobile Runtime singleton object.
+ */
+export declare function getRuntime({ primeUser }?: RuntimeConfig): Runtime;

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

@@ -0,0 +1,26 @@
+import { SideEffect } from '../drafts/sideEffects';
+import type { CreateSideEffectHook, DeleteSideEffectHook, UpdateSideEffectHook } from '../drafts/records/actionHandlers/SideEffectHook';
+import { DurableRecordStore } from '../durableStore/DurableRecordStore';
+export declare const instrumentation: any;
+export declare class ProductConsumedCreatedHook implements CreateSideEffectHook {
+    on: 'post';
+    apiName: string;
+    private static COUNTER_NAME;
+    then(draftActionId: string, draftActionTimestamp: number, _draftRecordId: string, fields: Record<string, any>): Promise<SideEffect[]>;
+}
+export declare class ProductConsumedUpdatedHook 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>): Promise<SideEffect[]>;
+}
+export declare class ProductConsumedDeletedHook implements DeleteSideEffectHook {
+    private readonly durableRecordStore;
+    on: 'delete';
+    apiName: string;
+    private static COUNTER_NAME;
+    constructor(durableRecordStore: DurableRecordStore);
+    then(draftActionId: string, draftActionTimestamp: number, draftRecordId: string): Promise<SideEffect[]>;
+}

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

@@ -0,0 +1,3 @@
+import { DurableRecordStore } from '../durableStore/DurableRecordStore';
+import type { SideEffectHook } from '../drafts/records/actionHandlers/SideEffectHook';
+export declare function createSfsSideEffectHooks(durableRecordStore: DurableRecordStore): SideEffectHook[];

package/sfdc/types/trim/AggressiveTrim.d.ts

@@ -0,0 +1,7 @@
+import type { TrimTaskData, DeallocationFunction, TrimResult } from '@luvio/engine';
+type TrimOptions = {
+    batchSize?: number;
+    maxStoreRecords?: number;
+};
+export declare function aggressiveTrim(data: TrimTaskData, deallocateFn: DeallocationFunction, options?: TrimOptions): Promise<TrimResult>;
+export {};

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

@@ -0,0 +1,44 @@
+import type { Adapter } from '@luvio/engine';
+import type { ObjectInfoRepresentation, SimplifiedBatchRepresentation, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+type ObjectInfoAdapterReturn = ReturnType<typeof getObjectInfoAdapterFactory>;
+type ObjectInfosAdapterReturn = ReturnType<typeof getObjectInfosAdapterFactory>;
+type ObjectInfoDirectoryAdapterReturn = ReturnType<typeof getObjectInfoDirectoryAdapterFactory>;
+type ObjectInfoConfig = Parameters<ObjectInfoAdapterReturn>[0];
+type ObjectInfosConfig = Parameters<ObjectInfosAdapterReturn>[0];
+type ObjectInfoDirectoryConfig = Parameters<ObjectInfoDirectoryAdapterReturn>[0];
+export type ObjectInfoMap = {
+    [apiName: string]: ObjectInfoRepresentation;
+};
+interface ObjectInfoStatus {
+    expiration: number;
+}
+export declare class ObjectInfoService {
+    private getObjectInfoAdapter;
+    private getObjectInfosAdapter;
+    private getObjectInfoDirectoryAdapter;
+    private durableStore;
+    apiNameToKeyPrefixMemoryCache: {
+        [apiName: string]: string | null;
+    };
+    keyPrefixToApiNameMemoryCache: {
+        [keyPrefix: string]: string;
+    };
+    constructor(getObjectInfoAdapter: Adapter<ObjectInfoConfig, ObjectInfoRepresentation>, getObjectInfosAdapter: Adapter<ObjectInfosConfig, SimplifiedBatchRepresentation>, getObjectInfoDirectoryAdapter: Adapter<ObjectInfoDirectoryConfig, ObjectInfoDirectoryRepresentation>, durableStore: SqliteStore);
+    apiNameForPrefix: (prefix: string) => Promise<string>;
+    /**
+     * Size of return map not necessarily correlated with number of inputs.  The
+     * ObjectInfoMap returned will only be populated with values of apiNames returned
+     * from the adapter.
+     */
+    getObjectInfos(apiNames: string[]): Promise<ObjectInfoMap>;
+    getObjectInfo(apiName: string): Promise<ObjectInfoRepresentation | undefined>;
+    getObjectInfoDirectory(): Promise<ObjectInfoDirectoryRepresentation | undefined>;
+    ensureObjectInfoCached: (apiName: string, entry?: ObjectInfoRepresentation) => Promise<void>;
+    getCachedObjectInfoStatus: () => Promise<Map<string, ObjectInfoStatus>>;
+    private isObjectInfoInDurableStore;
+    private loadObjectInfoMaps;
+    private readObjectInfoDataFromDurableStore;
+    private updateObjectInfoMapping;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { InMemoryStore, NetworkAdapter } from '@luvio/engine';
+import { Luvio } from '@luvio/engine';
+import type { DurableStore, ShouldFlushFn } from '@luvio/environments';
+import type { EnsureCachedObjectInfoFunction } from '../environment/enableLazyObjectInfoCaching';
+/**
+Builds adapter instances for environments that have cross-adapter dependencies.
+These are only to be used internally in this module and not exported.
+They do not use draft environments, just the makeDurable environment.
+*/
+export declare function buildInternalAdapters(store: InMemoryStore, networkAdapter: NetworkAdapter, durableStore: DurableStore, ensureObjectInfoCached: EnsureCachedObjectInfoFunction, shouldFlush: ShouldFlushFn): {
+    luvio: Luvio;
+    durableEnvironment: import("@luvio/environments").DurableEnvironment;
+    adapters: {
+        getRecord: import("@luvio/engine").Adapter<import("../adapters/main").GetRecordConfig, import("../adapters/main").RecordRepresentation>;
+        getObjectInfo: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi").GetObjectInfoConfig, import("@salesforce/lds-adapters-uiapi").ObjectInfoRepresentation>;
+        getObjectInfos: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi").GetObjectInfosConfig, import("@salesforce/lds-adapters-uiapi").SimplifiedBatchRepresentation>;
+        getObjectInfoDirectory: import("@luvio/engine").Adapter<import("@salesforce/lds-adapters-uiapi").GetObjectInfoDirectoryConfig, import("@salesforce/lds-adapters-uiapi").ObjectInfoDirectoryRepresentation>;
+    };
+};

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

@@ -0,0 +1,57 @@
+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 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 { 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, };

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

@@ -0,0 +1,27 @@
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;
+type PromiseResult<T> = {
+    status: 'fulfilled';
+    value: T;
+} | {
+    status: 'rejected';
+    reason: any;
+};
+/**
+ * A polyfill for Promise.allSettled
+ * @param promises An array of promises
+ * @returns the result of all the promises when they either fulfill or reject
+ */
+export declare function allSettled<T>(promises: Promise<T>[]): Promise<PromiseResult<T>[]>;
+export {};