@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/replication-google-drive/downstream.d.ts

@@ -0,0 +1,10 @@
+import type { DriveFileMetadata, GoogleDriveCheckpointType, GoogleDriveOptionsWithDefaults } from './google-drive-types';
+import { DriveStructure } from './init.ts';
+export declare function fetchChanges<DocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, checkpoint?: GoogleDriveCheckpointType, batchSize?: number): Promise<{
+    checkpoint: GoogleDriveCheckpointType | undefined;
+    documents: DocType[];
+}>;
+export declare function fetchChangesFiles(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, checkpoint?: GoogleDriveCheckpointType, batchSize?: number): Promise<{
+    checkpoint?: GoogleDriveCheckpointType;
+    files: DriveFileMetadata[];
+}>;

package/dist/types/plugins/replication-google-drive/google-drive-helper.d.ts

@@ -0,0 +1,35 @@
+import type { GoogleDriveOptionsWithDefaults, DriveFileMetadata } from './google-drive-types.ts';
+export declare const DRIVE_API_VERSION = "v3";
+export declare const DRIVE_MAX_PAGE_SIZE = 1000;
+export declare const DRIVE_MAX_BULK_SIZE: number;
+export declare const FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+export declare function createFolder(googleDriveOptions: GoogleDriveOptionsWithDefaults, parentId: string | undefined, folderName: string): Promise<string>;
+export declare function findFolder(googleDriveOptions: GoogleDriveOptionsWithDefaults, parentId: string | undefined, folderName: string): Promise<string | undefined>;
+export declare function ensureFolderExists(googleDriveOptions: GoogleDriveOptionsWithDefaults, folderPath: string): Promise<string>;
+export declare function createEmptyFile(googleDriveOptions: GoogleDriveOptionsWithDefaults, parentId: string, fileName: string): Promise<{
+    status: number;
+    etag: any;
+    createdTime: any;
+    fileId: any;
+    size: number;
+}>;
+export declare function fillFileIfEtagMatches<T = any>(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileId: string, etag: string, jsonContent?: any): Promise<{
+    status: number;
+    etag: string;
+    content: T | undefined;
+    serverTime: number;
+}>;
+export declare function deleteIfEtagMatches(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileId: string, etag: string): Promise<void>;
+export declare function deleteFile(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileId: string): Promise<void>;
+export declare function readJsonFileContent<T>(googleDriveOptions: GoogleDriveOptionsWithDefaults, fileId: string): Promise<{
+    etag: string;
+    content: T | undefined;
+    serverTime: number;
+}>;
+export declare function readFolder(googleDriveOptions: GoogleDriveOptionsWithDefaults, folderPath: string): Promise<DriveFileMetadata[]>;
+export declare function insertMultipartFile<T>(googleDriveOptions: GoogleDriveOptionsWithDefaults, folderId: string, filename: string, jsonData: T): Promise<void>;
+export declare function createMultipartBody(metadata: Record<string, unknown>, content: string): {
+    body: string;
+    boundary: string;
+};
+export declare function listFilesInFolder(googleDriveOptions: GoogleDriveOptionsWithDefaults, folderId: string): Promise<DriveFileMetadata[]>;

package/dist/types/plugins/replication-google-drive/google-drive-types.d.ts

@@ -0,0 +1,67 @@
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { SignalingOptions } from './signaling.ts';
+export type GoogleDriveCheckpointType = {
+    modifiedTime: string;
+    /**
+     * There is no way to do a comparison (> or >=)
+     * on fileNames or ids in google drive.
+     * Also modifiedTime can be sometimes the same
+     * on multiple files.
+     * Therefore we might overfetch documents and
+     * after the request removed the ones that have been known before.
+     */
+    docIdsWithSameModifiedTime: string[];
+};
+export interface DriveFileMetadata {
+    id: string;
+    name: string;
+    mimeType: string;
+    parents?: string[];
+    modifiedTime?: string;
+    size?: string;
+    fileSize?: string;
+}
+export type GoogleDriveOptions = {
+    oauthClientId: string;
+    authToken: string;
+    /**
+     * like "https://www.googleapis.com"
+     * No trailing slash!
+     */
+    apiEndpoint?: string;
+    /**
+     * Path to a folder in Google Drive where all data is stored.
+     * Example: 'rxdb-replication/my-app'
+     */
+    folderPath: string;
+    /**
+     * Time in milliseconds.
+     */
+    transactionTimeout?: number;
+};
+export type GoogleDriveOptionsWithDefaults = {
+    oauthClientId: string;
+    authToken: string;
+    /**
+     * like "https://www.googleapis.com"
+     * No trailing slash!
+     */
+    apiEndpoint: string;
+    folderPath: string;
+    /**
+     * Time in milliseconds.
+     */
+    transactionTimeout: number;
+};
+export interface DriveFileListResponse {
+    nextPageToken?: string;
+    files: DriveFileMetadata[];
+}
+export type GoogleDriveSyncPullOptions<RxDocType> = Omit<ReplicationPullOptions<RxDocType, GoogleDriveCheckpointType>, 'handler' | 'stream$'>;
+export type GoogleDriveSyncPushOptions<RxDocType> = Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+export type SyncOptionsGoogleDrive<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push'> & {
+    googleDrive: GoogleDriveOptions;
+    signalingOptions?: SignalingOptions;
+    pull?: GoogleDriveSyncPullOptions<RxDocType>;
+    push?: GoogleDriveSyncPushOptions<RxDocType>;
+};

package/dist/types/plugins/replication-google-drive/index.d.ts

@@ -0,0 +1,39 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { GoogleDriveCheckpointType, GoogleDriveOptionsWithDefaults, SyncOptionsGoogleDrive } from './google-drive-types.ts';
+import { DriveStructure } from './init.ts';
+import { SignalingOptions, SignalingState } from './signaling.ts';
+export * from './google-drive-types.ts';
+export * from './google-drive-helper.ts';
+export * from './transaction.ts';
+export * from './init.ts';
+export * from './document-handling.ts';
+export * from './multipart.ts';
+export * from './downstream.ts';
+export * from './upstream.ts';
+export * from './signaling.ts';
+export declare const DEFAULT_TRANSACTION_TIMEOUT: number;
+export declare class RxGoogleDriveReplicationState<RxDocType> extends RxReplicationState<RxDocType, GoogleDriveCheckpointType> {
+    readonly googleDrive: GoogleDriveOptionsWithDefaults;
+    readonly driveStructure: DriveStructure;
+    readonly replicationIdentifierHash: string;
+    readonly collection: RxCollection<RxDocType, any>;
+    readonly pull?: ReplicationPullOptions<RxDocType, GoogleDriveCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly signalingOptions?: SignalingOptions | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    /**
+     * Only exists on live replication
+     */
+    signalingState?: SignalingState;
+    constructor(googleDrive: GoogleDriveOptionsWithDefaults, driveStructure: DriveStructure, replicationIdentifierHash: string, collection: RxCollection<RxDocType, any>, pull?: ReplicationPullOptions<RxDocType, GoogleDriveCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, signalingOptions?: SignalingOptions | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+    /**
+     * Notify other peers that something
+     * has or might have changed so that
+     * they can pull from their checkpoints.
+     */
+    notifyPeers(): Promise<void>;
+}
+export declare function replicateGoogleDrive<RxDocType>(options: SyncOptionsGoogleDrive<RxDocType>): Promise<RxGoogleDriveReplicationState<RxDocType>>;

package/dist/types/plugins/replication-google-drive/init.d.ts

@@ -0,0 +1,29 @@
+import type { GoogleDriveOptionsWithDefaults } from './google-drive-types.ts';
+export declare function initDriveStructure(googleDriveOptions: GoogleDriveOptionsWithDefaults): Promise<{
+    rootFolderId: string;
+    docsFolderId: string;
+    signalingFolderId: string;
+    replicationIdentifier: string;
+    rxdbJson: {
+        status: number;
+        etag: any;
+        createdTime: any;
+        fileId: any;
+        size: number;
+    };
+    transactionFile: {
+        status: number;
+        etag: any;
+        createdTime: any;
+        fileId: any;
+        size: number;
+    };
+    walFile: {
+        status: number;
+        etag: any;
+        createdTime: any;
+        fileId: any;
+        size: number;
+    };
+}>;
+export type DriveStructure = Awaited<ReturnType<typeof initDriveStructure>>;

package/dist/types/plugins/replication-google-drive/multipart.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses a multipart/mixed response body from Google Drive Batch API.
+ * Returns an array of objects containing { status, headers, body }.
+ */
+export declare function parseBatchResponse(body: string): {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}[];
+export declare function findDoubleNewline(str: string): number;

package/dist/types/plugins/replication-google-drive/signaling.d.ts

@@ -0,0 +1,41 @@
+import type { Instance as SimplePeerInstance } from 'simple-peer';
+import { SimplePeerConfig, SimplePeerWrtc } from '../replication-webrtc/connection-handler-simple-peer';
+import { DriveStructure } from './init.ts';
+import { GoogleDriveOptionsWithDefaults } from './google-drive-types.ts';
+export type SignalingOptions = {
+    wrtc?: SimplePeerWrtc;
+    config?: SimplePeerConfig;
+};
+export type SIGNAL = 'RESYNC' | 'NEW_PEER';
+export declare class SignalingState {
+    private googleDriveOptions;
+    private init;
+    private signalingOptions;
+    readonly sessionId: string;
+    readonly processedMessageIds: Set<string>;
+    /**
+     * Emits whenever a new connection
+     * is there or some connection
+     * told us to RESYNC
+     */
+    private _resync$;
+    resync$: import("rxjs").Observable<void>;
+    peerBySenderId: Map<string, SimplePeerInstance>;
+    private processQueue;
+    private backoffStepId;
+    private skipBackoffTime?;
+    closed: boolean;
+    resetReaderFn: () => void;
+    constructor(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, signalingOptions: SignalingOptions);
+    sendMessage(data: any): Promise<void>;
+    pingPeers(message: SIGNAL): Promise<void>;
+    resetReadLoop(): Promise<void>;
+    processNewMessages(): Promise<any>;
+    _processNewMessages(): Promise<void>;
+    close(): void;
+}
+export declare function readMessages(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, processedMessageIds: Set<string>): Promise<{
+    senderId: string;
+    data: any;
+}[]>;
+export declare function cleanupOldSignalingMessages(googleDriveOptions: GoogleDriveOptionsWithDefaults, signalingFolderId: string, maxAgeMs?: number): Promise<number>;

package/dist/types/plugins/replication-google-drive/transaction.d.ts

@@ -0,0 +1,22 @@
+import type { GoogleDriveOptionsWithDefaults } from './google-drive-types.ts';
+import { DriveStructure } from './init.ts';
+export type DriveTransaction = {
+    etag: string;
+};
+export type TransactionFileContent = {
+    createdAtClientTime: number;
+};
+export declare const TRANSACTION_FILE_NAME = "transaction.json";
+export declare const TRANSACTION_BLOCKED_FLAG: {
+    readonly retry: true;
+};
+export declare function startTransactionTryOnce(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure): Promise<typeof TRANSACTION_BLOCKED_FLAG | DriveTransaction>;
+export declare function startTransaction(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure): Promise<DriveTransaction>;
+export declare function isTransactionTimedOut(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure): Promise<{
+    timeLeft: number;
+    transactionAge: number;
+    expired: boolean;
+    etag: any;
+}>;
+export declare function commitTransaction(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, transactionInput: DriveTransaction | typeof TRANSACTION_BLOCKED_FLAG): Promise<void>;
+export declare function runInTransaction<T>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, primaryPath: string, fn: () => Promise<T>, runAfter?: () => any): Promise<T>;

package/dist/types/plugins/replication-google-drive/upstream.d.ts

@@ -0,0 +1,24 @@
+import { RxReplicationWriteToMasterRow, WithDeletedAndAttachments } from '../../index.ts';
+import type { GoogleDriveOptionsWithDefaults } from './google-drive-types';
+import { DriveStructure } from './init.ts';
+export declare const WAL_FILE_NAME = "rxdb-wal.json";
+export declare function fetchConflicts<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, primaryPath: keyof WithDeletedAndAttachments<RxDocType>, writeRows: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<{
+    conflicts: WithDeletedAndAttachments<RxDocType>[];
+    nonConflicts: RxReplicationWriteToMasterRow<RxDocType>[];
+}>;
+export declare function writeToWal<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, writeRows?: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<void>;
+export declare function readWalContent<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure): Promise<{
+    etag: string;
+    rows: RxReplicationWriteToMasterRow<RxDocType>[] | undefined;
+}>;
+/**
+ * Here we read the WAL file content
+ * and sort the content into the actual
+ * document files.
+ * Notice that when the JavaScript process
+ * exists at any point here, we need to have
+ * a recoverable state on the next run. So this
+ * must be idempotent.
+ */
+export declare function processWalFile<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, primaryPath: keyof RxDocType): Promise<void>;
+export declare function handleUpstreamBatch<RxDocType>(googleDriveOptions: GoogleDriveOptionsWithDefaults, init: DriveStructure, primaryPath: keyof WithDeletedAndAttachments<RxDocType>, writeRows: RxReplicationWriteToMasterRow<RxDocType>[]): Promise<WithDeletedAndAttachments<RxDocType>[]>;

package/dist/types/plugins/replication-graphql/graphql-schema-from-rx-schema.d.ts

@@ -0,0 +1,51 @@
+import type { RxJsonSchema } from '../../types/index.d.ts';
+export type Prefixes = {
+    push?: string;
+    pushRow?: string;
+    checkpoint?: string;
+    pull?: string;
+    pullBulk?: string;
+    stream?: string;
+    headers?: string;
+};
+/**
+ * just type some common types
+ * to have better IDE autocomplete,
+ * all strings are allowed
+ */
+export type GraphQLParamType = 'ID' | 'ID!' | 'String' | 'String!' | 'Int' | 'Int!' | 'Float' | 'Float!' | string;
+export type GraphQLSchemaFromRxSchemaInputSingleCollection = {
+    schema: RxJsonSchema<any>;
+    /**
+     * These fields of the document data
+     * will be used for the checkpoint.
+     */
+    checkpointFields: string[];
+    ignoreInputKeys?: string[];
+    ignoreOutputKeys?: string[];
+    withRevisions?: boolean;
+    prefixes?: Prefixes;
+    headerFields?: string[];
+    /**
+     * Name of the boolean field that marks deleted documents.
+     * [default='_deleted']
+     */
+    deletedField?: string;
+};
+export type GraphQLSchemaFromRxSchemaInput = {
+    [collectionName: string]: GraphQLSchemaFromRxSchemaInputSingleCollection;
+};
+export type GraphQLSchemaFromRxSchemaOutput = {
+    asString: string;
+    queries: string[];
+    mutations: string[];
+    subscriptions: string[];
+    inputs: string[];
+    types: string[];
+};
+export declare const SPACING = "  ";
+/**
+ * Create a GraphQL schema from a given RxJsonSchema
+ */
+export declare function graphQLSchemaFromRxSchema(input: GraphQLSchemaFromRxSchemaInput): GraphQLSchemaFromRxSchemaOutput;
+export declare function fillUpOptionals(input: GraphQLSchemaFromRxSchemaInputSingleCollection): GraphQLSchemaFromRxSchemaInputSingleCollection;

package/dist/types/plugins/replication-graphql/graphql-websocket.d.ts

@@ -0,0 +1,12 @@
+import { Client } from 'graphql-ws';
+import { RxGraphQLPullWSOptions } from '../../types';
+export type WebsocketWithRefCount = {
+    url: string;
+    socket: Client;
+    refCount: number;
+};
+export declare const GRAPHQL_WEBSOCKET_BY_URL: Map<string, WebsocketWithRefCount>;
+export declare function getGraphQLWebSocket(url: string, headers?: {
+    [k: string]: string;
+}, options?: RxGraphQLPullWSOptions): Client;
+export declare function removeGraphQLWebSocketRef(url: string): void;

package/dist/types/plugins/replication-graphql/helper.d.ts

@@ -0,0 +1,15 @@
+import type { RxGraphQLReplicationClientState, RxGraphQLReplicationQueryBuilderResponseObject } from '../../types/index.d.ts';
+export declare const GRAPHQL_REPLICATION_PLUGIN_IDENTITY_PREFIX = "graphql";
+export interface GraphQLError {
+    message: string;
+    locations: Array<{
+        line: number;
+        column: number;
+    }>;
+    path: string[];
+}
+export type GraphQLErrors = Array<GraphQLError>;
+export declare function graphQLRequest(fetchRequest: WindowOrWorkerGlobalScope['fetch'], httpUrl: string, clientState: RxGraphQLReplicationClientState, queryParams: RxGraphQLReplicationQueryBuilderResponseObject): Promise<any>;
+export declare function getDataFromResult(result: {
+    data: object;
+}, userDefinedDataPath: string | string[] | undefined): any;

package/dist/types/plugins/replication-graphql/index.d.ts

@@ -0,0 +1,26 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions, GraphQLServerUrl, RxGraphQLReplicationQueryBuilderResponseObject, RxGraphQLReplicationClientState, ById } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import { SyncOptionsGraphQL } from '../../index.ts';
+export declare class RxGraphQLReplicationState<RxDocType, CheckpointType> extends RxReplicationState<RxDocType, CheckpointType> {
+    readonly url: GraphQLServerUrl;
+    readonly clientState: RxGraphQLReplicationClientState;
+    readonly replicationIdentifier: string;
+    readonly collection: RxCollection<RxDocType, any, any, any>;
+    readonly deletedField: string;
+    readonly pull?: ReplicationPullOptions<RxDocType, CheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly live?: boolean | undefined;
+    retryTime?: number | undefined;
+    autoStart?: boolean | undefined;
+    readonly customFetch?: WindowOrWorkerGlobalScope["fetch"] | undefined;
+    constructor(url: GraphQLServerUrl, clientState: RxGraphQLReplicationClientState, replicationIdentifier: string, collection: RxCollection<RxDocType, any, any, any>, deletedField: string, pull?: ReplicationPullOptions<RxDocType, CheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, live?: boolean | undefined, retryTime?: number | undefined, autoStart?: boolean | undefined, customFetch?: WindowOrWorkerGlobalScope["fetch"] | undefined);
+    setHeaders(headers: ById<string>): void;
+    setCredentials(credentials: RequestCredentials | undefined): void;
+    graphQLRequest(queryParams: RxGraphQLReplicationQueryBuilderResponseObject): Promise<any>;
+}
+export declare function replicateGraphQL<RxDocType, CheckpointType>({ collection, url, headers, credentials, deletedField, waitForLeadership, pull, push, live, fetch: customFetch, retryTime, // in ms
+autoStart, replicationIdentifier }: SyncOptionsGraphQL<RxDocType, CheckpointType>): RxGraphQLReplicationState<RxDocType, CheckpointType>;
+export * from './helper.ts';
+export * from './graphql-schema-from-rx-schema.ts';
+export * from './query-builder-from-rx-schema.ts';
+export * from './graphql-websocket.ts';

package/dist/types/plugins/replication-graphql/query-builder-from-rx-schema.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLSchemaFromRxSchemaInputSingleCollection } from './graphql-schema-from-rx-schema.ts';
+import type { RxGraphQLReplicationPullQueryBuilder, RxGraphQLReplicationPullStreamQueryBuilder, RxGraphQLReplicationPushQueryBuilder } from '../../types/index.d.ts';
+export declare function pullQueryBuilderFromRxSchema(collectionName: string, input: GraphQLSchemaFromRxSchemaInputSingleCollection): RxGraphQLReplicationPullQueryBuilder<any>;
+export declare function pullStreamBuilderFromRxSchema(collectionName: string, input: GraphQLSchemaFromRxSchemaInputSingleCollection): RxGraphQLReplicationPullStreamQueryBuilder;
+export declare function pushQueryBuilderFromRxSchema(collectionName: string, input: GraphQLSchemaFromRxSchemaInputSingleCollection): RxGraphQLReplicationPushQueryBuilder;

package/dist/types/plugins/replication-microsoft-onedrive/document-handling.d.ts

@@ -0,0 +1,14 @@
+import { ById } from '../../types/util';
+import type { OneDriveState, OneDriveItem } from './microsoft-onedrive-types.ts';
+import { DriveStructure } from './init.ts';
+export declare function getDocumentFiles(oneDriveState: OneDriveState, init: DriveStructure, docIds: string[]): Promise<{
+    files: OneDriveItem[];
+}>;
+export declare function insertDocumentFiles<RxDocType>(oneDriveState: OneDriveState, init: DriveStructure, primaryPath: keyof RxDocType, docs: RxDocType[]): Promise<void>;
+export declare function updateDocumentFiles<DocType>(oneDriveState: OneDriveState, primaryPath: keyof DocType, docs: DocType[], fileIdByDocId: Record<string, string>, concurrency?: number): Promise<Record<string, {
+    id: string;
+}>>;
+export declare function fetchDocumentContents<DocType>(oneDriveState: OneDriveState, fileIds: string[], concurrency?: number): Promise<{
+    byId: ById<DocType>;
+    ordered: (DocType)[];
+}>;

package/dist/types/plugins/replication-microsoft-onedrive/downstream.d.ts

@@ -0,0 +1,10 @@
+import type { OneDriveItem, OneDriveCheckpointType, OneDriveState } from './microsoft-onedrive-types.ts';
+import { DriveStructure } from './init.ts';
+export declare function fetchChanges<DocType>(oneDriveState: OneDriveState, init: DriveStructure, checkpoint?: OneDriveCheckpointType, batchSize?: number): Promise<{
+    checkpoint: OneDriveCheckpointType | undefined;
+    documents: DocType[];
+}>;
+export declare function fetchChangesFiles(oneDriveState: OneDriveState, init: DriveStructure, checkpoint?: OneDriveCheckpointType, batchSize?: number): Promise<{
+    checkpoint?: OneDriveCheckpointType;
+    files: OneDriveItem[];
+}>;

package/dist/types/plugins/replication-microsoft-onedrive/index.d.ts

@@ -0,0 +1,38 @@
+import type { RxCollection, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { RxReplicationState } from '../replication/index.ts';
+import type { OneDriveCheckpointType, OneDriveState, SyncOptionsOneDrive } from './microsoft-onedrive-types.ts';
+import { DriveStructure } from './init.ts';
+import { SignalingOptions, SignalingState } from './signaling.ts';
+export * from './microsoft-onedrive-types.ts';
+export * from './microsoft-onedrive-helper.ts';
+export * from './transaction.ts';
+export * from './init.ts';
+export * from './document-handling.ts';
+export * from './downstream.ts';
+export * from './upstream.ts';
+export * from './signaling.ts';
+export declare const DEFAULT_TRANSACTION_TIMEOUT: number;
+export declare class RxOneDriveReplicationState<RxDocType> extends RxReplicationState<RxDocType, OneDriveCheckpointType> {
+    readonly oneDrive: OneDriveState;
+    readonly driveStructure: DriveStructure;
+    readonly replicationIdentifierHash: string;
+    readonly collection: RxCollection<RxDocType, any>;
+    readonly pull?: ReplicationPullOptions<RxDocType, OneDriveCheckpointType> | undefined;
+    readonly push?: ReplicationPushOptions<RxDocType> | undefined;
+    readonly signalingOptions?: SignalingOptions | undefined;
+    readonly live: boolean;
+    retryTime: number;
+    autoStart: boolean;
+    /**
+     * Only exists on live replication
+     */
+    signalingState?: SignalingState;
+    constructor(oneDrive: OneDriveState, driveStructure: DriveStructure, replicationIdentifierHash: string, collection: RxCollection<RxDocType, any>, pull?: ReplicationPullOptions<RxDocType, OneDriveCheckpointType> | undefined, push?: ReplicationPushOptions<RxDocType> | undefined, signalingOptions?: SignalingOptions | undefined, live?: boolean, retryTime?: number, autoStart?: boolean);
+    /**
+     * Notify other peers that something
+     * has or might have changed so that
+     * they can pull from their checkpoints.
+     */
+    notifyPeers(): Promise<void>;
+}
+export declare function replicateMicrosoftOneDrive<RxDocType>(options: SyncOptionsOneDrive<RxDocType>): Promise<RxOneDriveReplicationState<RxDocType>>;

package/dist/types/plugins/replication-microsoft-onedrive/init.d.ts

@@ -0,0 +1,29 @@
+import type { OneDriveState } from './microsoft-onedrive-types.ts';
+export declare function initDriveStructure(oneDriveState: OneDriveState): Promise<{
+    rootFolderId: string;
+    docsFolderId: string;
+    signalingFolderId: string;
+    replicationIdentifier: string;
+    rxdbJson: {
+        status: number;
+        etag: string;
+        createdTime: string;
+        fileId: string;
+        size: number;
+    };
+    transactionFile: {
+        status: number;
+        etag: string;
+        createdTime: string;
+        fileId: string;
+        size: number;
+    };
+    walFile: {
+        status: number;
+        etag: string;
+        createdTime: string;
+        fileId: string;
+        size: number;
+    };
+}>;
+export type DriveStructure = Awaited<ReturnType<typeof initDriveStructure>>;

package/dist/types/plugins/replication-microsoft-onedrive/microsoft-onedrive-helper.d.ts

@@ -0,0 +1,30 @@
+import type { OneDriveState, OneDriveItem } from './microsoft-onedrive-types.ts';
+/**
+ * Returns the base URL for Graph API calls up to the drive root.
+ * Examples:
+ *   - "https://graph.microsoft.com/v1.0/me/drive" (personal / default)
+ *   - "https://graph.microsoft.com/v1.0/drives/12345"
+ */
+export declare function getDriveBaseUrl(oneDriveState: OneDriveState): string;
+export declare function createFolder(oneDriveState: OneDriveState, parentId: string | undefined, folderName: string): Promise<string>;
+export declare function findFolder(oneDriveState: OneDriveState, parentId: string | undefined, folderName: string): Promise<string | undefined>;
+export declare function ensureFolderExists(oneDriveState: OneDriveState, folderPath: string): Promise<string>;
+export declare function createEmptyFile(oneDriveState: OneDriveState, parentId: string, fileName: string): Promise<{
+    status: number;
+    etag: string;
+    createdTime: string;
+    fileId: string;
+    size: number;
+}>;
+export declare function fillFileIfEtagMatches<T = any>(oneDriveState: OneDriveState, fileId: string, etag: string, jsonContent?: any): Promise<{
+    status: number;
+    etag: string;
+    content: T | undefined;
+}>;
+export declare function deleteIfEtagMatches(oneDriveState: OneDriveState, fileId: string, etag: string): Promise<void>;
+export declare function deleteFile(oneDriveState: OneDriveState, fileId: string): Promise<void>;
+export declare function readJsonFileContent<T>(oneDriveState: OneDriveState, fileId: string): Promise<{
+    etag: string;
+    content: T | undefined;
+}>;
+export declare function listFilesInFolder(oneDriveState: OneDriveState, folderId: string): Promise<OneDriveItem[]>;

package/dist/types/plugins/replication-microsoft-onedrive/microsoft-onedrive-types.d.ts

@@ -0,0 +1,71 @@
+import type { ReplicationOptions, ReplicationPullOptions, ReplicationPushOptions } from '../../types/index.d.ts';
+import { SignalingOptions } from './signaling.ts';
+/**
+ * Represents a Microsoft Graph DriveItem.
+ * https://learn.microsoft.com/en-us/graph/api/resources/driveitem?view=graph-rest-1.0
+ */
+export interface OneDriveItem {
+    id: string;
+    name: string;
+    eTag: string;
+    cTag: string;
+    createdDateTime?: string;
+    lastModifiedDateTime: string;
+    folder?: {
+        childCount: number;
+    };
+    file?: {
+        mimeType: string;
+    };
+    '@microsoft.graph.downloadUrl'?: string;
+    size?: number;
+    parentReference?: {
+        driveId: string;
+        id: string;
+    };
+}
+export interface OneDriveState {
+    oauthClientId?: string;
+    authToken: string;
+    /**
+     * Microsoft Graph API Endpoint.
+     * Default: `https://graph.microsoft.com/v1.0`
+     */
+    apiEndpoint?: string;
+    /**
+     * ID of the personal OneDrive root or SharePoint Document Library root.
+     * 'me/drive' is common for personal.
+     */
+    driveId?: string;
+    /**
+     * Provide a folderPath to the app root in the cloud.
+     * Must not be the root folder.
+     */
+    folderPath: string;
+    /**
+     * In ms.
+     * Default: 10000
+     */
+    transactionTimeout?: number;
+}
+export type OneDriveSyncPullOptions<RxDocType> = Omit<ReplicationPullOptions<RxDocType, OneDriveCheckpointType>, 'handler' | 'stream$'>;
+export type OneDriveSyncPushOptions<RxDocType> = Omit<ReplicationPushOptions<RxDocType>, 'handler'>;
+export type SyncOptionsOneDrive<RxDocType> = Omit<ReplicationOptions<RxDocType, any>, 'pull' | 'push'> & {
+    oneDrive: OneDriveState;
+    signalingOptions?: SignalingOptions;
+    pull?: OneDriveSyncPullOptions<RxDocType>;
+    push?: OneDriveSyncPushOptions<RxDocType>;
+};
+export type OneDriveCheckpointType = {
+    /**
+     * The last 'lastModifiedDateTime' of a document.
+     */
+    lastModifiedDateTime: string;
+};
+export type OneDriveTransaction = {
+    retry: true;
+} | OneDriveItem;
+export type OneDriveResponse<T> = {
+    value: T;
+    '@odata.nextLink'?: string;
+};

package/dist/types/plugins/replication-microsoft-onedrive/signaling.d.ts

@@ -0,0 +1,41 @@
+import type { Instance as SimplePeerInstance } from 'simple-peer';
+import { SimplePeerConfig, SimplePeerWrtc } from '../replication-webrtc/connection-handler-simple-peer';
+import { DriveStructure } from './init.ts';
+import type { OneDriveState } from './microsoft-onedrive-types.ts';
+export type SignalingOptions = {
+    wrtc?: SimplePeerWrtc;
+    config?: SimplePeerConfig;
+};
+export type SIGNAL = 'RESYNC' | 'NEW_PEER';
+export declare class SignalingState {
+    private oneDriveState;
+    private init;
+    private signalingOptions;
+    readonly sessionId: string;
+    readonly processedMessageIds: Set<string>;
+    /**
+     * Emits whenever a new connection
+     * is there or some connection
+     * told us to RESYNC
+     */
+    private _resync$;
+    resync$: import("rxjs").Observable<void>;
+    peerBySenderId: Map<string, SimplePeerInstance>;
+    private processQueue;
+    private backoffStepId;
+    private skipBackoffTime?;
+    closed: boolean;
+    resetReaderFn: () => void;
+    constructor(oneDriveState: OneDriveState, init: DriveStructure, signalingOptions: SignalingOptions);
+    sendMessage(data: any): Promise<void>;
+    pingPeers(message: SIGNAL): Promise<void>;
+    resetReadLoop(): Promise<void>;
+    processNewMessages(): Promise<any>;
+    _processNewMessages(): Promise<void>;
+    close(): void;
+}
+export declare function readMessages(oneDriveState: OneDriveState, init: DriveStructure, processedMessageIds: Set<string>): Promise<{
+    senderId: string;
+    data: any;
+}[]>;
+export declare function cleanupOldSignalingMessages(oneDriveState: OneDriveState, signalingFolderId: string, maxAgeMs?: number): Promise<number>;