@salesforce/lds-runtime-mobile 1.319.0 → 1.321.0

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

@@ -0,0 +1,36 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+interface BaseRecordSideEffect {
+    key: string;
+    tag: string;
+    uniqueId: string;
+    timestamp: number;
+}
+export interface CreateRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-create';
+    record: DurableRecordRepresentation;
+}
+export interface UpdateRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-update';
+    recordPatch: Partial<DurableRecordRepresentation>;
+}
+export interface DeleteRecordSideEffect extends BaseRecordSideEffect {
+    type: 'record-delete';
+}
+export interface FieldIncrementSideEffect extends BaseRecordSideEffect {
+    type: 'record-field-increment';
+    fieldName: string;
+    value: number;
+}
+export type SideEffect = CreateRecordSideEffect | UpdateRecordSideEffect | DeleteRecordSideEffect | FieldIncrementSideEffect;
+/**
+ * Removes any existing effects on a record and re-applies the given ordered list and returns the record
+ * with the updated side effects applied.
+ *
+ * If the record contains effects applied to it and we no longer
+ * have any effects to apply to it, they will be removed and the result returned without any side effect applied
+ *
+ * @param record The base record to apply effects to to. If undefined the first effect must be a record-create operation
+ * @param sideEffects The list of effects to apply to the record
+ */
+export declare function resetAndApplyEffects(record: DurableRecordRepresentation | undefined, sideEffects: SideEffect[]): DurableRecordRepresentation | undefined;
+export {};

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

@@ -0,0 +1,3 @@
+import type { DurableRecordRepresentationField } from '@salesforce/lds-durable-records';
+export declare function isDraftFieldPending(field: DurableRecordRepresentationField): boolean;
+export declare function isDraftFieldMissing(field: DurableRecordRepresentationField): boolean;

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

@@ -0,0 +1,17 @@
+import { type DurableStore } from '@luvio/environments';
+import type { Luvio, StoreMetadata } from '@luvio/engine';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export declare class DurableRecordStore {
+    private readonly durableStore;
+    private readonly getLuvio;
+    constructor(durableStore: DurableStore & SqliteStore, getLuvio: () => Luvio);
+    exists(key: string): Promise<boolean>;
+    getRecord(key: string): Promise<DurableRecordRepresentation | undefined>;
+    getRecords(keys: string[]): Promise<Map<string, DurableRecordRepresentation>>;
+    getRecordsWithMetadata(keys: string[]): Promise<Map<string, {
+        record: DurableRecordRepresentation;
+        metadata: StoreMetadata | undefined;
+    }>>;
+    private entriesToRecordDirectory;
+}

package/sfdc/types/durableStore/NimbusSqliteStore/tables/index.d.ts

@@ -1,2 +1 @@
 export { LdsDraftsDataTable } from './LdsDraftsDataTable';
-export { LdsDraftIdMapDataTable } from './LdsDraftIdMapDataTable';

package/sfdc/types/graphql/adapter/draftAwareGraphQLAdapterFactory.d.ts

@@ -0,0 +1,6 @@
+import type { Luvio, Snapshot, StoreLookup, CoercedAdapterRequestContext } from '@luvio/engine';
+import type { DraftAwareGraphQLAdapter, GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { DraftFunctions, ObjectInfoService } from '../types';
+export declare const replaceDraftIdsInVariables: (variables: Record<string, any>, draftFunctions: DraftFunctions, unmappedDraftIDs: Set<string>) => Record<string, any>;
+export declare function draftAwareGraphQLAdapterFactory(userId: string, objectInfoService: ObjectInfoService, store: SqliteStore, luvio: Luvio, isDraftId: (id: string) => boolean, buildCachedSnapshotCachePolicy: (context: any, storeLookup: StoreLookup<GraphQLRepresentation, unknown>) => Snapshot<GraphQLRepresentation, any>, buildNetworkSnapshotCachePolicy: (context: any, coercedAdapterRequestContext: CoercedAdapterRequestContext) => Promise<Snapshot<GraphQLRepresentation, any>>): DraftAwareGraphQLAdapter;

package/sfdc/types/graphql/adapter/environmentAwareGraphQLBatchAdapterFactory.d.ts

@@ -0,0 +1,4 @@
+import type { CoercedAdapterRequestContext, Luvio, Snapshot, StoreLookup } from '@luvio/engine';
+import type { GraphQLBatchRepresentation, EnvironmentAwareGraphQLBatchAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { ObjectInfoService } from '../types';
+export declare function environmentAwareGraphQLBatchAdapterFactory(objectInfoService: ObjectInfoService, luvio: Luvio, isDraftId: (id: string) => boolean, buildCachedSnapshotCachePolicy: (context: any, storeLookup: StoreLookup<GraphQLBatchRepresentation, unknown>) => Snapshot<GraphQLBatchRepresentation, any>, buildNetworkSnapshotCachePolicy: (context: any, coercedAdapterRequestContext: CoercedAdapterRequestContext) => Promise<Snapshot<GraphQLBatchRepresentation, any>>): EnvironmentAwareGraphQLBatchAdapter;

package/sfdc/types/graphql/adapter/graphqlEvalAdapterFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+import type { DraftAwareGraphQLAdapter } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { ObjectInfoService } from '../types';
+export declare function graphqlEvalAdapterFactory(_userId: string, _objectInfoService: ObjectInfoService, _store: SqliteStore, _luvio: Luvio, _isDraftId: (id: string) => boolean): DraftAwareGraphQLAdapter;

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

@@ -0,0 +1,2 @@
+import type { Luvio } from '@luvio/engine';
+export declare function getCanonicalIdFunction(luvio: Luvio): (id: string) => string;

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

@@ -0,0 +1,3 @@
+export { draftAwareGraphQLAdapterFactory } from './adapter/draftAwareGraphQLAdapterFactory';
+export { environmentAwareGraphQLBatchAdapterFactory } from './adapter/environmentAwareGraphQLBatchAdapterFactory';
+export { graphqlEvalAdapterFactory } from './adapter/graphqlEvalAdapterFactory';

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

@@ -0,0 +1,2 @@
+export declare function removeUndefined<T>(array: T[]): NonNullable<T>[];
+export declare function flat(arr: any[], d?: number): any[];

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

@@ -0,0 +1,4 @@
+export declare function btoaPolyfill(input: string): string;
+export declare function atobPolyfill(data: string): string;
+export declare const base64encode: (data: string) => string;
+export declare const base64decode: (data: string) => string;

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

@@ -0,0 +1,3 @@
+export declare const JSON_EXTRACT_PATH_INGESTION_TIMESTAMP = "$.ingestionTimestamp";
+export declare const JSON_EXTRACT_PATH_INGESTION_APINAME = "$.apiName";
+export declare const JSON_EXTRACT_PATH_DRAFTS = "$.drafts";

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

@@ -0,0 +1,19 @@
+import type { AvailableSnapshot } from '@luvio/engine';
+import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteResult, SqliteStore, SqliteType } from '@salesforce/lds-store-sql';
+import type { DataLoader } from './dataloader';
+import type { DraftFunctions, LocalEvaluationRuntimeSettings, ObjectInfoMap, RecordRepresentation } from './types';
+export type QueryFunction = (sql: string, params: SqliteType[]) => Promise<SqliteResult>;
+export type ResolverContext = {
+    query: QueryFunction;
+    objectInfos: ObjectInfoMap;
+    eventEmitter: (eventData: unknown) => void;
+    settings: LocalEvaluationRuntimeSettings;
+    Record: DataLoader<string, RecordRepresentation>;
+    snapshot: AvailableSnapshot<GraphQLRepresentation>;
+    seenRecordIds: Set<string>;
+    possibleStaleRecordMap: Map<string, string[]>;
+    draftFunctions?: DraftFunctions;
+    mappedCursors: Map<string, string>;
+};
+export declare function createContext(store: SqliteStore, objectInfos: ObjectInfoMap, eventEmitter: (eventData: unknown) => void, settings: LocalEvaluationRuntimeSettings, snapshot: AvailableSnapshot<GraphQLRepresentation>, mappedCursors?: Map<string, string>, draftFunctions?: DraftFunctions): ResolverContext;

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

@@ -0,0 +1,26 @@
+type BatchLoadFn<Key> = (keys: Key[]) => Promise<any>;
+type Batch<Key, Value> = {
+    hasDispatched: boolean;
+    keys: Array<Key>;
+    callbacks: Array<{
+        resolve: (value: Value) => void;
+        reject: (error: Error) => void;
+    }>;
+    cacheHits?: Array<() => void>;
+};
+export declare class DataLoader<Key, Value> {
+    private _batch;
+    private _batchLoadFn;
+    private _batchScheduleFn;
+    private _cacheMap;
+    private _maxBatchSize;
+    constructor(batchLoadFn: BatchLoadFn<Key>, options?: {
+        maxBatchSize?: number;
+    });
+    load(key: Key): Promise<Value>;
+    getCurrentBatch(): Batch<Key, Value>;
+    dispatchBatch(batch: Batch<Key, Value>): void;
+    failedDispatch(batch: Batch<Key, Value>, error: Error): void;
+    clear(key: Key): void;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import type { Operator, SinglePredicate } from './query';
+import type { FieldRepresentation } from './types';
+export declare enum DateLiteral {
+    NEXT_YEAR = "NEXT_YEAR",
+    LAST_WEEK = "LAST_WEEK",
+    THIS_MONTH = "THIS_MONTH",
+    THIS_QUARTER = "THIS_QUARTER",
+    LAST_MONTH = "LAST_MONTH",
+    LAST_90_DAYS = "LAST_90_DAYS",
+    LAST_QUARTER = "LAST_QUARTER",
+    THIS_YEAR = "THIS_YEAR",
+    NEXT_QUARTER = "NEXT_QUARTER",
+    NEXT_MONTH = "NEXT_MONTH",
+    TOMORROW = "TOMORROW",
+    TODAY = "TODAY",
+    LAST_YEAR = "LAST_YEAR",
+    NEXT_90_DAYS = "NEXT_90_DAYS",
+    THIS_WEEK = "THIS_WEEK",
+    YESTERDAY = "YESTERDAY",
+    NEXT_WEEK = "NEXT_WEEK"
+}
+export interface DateRange {
+    lowerBound: string;
+    upperBound: string;
+}
+export declare function quarterStart(date: Date): string;
+export declare function dateLiteralRange(literal: DateLiteral): DateRange;
+export declare function dateLiteral(literal: DateLiteral, op: Operator, field: FieldRepresentation, alias: string): SinglePredicate;

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

@@ -0,0 +1,33 @@
+import type { Operator, SinglePredicate } from './query';
+import type { FieldRepresentation } from './types';
+import { DateLiteral } from './dateLiteral';
+export declare enum DateRange {
+    last_n_days = "last_n_days",
+    next_n_days = "next_n_days",
+    n_days_ago = "n_days_ago",
+    last_n_weeks = "last_n_weeks",
+    next_n_weeks = "next_n_weeks",
+    n_weeks_ago = "n_weeks_ago",
+    last_n_months = "last_n_months",
+    next_n_months = "next_n_months",
+    n_months_ago = "n_months_ago",
+    last_n_quarters = "last_n_quarters",
+    next_n_quarters = "next_n_quarters",
+    n_quarters_ago = "n_quarters_ago",
+    last_n_fiscal_quarters = "last_n_fiscal_quarters",
+    next_n_fiscal_quarters = "next_n_fiscal_quarters",
+    last_n_years = "last_n_years",
+    next_n_years = "next_n_years",
+    n_years_ago = "n_years_ago",
+    last_n_fiscal_years = "last_n_fiscal_years",
+    next_n_fiscal_years = "next_n_fiscal_years"
+}
+type DateTime = string;
+export type DateTimeInput = {
+    value: DateTime | null;
+    literal: DateLiteral;
+    range: DateRangeInput;
+};
+type DateRangeInput = Record<string, number>;
+export declare function dateTimePredicate(input: Partial<DateTimeInput>, operator: Operator, field: FieldRepresentation, alias: string): SinglePredicate;
+export {};

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

@@ -0,0 +1,12 @@
+import { type CachedGraphQLSchema } from './schema';
+import type { AvailableSnapshot, LuvioAdapterEventObserver } from '@luvio/engine';
+import type { GraphQLConfig, GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { DraftFunctions, LocalEvaluationRuntimeSettings, ObjectInfoMap } from './types';
+type LocalEvaluationResult = {
+    result: GraphQLRepresentation;
+    seenRecordIds: string[];
+    possibleStaleRecordMap: Map<string, string[]>;
+};
+export declare function evaluate(config: GraphQLConfig, observers: LuvioAdapterEventObserver[], settings: LocalEvaluationRuntimeSettings, objectInfos: ObjectInfoMap, store: SqliteStore, snapshot: AvailableSnapshot<GraphQLRepresentation>, cache: CachedGraphQLSchema, draftFunctions?: DraftFunctions, mappedCursors?: Map<string, string>): Promise<LocalEvaluationResult>;
+export {};

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

@@ -0,0 +1,37 @@
+import type { CustomAdapterEvent } from '@luvio/engine';
+import type { SqliteType } from '@salesforce/lds-store-sql';
+import type { QueryInstrumentation } from './instrumentLimits';
+export declare const GRAPHQL_EVAL_NAMESPACE = "graphql-eval";
+interface GraphQLEvalStartCustomEventData {
+    type: 'graphql-eval-start';
+}
+interface GraphQLEvalPreconditionsMetCustomEventData {
+    type: 'graphql-eval-preconditions-met';
+}
+interface GraphQLEvalEndCustomEventData {
+    type: 'graphql-eval-end';
+}
+interface GraphQLDbReadCustomEventData {
+    type: 'graphql-db-read';
+    sql: string;
+    bindings: SqliteType[];
+    duration: number;
+}
+interface GraphQLEvalPreconditionErrorCustomEventData {
+    type: 'graphql-eval-precondition-error';
+    error: unknown;
+}
+interface GraphQLCreateSnapshotErrorCustomEventData {
+    type: 'graphql-create-snapshot-error';
+    error: unknown;
+}
+interface GraphQLQueryInstrumentationCustomEventData {
+    type: 'graphql-query-instrumentation';
+    data: QueryInstrumentation;
+}
+interface GraphQLSnapshotRefreshUndefined {
+    type: 'graphql-luvio-refresh-undefined';
+}
+export type GraphQLEvalCustomAdapterEventData = GraphQLEvalStartCustomEventData | GraphQLEvalPreconditionsMetCustomEventData | GraphQLEvalEndCustomEventData | GraphQLCreateSnapshotErrorCustomEventData | GraphQLEvalPreconditionErrorCustomEventData | GraphQLDbReadCustomEventData | GraphQLQueryInstrumentationCustomEventData | GraphQLSnapshotRefreshUndefined;
+export declare function isGraphQLEvalEvent(customEvent: CustomAdapterEvent<unknown>): customEvent is CustomAdapterEvent<GraphQLEvalCustomAdapterEventData>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { DraftFunctions, ObjectInfoMap } from './types';
+import { type Join } from './query';
+import type { PredicateValue, SqlAndBindings } from './query';
+export declare function filterToPredicates(where: any, recordType: string, alias: string, objectInfoMap: ObjectInfoMap, joins: Join[], draftFunctions?: DraftFunctions): PredicateValue[];
+export declare function predicateToSQL(predicate: PredicateValue, defaultAlias: string, isChildNotPredicate?: boolean): SqlAndBindings;
+export declare function predicatesToSqls(predicates: PredicateValue[], defaultAlias: string, isChildNotPredicate?: boolean): SqlAndBindings[];

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

@@ -0,0 +1,9 @@
+export { evaluate } from './evaluate';
+export { injectSyntheticFields, removeSyntheticFields } from './syntheticFields';
+export { DateLiteral } from './dateLiteral';
+export { DateRange } from './dateTimePredication';
+export { createSchemaWithCache, extendSchemaWithObjectInfos, CachedGraphQLSchema } from './schema';
+export type { ObjectInfoService, IDMapper, DraftFunctions } from './types';
+export { draftAwareGraphQLAdapterFactory, environmentAwareGraphQLBatchAdapterFactory, graphqlEvalAdapterFactory, } from './adapterFactory';
+export { isLocalEvalSnapshot } from './snapshot';
+export { isGraphQLEvalEvent } from './events';

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

@@ -0,0 +1,8 @@
+import type { DocumentNode } from '@luvio/graphql-parser';
+export type QueryInstrumentation = {
+    rootQueryCount: number;
+    totalQueryCount: number;
+    maxChildRelationships: number;
+    requestedRecordCount: number;
+};
+export declare function instrumentLimits(ast: DocumentNode, variables: Record<string, any>): QueryInstrumentation;

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

@@ -0,0 +1,52 @@
+import type { FieldNode, InlineFragmentNode, SelectionNode, ArgumentNode, OperationDefinitionNode, ASTNode } from '@luvio/graphql-parser';
+import type { FieldRepresentation, ObjectInfoRepresentation, RelationshipType } from './types';
+import type { QueryFunction } from './context';
+export declare const POLYMORPHIC_PARENT_RELATIONSHIP = "polymorphicParentRelationship";
+export declare const PARENT_RELATIONSHIP = "parentRelationship";
+export declare const CHILD_RELATIONSHIP = "childRelationship";
+declare const RECORD_QUERY = "recordQuery";
+type CategoryType = typeof POLYMORPHIC_PARENT_RELATIONSHIP | typeof PARENT_RELATIONSHIP | typeof CHILD_RELATIONSHIP | typeof RECORD_QUERY;
+export declare function requestsDraftsField(recordFieldNode: FieldNode): boolean;
+type RecordQueryPathInfo = {
+    node: FieldNode | InlineFragmentNode | undefined;
+    parentIndex: number;
+};
+export declare function fieldHasCategory(field: FieldNode, categories: ReadonlyArray<CategoryType>): boolean;
+export declare function isRecordQuery(field: FieldNode | undefined): boolean;
+export declare function isChildRelationshipQuery(field: FieldNode): boolean;
+export declare function isParentRelationshipQuery(field: FieldNode): boolean;
+export declare function findNearestConnection(ancestors: ReadonlyArray<any>): FieldNode | undefined;
+export declare function findNearestConnectionWithPath(ancestors: ReadonlyArray<any>): {
+    connection: FieldNode | undefined;
+    path: string | undefined;
+};
+export declare function findNearestAncesterPath(ancestors: ReadonlyArray<any>, connectionOnly: boolean): RecordQueryPathInfo;
+export declare function findAncesterPath(ancesters: ReadonlyArray<any>): string;
+/**
+ * checks if the 'SelectionNode' has the potential to have relationship(parent or child) with its ancestor.
+ * @param node
+ * @returns
+ */
+export declare function isCapableRelationship(node: SelectionNode): boolean;
+/**
+ * checks if the 'ArgumentNode' is a specific scope type
+ * @param node
+ * @param scopeType
+ * @param variables
+ * @returns
+ */
+export declare function isScopeArgumentNodeWithType(node: ArgumentNode, scopeType: string, variables?: Record<string, any>): boolean;
+export declare function getRelation(node: FieldNode | InlineFragmentNode): RelationshipType;
+export declare function isFieldSpanning(node: SelectionNode, parentNode?: FieldNode | InlineFragmentNode): boolean;
+export declare function isInlineFragmentFieldSpanning(node: SelectionNode): boolean;
+export declare function isRelationship(node: FieldNode | InlineFragmentNode, relationship: RelationshipType): boolean;
+export declare function isFieldAvailable(field: string, objectInfo: ObjectInfoRepresentation): boolean;
+export declare function mergeFieldNode(node1: FieldNode, node2: FieldNode): FieldNode;
+export declare function mergeInLineFragmentNode(node1: InlineFragmentNode, node2: InlineFragmentNode): InlineFragmentNode;
+export declare function depth(json: any, currentLevel?: number): number;
+export declare function flatten<T>(previous: T[], current: T[]): T[];
+export declare function findFieldInfo(objectInfo: ObjectInfoRepresentation, fieldName: string): FieldRepresentation | undefined;
+export declare function readIngestionTimestampForKey(key: string, query: QueryFunction): Promise<number>;
+export declare function isObjectDefinitionNode(node: ASTNode): node is OperationDefinitionNode;
+export declare function operationNodeAncestor(ancestors: ReadonlyArray<any>): OperationDefinitionNode | undefined;
+export {};

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

@@ -0,0 +1,10 @@
+import { type DocumentNode } from 'graphql';
+import type { ObjectInfoMap } from './types';
+type EnforcedLimits = {
+    maxFieldCount: number;
+    maxRecordLimit: number;
+    singleRecordField: string;
+    maxFieldSize: number;
+};
+export declare function enforceFieldLimitOnAST(ast: DocumentNode, variables: Record<string, any>, objectInfos: ObjectInfoMap, enforcedLimits?: EnforcedLimits): DocumentNode;
+export {};

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

@@ -0,0 +1,10 @@
+import type { ObjectInfoMap } from './types';
+import type { Join } from './query';
+export type OrderByPredicate = {
+    alias: string;
+    path: string;
+    order?: 'ASC' | 'DESC';
+    nulls?: 'FIRST' | 'LAST';
+    joins?: Join[];
+};
+export declare function orderByToPredicate(orderBy: any, recordType: string, alias: string, objectInfoMap: ObjectInfoMap, joins?: Join[]): OrderByPredicate[];

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

@@ -0,0 +1,10 @@
+import type { QueryFunction } from './context';
+import type { DocumentNode } from '@luvio/graphql-parser';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export type PaginationMetadata = Record<string, number | undefined>;
+export declare function mapCursorValue(originalValue: string | null | undefined, paginationMetadata: PaginationMetadata): string | null;
+export declare function mapPaginationCursors(originalAST: DocumentNode, variables: Record<string, any>, store: SqliteStore): Promise<{
+    ast: DocumentNode;
+    mappedCursors: Map<string, string>;
+}>;
+export declare function readPaginationMetadataForKeys(keys: string[], query: QueryFunction): Promise<Map<string, PaginationMetadata>>;

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

@@ -0,0 +1,56 @@
+import type { OrderByPredicate } from './orderByParser';
+import type { SQLStatement } from './types';
+export type PredicatePath = {
+    leftPath: string;
+    rightPath: string;
+};
+export type DataType = 'Boolean' | 'String' | 'Double' | 'Date' | 'DateTime' | 'Int' | 'WeakEtag' | 'Reference' | 'Picklist' | 'Currency' | 'MultiPicklist' | 'Time' | 'Phone' | 'Url' | 'TextArea' | 'Email' | 'Percent';
+export type PredicateValue = CompoundPredicate | SinglePredicate | NotPredicate;
+export type NotPredicate = {
+    type: PredicateType.not;
+    operator: NotOperator;
+    children: (CompoundPredicate | SinglePredicate)[];
+};
+export type CompoundPredicate = {
+    type: PredicateType.compound;
+    operator: CompoundOperator;
+    children: PredicateValue[];
+};
+export type SinglePredicate = {
+    type: PredicateType.single;
+    alias?: string;
+    leftPath: string;
+    operator: Operator;
+    value: unknown;
+    bindings?: unknown[];
+    dataType?: DataType;
+    isCaseSensitive?: boolean;
+};
+export type CompoundOperator = 'and' | 'or';
+export type NotOperator = 'not';
+export type Operator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'IN' | 'NOT IN' | 'LIKE' | 'NOT LIKE' | 'BETWEEN' | 'NOT BETWEEN' | 'IS' | 'IS NOT';
+export declare enum PredicateType {
+    compound = "compound",
+    single = "single",
+    not = "not"
+}
+export type SqlAndBindings = {
+    sql: string;
+    binding: any[];
+};
+export type Join = {
+    type: 'INNER' | 'LEFT';
+    alias: string;
+    to: string;
+    apiName?: string;
+    conditions: (PredicatePath | PredicateValue)[];
+};
+export type QueryBuilderConfig = {
+    alias: string;
+    joins?: Join[];
+    predicates?: PredicateValue[];
+    limit?: number;
+    offset?: number;
+    orderBy?: OrderByPredicate[];
+};
+export declare function buildQuery(config: QueryBuilderConfig): SQLStatement;

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

@@ -0,0 +1,4 @@
+import { DataLoader } from './dataloader';
+import type { SqliteResult, SqliteType } from '@salesforce/lds-store-sql';
+import type { RecordRepresentation } from './types';
+export declare function recordLoaderFactory(query: (sql: string, params: SqliteType[]) => Promise<SqliteResult>): DataLoader<string, RecordRepresentation>;

package/sfdc/types/graphql/resolvers/basic.d.ts

@@ -0,0 +1 @@
+export declare function passThroughResolver(source: any): any;

package/sfdc/types/graphql/resolvers/connection.d.ts

@@ -0,0 +1,31 @@
+import type { RecordQueryArgs, RecordRepresentation } from '../types';
+import type { ArgumentNode, GraphQLResolveInfo, OperationDefinitionNode } from 'graphql';
+import type { ResolverContext } from '../context';
+export type RecordInformation = {
+    recordRepresentation: RecordRepresentation;
+    ingestionTimestamp: number;
+};
+export type IndexedRecordInformation = RecordInformation & {
+    index: number;
+    earlyEnd?: boolean;
+};
+export type RecordConnectionInformation = {
+    records: IndexedRecordInformation[];
+    hasNextPage: boolean;
+    earlyEnd: boolean;
+    offset: number;
+};
+export declare function connectionResolver(obj: Partial<RecordInformation>, args: RecordQueryArgs, context: ResolverContext, info: GraphQLResolveInfo): Promise<RecordConnectionInformation>;
+/**
+ * Returns just the records array of a connection result, used for edges field
+ */
+export declare function edgesResolver(obj: RecordConnectionInformation): IndexedRecordInformation[];
+/**
+ * Builds the top level record query key based on AST data
+ * @param operation
+ * @param variables
+ * @param argumentNodes
+ * @param currentFieldName
+ * @returns
+ */
+export declare function buildKeyStringForRecordQuery(operation: OperationDefinitionNode, variables: Record<string, any>, argumentNodes: Readonly<ArgumentNode[]>, currentFieldName: string): string;

package/sfdc/types/graphql/resolvers/index.d.ts

@@ -0,0 +1,8 @@
+import type { GraphQLSchema } from '@luvio/graphql-parser';
+/**
+ *
+ * @param schema GraphQL Schema generated from ObjectInfos
+ * @param polyFields The record types which support polymorphic fields. For example, 'Owner' has the 'Record' interface which is a polymorphic fields. The 'User' and 'Group' are the concrete types which support 'Owner' interface.
+ * @returns Updated schema
+ */
+export declare function addResolversToSchema(schema: GraphQLSchema, polyFields: string[]): GraphQLSchema;

package/sfdc/types/graphql/resolvers/pagination.d.ts

@@ -0,0 +1,29 @@
+import type { IndexedRecordInformation, RecordConnectionInformation } from './connection';
+import type { FragmentDefinitionNode, SelectionNode } from 'graphql';
+export declare function cursorResolver(source: IndexedRecordInformation): string;
+export declare function pageInfoResolver(source: RecordConnectionInformation): {
+    startCursor: null;
+    endCursor: string;
+    hasNextPage: boolean;
+} | {
+    startCursor: null;
+    endCursor: null;
+    hasNextPage: boolean;
+} | {
+    startCursor: string;
+    endCursor: string;
+    hasNextPage: boolean;
+};
+export declare function pageResultCountResolver(source: RecordConnectionInformation): number;
+export interface LocalCursor {
+    i: number;
+    e?: unknown;
+}
+export declare function encodeV1Cursor(cursor: LocalCursor): string;
+export declare function decodeV1Cursor(base64cursor: string): LocalCursor;
+/**
+ * Check the selections for any selection matching `pageInfo { hasNextPage }`
+ */
+export declare function selectionIncludesHasNextPage(selections: ReadonlyArray<SelectionNode>, fragments: {
+    [key: string]: FragmentDefinitionNode;
+}): boolean;

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

@@ -0,0 +1,51 @@
+import { type GraphQLSchema } from '@luvio/graphql-parser';
+import type { ObjectInfoMap } from './types';
+export declare class CachedGraphQLSchema {
+    private _schema;
+    private _polymorphicFieldTypeNames;
+    constructor();
+    getSchema(): GraphQLSchema;
+    setSchema(value: GraphQLSchema): void;
+    getPolymorphicFieldTypeNames(): string[];
+    setPolymorphicFieldTypeNames(value: string[]): void;
+    set(schema: GraphQLSchema, polymorphicFieldTypeNames: string[]): void;
+}
+/**
+ * Looks at the injected object info map and checks to see if the existing objects
+ * are within the current schema. It will extend the cached schema if it is not included.
+ * @param objectInfos
+ * @param cache
+ * @returns GraphQLSchema
+ */
+export declare function createSchemaWithCache(objectInfos: ObjectInfoMap, cache: CachedGraphQLSchema): GraphQLSchema;
+/**
+ * Extends the current GraphQL Schema with new types based on the given object info map
+ *
+ * @param cache the existing cached schema object
+ * @param objectInfoMap map of object info and apiname for key
+ * @returns CachedGraphQLSchema
+ */
+export declare function extendSchemaWithObjectInfos(cache: CachedGraphQLSchema, objectInfoMap: ObjectInfoMap): CachedGraphQLSchema;
+/**
+ * Builds the base schema from uiapi graphql adapter with resolvers attached
+ * @returns GraphQLSchema
+ */
+export declare function buildBaseSchema(): GraphQLSchema;
+/**
+ * Given the existing schema and the object infos it will create a new type for the schema
+ * or extend an existing type to add new fields to it.
+ *
+ * Extends RecordQuery to add new top level queries
+ * extend type RecordQuery {
+ *   Account(predicates): AccountConnection
+ * }
+ * @param schema
+ * @param objectInfoMap
+ * @returns
+ */
+export declare function generateRecordQueries(schema: GraphQLSchema, objectInfoMap: ObjectInfoMap): {
+    recordQueries: string;
+    recordConnections: string;
+    recordExtensions: string;
+    polyFieldTypeNameArr: string[];
+};

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

@@ -0,0 +1,4 @@
+import type { Join, PredicateValue } from './query';
+import type { LocalEvaluationRuntimeSettings } from './types';
+export declare function scopeToJoins(scope: string | undefined, settings: LocalEvaluationRuntimeSettings): Join[];
+export declare function scopeToPredicates(scope: string | undefined, settings: LocalEvaluationRuntimeSettings): PredicateValue[];

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

@@ -0,0 +1,26 @@
+import type { Snapshot, ErrorSnapshot, AvailableSnapshot, NormalizedKeyMetadata, SnapshotRefresh } from '@luvio/engine';
+import { StoreKeySet } from '@luvio/engine';
+import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+export type StaleRefreshLocalEvalSnapshot = LocalEvalSnapshot & {
+    refreshStaleRecords: (keys: Set<string>) => Promise<void>;
+};
+export type LocalEvalSnapshot = AvailableSnapshot<GraphQLRepresentation> & {
+    rebuildWithLocalEval: (originalSnapshot: AvailableSnapshot<GraphQLRepresentation>) => Promise<LocalEvalSnapshot>;
+};
+export declare function isLocalEvalSnapshot(snapshot: Snapshot<unknown>): snapshot is LocalEvalSnapshot;
+export declare function createSeenRecords(ids: string[], currentSnapshot: AvailableSnapshot<unknown>): StoreKeySet<string | NormalizedKeyMetadata>;
+export declare function createErrorSnapshot(result: Partial<{
+    errors: any[];
+}>, snapshot: Snapshot<unknown>): ErrorSnapshot;
+export declare function createLocalEvalSnapshot<D>(data: GraphQLRepresentation, seenRecords: StoreKeySet<string | NormalizedKeyMetadata>, recordId: string, rebuildWithLocalEval: LocalEvalSnapshot['rebuildWithLocalEval'], refresh?: SnapshotRefresh<any>): LocalEvalSnapshot;
+/**
+ * If we can't reach the server or if we get back a 504 (which means only-if-cached
+ * cache policy was used but this query hasn't been cached) then we still want to
+ * attempt an eval.  All other errors should be returned to caller.
+ */
+export declare function isErrorSnapshotThatShouldGetReturnedToCaller(snapshot: Snapshot<GraphQLRepresentation>): boolean;
+/**
+ * Checks a GraphQL-shaped network response for errors, returning true if it does
+ * and false otherwise
+ */
+export declare function hasGraphQlErrors(response: GraphQLRepresentation | undefined): boolean;

package/sfdc/types/graphql/staleRecords/batchingStaleRecordsAdapter.d.ts

@@ -0,0 +1,10 @@
+import { type Adapter, type Luvio } from '@luvio/engine';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+/**
+ * Adapter for limiting the number of record ids to a maximum of 100 and sending them
+ * out in batches to the getRecords adapter
+ *
+ * @param luvio
+ * @returns
+ */
+export declare function batchingGetRecordsAdapterFactory(luvio: Luvio): Adapter<GetRecordsConfig, BatchRepresentation>;