@salesforce/lds-runtime-mobile 1.318.0 → 1.320.0

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/dist/types/draftsAdapters/QuickActionExecutionRepresentation/UpdateRecordQuickActionExecutionRepresentationHandler.d.ts

@@ -1,38 +0,0 @@
-import type { ActionHandler, CompletedDraftAction, DraftAction, DraftQueue, PendingDraftAction, QueueOperation } from '@salesforce/lds-drafts';
-import { AbstractResourceRequestActionHandler } from '../AbstractResourceRequestActionHandler';
-import type { DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
-import type { PerformActionInputRepresentation, QuickActionExecutionRepresentation } from '../../adapters/main';
-import type { UiApiDraftRecordService } from '../UiApiDraftRecordService';
-import type { RecordEffectingHandler } from '../RecordRepresentation/actionHandlers/RecordEffectingHandler';
-import type { DraftRecordOperation, RecordDraftMetadata } from '../RecordRepresentation/replayDraftsOnRecord';
-import { type DurableStore } from '@luvio/environments';
-import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
-export declare const UPDATE_RECORD_QUICK_ACTION_HANDLER = "UPDATE_RECORD_QUICK_ACTION_HANDLER";
-interface PerformUpdateRecordQuickActionResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
-    body: PerformActionInputRepresentation;
-    method: 'patch';
-}
-export declare class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractResourceRequestActionHandler<QuickActionExecutionRepresentation, {}> implements RecordEffectingHandler {
-    private readonly draftRecordService;
-    private readonly durableStore;
-    readonly isDraftId: (targetId: string) => boolean;
-    handlerId: string;
-    getDenormedRecord: (key: string) => Promise<DurableRecordRepresentation | undefined>;
-    constructor(getLuvio: () => Luvio, draftRecordService: UiApiDraftRecordService, draftQueue: DraftQueue, networkAdapter: NetworkAdapter, durableStore: DurableStore, isDraftId: (targetId: string) => boolean);
-    draftActionToDraftOperation(queueEntry: DraftAction<PerformUpdateRecordQuickActionResourceRequest, QuickActionExecutionRepresentation>): DraftRecordOperation[] | undefined;
-    handleActionEnqueued(action: PendingDraftAction<PerformUpdateRecordQuickActionResourceRequest>): Promise<void>;
-    canHandlePublish(_key: string): boolean;
-    canRepresentationContainDraftMetadata(_representationName: string): boolean;
-    getIdFromRequest(request: ResourceRequest): Promise<string>;
-    getIdFromResponseBody(responseBody: QuickActionExecutionRepresentation): string;
-    buildTagForTargetId(id: string): string;
-    getDataForAction(action: DraftAction<ResourceRequest, QuickActionExecutionRepresentation>): Promise<QuickActionExecutionRepresentation | undefined>;
-    getDraftMetadata(key: string): Promise<RecordDraftMetadata | undefined>;
-    applyDraftsToIncomingData(key: string, data: unknown, _draftMetadata: {} | undefined, publishFn: (key: string, data: any) => void): void;
-    handleActionRemoved(action: DraftAction<ResourceRequest, QuickActionExecutionRepresentation>): Promise<void>;
-    handleActionCompleted(action: CompletedDraftAction<ResourceRequest, QuickActionExecutionRepresentation>, _queueOperations: QueueOperation[], _allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
-    buildCacheKeysFromResponse(_response: QuickActionExecutionRepresentation): DurableStoreKeyMetadataMap;
-    synchronousIngest(response: QuickActionExecutionRepresentation): void;
-    mergeRequestBody<T>(): T;
-}
-export {};

package/dist/types/draftsAdapters/RecordRepresentation/actionHandlers/RecordEffectingHandler.d.ts

@@ -1,6 +0,0 @@
-import type { DraftAction } from '@salesforce/lds-drafts';
-import type { DraftRecordOperation } from '../replayDraftsOnRecord';
-export interface RecordEffectingHandler {
-    draftActionToDraftOperation(queueEntry: DraftAction<unknown, unknown>): DraftRecordOperation[] | undefined;
-    handlerId: string;
-}

package/dist/types/draftsAdapters/RecordRepresentation/actionHandlers/UiApiRecordActionHandler.d.ts

@@ -1,84 +0,0 @@
-import type { Adapter, DurableStoreKeyMetadataMap, Luvio, NetworkAdapter, ResourceRequest } from '@luvio/engine';
-import type { GetRecordConfig, ObjectInfoRepresentation, RecordRepresentation, RecordRepresentationNormalized, RecordInputRepresentation } from '../../../adapters/main';
-import type { ActionHandler, CompletedDraftAction, DraftAction, DraftActionMetadata, DraftIdAndKeyMapping, DraftQueue, PendingDraftAction, QueueOperation } from '@salesforce/lds-drafts';
-import type { FieldRepresentation, ObjectInfoService } from '../../utils/types';
-import { AbstractResourceRequestActionHandler } from '../../AbstractResourceRequestActionHandler';
-import type { DraftRecordOperation, RecordDraftMetadata } from '../replayDraftsOnRecord';
-import type { UiApiDraftRecordService, ReferenceIdFieldInfo } from '../../UiApiDraftRecordService';
-import type { RecordEffectingHandler } from './RecordEffectingHandler';
-import type { DurableStore } from '@luvio/environments';
-export declare const LDS_ACTION_HANDLER_ID = "LDS_ACTION_HANDLER";
-export declare const LDS_ACTION_METADATA_API_NAME = "LDS_ACTION_METADATA_API_NAME";
-export type FormatDisplayValue = (value: boolean | number | string | null, datatype: string) => null | string;
-interface RecordEndpointResourceRequest extends Omit<ResourceRequest, 'body' | 'method'> {
-    body: RecordInputRepresentation;
-    method: 'post' | 'patch' | 'delete';
-}
-export type RecordResourceRequest = RecordEndpointResourceRequest;
-export declare class UiApiActionHandler extends AbstractResourceRequestActionHandler<RecordRepresentation, RecordDraftMetadata> implements RecordEffectingHandler {
-    protected readonly getLuvio: () => Luvio;
-    protected readonly networkAdapter: NetworkAdapter;
-    private readonly durableStore;
-    protected readonly draftQueue: DraftQueue;
-    private readonly getRecordAdapter;
-    private readonly objectInfoService;
-    readonly isDraftId: (targetId: string) => boolean;
-    private readonly recordService;
-    handlerId: string;
-    constructor(getLuvio: () => Luvio, networkAdapter: NetworkAdapter, durableStore: DurableStore, draftQueue: DraftQueue, getRecordAdapter: Adapter<GetRecordConfig, RecordRepresentation>, objectInfoService: ObjectInfoService, isDraftId: (targetId: string) => boolean, recordService: UiApiDraftRecordService);
-    buildPendingAction(request: RecordResourceRequest, queue: DraftAction<unknown, unknown>[]): Promise<PendingDraftAction<ResourceRequest>>;
-    getBackdatingFields(objectInfo: ObjectInfoRepresentation, requestMethod: string, pendingAction: PendingDraftAction<RecordResourceRequest>): {
-        [key: string]: string;
-    };
-    getRedirectMappings(action: CompletedDraftAction<ResourceRequest, RecordRepresentation>): DraftIdAndKeyMapping[] | undefined;
-    handleActionCompleted(completedAction: CompletedDraftAction<ResourceRequest, RecordRepresentation>, queueOperations: QueueOperation[], allHandlers: ActionHandler<unknown, unknown, unknown>[]): Promise<void>;
-    handleActionEnqueued(action: PendingDraftAction<ResourceRequest>): Promise<void>;
-    fetchReferenceRecord(referenceFields: ReferenceIdFieldInfo[]): Promise<void>;
-    /**
-     * identify the API Name from the record ID and its field representation. For example, ApiName for `001x0000004cKfzAAE` is `Account` if its field info reference to `Account`
-     * representation
-     * @param id
-     * @param fieldInfo
-     * @returns apiName
-     */
-    identifyApiName(id: string, fieldInfo: FieldRepresentation): Promise<string | undefined>;
-    canRepresentationContainDraftMetadata(representationName: string): boolean;
-    canHandlePublish(key: string): boolean;
-    buildTagForTargetId(id: string): string;
-    getIdFromRequest(request: RecordResourceRequest): Promise<string>;
-    getIdFromResponseBody(responseBody: RecordRepresentation): string;
-    draftActionToDraftOperation(action: DraftAction<RecordResourceRequest, RecordRepresentation>): DraftRecordOperation[];
-    getDraftMetadata(key: string): Promise<RecordDraftMetadata | undefined>;
-    isActionRecordAction(action: DraftAction<unknown, unknown>): action is DraftAction<RecordResourceRequest, RecordRepresentation>;
-    /**
-     * Gets the record associated with the passed in action
-     *
-     * @param action The draft action related to this record
-     * @param _queue The draft queue
-     * @returns The record with the updated draft queue applied. References are not included and must be applied at ingest.
-     *
-     * or
-     *
-     * undefined if the record no
-     * longer exists (i.e. the post action for a draft-created record was deleted)
-     *
-     * @throws if there are actions on an existing record but that record doesn't live in the durable store
-     */
-    getDataForAction(action: DraftAction<ResourceRequest, RecordRepresentation>): Promise<RecordRepresentation | undefined>;
-    applyDraftsToIncomingData(key: string, data: RecordRepresentationNormalized, draftMetadata: RecordDraftMetadata | undefined, publishData: (key: string, data: RecordRepresentationNormalized) => void): void;
-    updateMetadata(existingMetadata: DraftActionMetadata, incomingMetadata: DraftActionMetadata): DraftActionMetadata;
-    private getApiNameForRecordId;
-    /**
-     * Inspects the resource request to ensure this handler can handle it
-     * Inspects the resource request for draft id references. Replaces the draft ids
-     * with their canonical ids if they exist otherwise returns the request as is
-     * @param request The original resource request
-     * @returns the request with draft ids replaced or undefined if this handler is not capable of handling it
-     */
-    private resolveResourceRequest;
-    buildCacheKeysFromResponse(response: RecordRepresentation): DurableStoreKeyMetadataMap;
-    synchronousIngest(response: RecordRepresentation): void;
-    mergeRequestBody<T>(targetBody: T, sourceBody: T): T;
-}
-export declare function isLDSDraftAction<Response>(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, Response>;
-export {};

package/dist/types/draftsAdapters/RecordRepresentation/replayDraftsOnRecord.d.ts

@@ -1,40 +0,0 @@
-import type { Luvio } from '@luvio/engine';
-import { type ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
-import type { FormatDisplayValue } from './actionHandlers/UiApiRecordActionHandler';
-import { type DraftRecordRepresentation } from './DraftRecordRepresentation';
-interface BaseDraftRecordOperation {
-    apiName: string;
-    id: string;
-    draftActionId: string;
-    timestamp: number;
-}
-export interface CreateDraftRecordOperation extends BaseDraftRecordOperation {
-    type: 'create';
-    fields: Record<string, any>;
-}
-export interface UpdateDraftRecordOperation extends BaseDraftRecordOperation {
-    type: 'update';
-    fields: Record<string, any>;
-}
-export interface DeleteDraftRecordOperation extends BaseDraftRecordOperation {
-    type: 'delete';
-}
-export type DraftRecordOperation = CreateDraftRecordOperation | UpdateDraftRecordOperation | DeleteDraftRecordOperation;
-export interface RecordDraftMetadata {
-    luvio: Luvio;
-    recordOperations: DraftRecordOperation[];
-    objectInfos: Map<string, ObjectInfoRepresentation>;
-    referencedRecords: Map<string, DraftRecordRepresentation>;
-    userId: string;
-    formatDisplayValue: FormatDisplayValue;
-}
-/**
- * Replays an ordered draft list on top of a record. If undefined is passed in, the first draft must
- * be a POST action
- * @param record The base record to apply drafts to
- * @param drafts The list of drafts to apply to the record
- * @param userId The current user id, will be the last modified id
- */
-export declare function replayDraftsOnRecord(record: DraftRecordRepresentation | undefined, draftMetadata: RecordDraftMetadata | undefined): DraftRecordRepresentation | undefined;
-export declare function applyReferenceLinksToDraft(record: DraftRecordRepresentation, draftMetadata: RecordDraftMetadata): DraftRecordRepresentation;
-export {};