local-lite 0.0.11 → 0.0.14

package/dist/auth/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./google.js"), exports);
+__exportStar(require("./microsoft.js"), exports);
+__exportStar(require("./github.js"), exports);
+__exportStar(require("./apple.js"), exports);

package/dist/auth/microsoft.d.ts

@@ -0,0 +1,76 @@
+export declare const MICROSOFT_GRAPH_ENDPOINT = "https://graph.microsoft.com/v1.0";
+export declare const DEFAULT_MICROSOFT_AUTH_SCOPES: string[];
+export interface MicrosoftUser {
+    id: string;
+    email: string;
+    name: string;
+    givenName?: string;
+    familyName?: string;
+    picture?: string;
+    userPrincipalName?: string;
+}
+export type OneDriveUser = MicrosoftUser;
+export interface MicrosoftAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresAt: number;
+    tokenType?: string;
+    scope?: string;
+}
+export interface MicrosoftAuthTokenStore {
+    getTokens(): Promise<MicrosoftAuthTokens | null>;
+    setTokens(tokens: MicrosoftAuthTokens): Promise<void>;
+    removeTokens(): Promise<void>;
+    getUser(): Promise<MicrosoftUser | null>;
+    setUser(user: MicrosoftUser | null): Promise<void>;
+}
+export interface MicrosoftAuthKeyValueStorage {
+    getItem(key: string): Promise<unknown>;
+    setItem(key: string, value: unknown): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export interface MicrosoftAuthorizationRequest {
+    authorizationUrl: string;
+    redirectUri: string;
+    state: string;
+}
+export interface MicrosoftAuthorizationResponse {
+    code: string;
+    state: string;
+}
+export interface MicrosoftAuthClientOptions {
+    clientId: string;
+    redirectUri: string;
+    tenantId?: 'common' | 'consumers' | 'organizations' | string;
+    scopes?: string[];
+    authorize: (request: MicrosoftAuthorizationRequest) => Promise<MicrosoftAuthorizationResponse | null>;
+    tokenStore?: MicrosoftAuthTokenStore;
+    storage?: MicrosoftAuthKeyValueStorage;
+    randomBytes?: (length: number) => Uint8Array;
+    fetch?: typeof fetch;
+    prompt?: 'select_account' | 'consent' | 'login' | 'none';
+}
+export declare function createInMemoryMicrosoftTokenStore(): MicrosoftAuthTokenStore;
+export declare function createMicrosoftAuthTokenStore(storage: MicrosoftAuthKeyValueStorage, prefix?: string): MicrosoftAuthTokenStore;
+export declare const createOneDriveAuthTokenStore: typeof createMicrosoftAuthTokenStore;
+export declare class MicrosoftAuthClient {
+    private readonly options;
+    private readonly tokenStore;
+    private readonly fetcher;
+    private readonly listeners;
+    private readonly tenant;
+    private currentUser;
+    constructor(options: MicrosoftAuthClientOptions);
+    get authorizationEndpoint(): string;
+    get tokenEndpoint(): string;
+    onAuthStateChange(listener: (user: MicrosoftUser | null) => void): () => void;
+    private notify;
+    signIn(): Promise<MicrosoftUser | null>;
+    signOut(): Promise<void>;
+    isSignedIn(): Promise<boolean>;
+    getUser(): Promise<MicrosoftUser | null>;
+    getValidAccessToken(): Promise<string>;
+    private fetchUserProfile;
+}
+export declare const OneDriveAuthClient: typeof MicrosoftAuthClient;

package/dist/auth/microsoft.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneDriveAuthClient = exports.MicrosoftAuthClient = exports.createOneDriveAuthTokenStore = exports.DEFAULT_MICROSOFT_AUTH_SCOPES = exports.MICROSOFT_GRAPH_ENDPOINT = void 0;
+exports.createInMemoryMicrosoftTokenStore = createInMemoryMicrosoftTokenStore;
+exports.createMicrosoftAuthTokenStore = createMicrosoftAuthTokenStore;
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/hashes/utils.js");
+exports.MICROSOFT_GRAPH_ENDPOINT = 'https://graph.microsoft.com/v1.0';
+exports.DEFAULT_MICROSOFT_AUTH_SCOPES = ['openid', 'profile', 'email', 'User.Read'];
+function secureRandomBytes(length) {
+    const crypto = globalThis.crypto;
+    if (!crypto?.getRandomValues) {
+        throw new Error('Secure random number generation is unavailable.');
+    }
+    return crypto.getRandomValues(new Uint8Array(length));
+}
+function base64UrlEncode(bytes) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+    let result = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index];
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        result += alphabet[first >> 2];
+        result += alphabet[((first & 3) << 4) | (second === undefined ? 0 : second >> 4)];
+        if (second !== undefined) {
+            result += alphabet[((second & 15) << 2) | (third === undefined ? 0 : third >> 6)];
+        }
+        if (third !== undefined)
+            result += alphabet[third & 63];
+    }
+    return result;
+}
+function validateTokens(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const tokens = value;
+    return (typeof tokens.accessToken === 'string' &&
+        typeof tokens.expiresAt === 'number' &&
+        (tokens.refreshToken === undefined || typeof tokens.refreshToken === 'string') &&
+        (tokens.idToken === undefined || typeof tokens.idToken === 'string'));
+}
+function validateUser(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const user = value;
+    return (typeof user.id === 'string' &&
+        typeof user.email === 'string' &&
+        typeof user.name === 'string');
+}
+function createInMemoryMicrosoftTokenStore() {
+    let storedTokens = null;
+    let storedUser = null;
+    return {
+        getTokens: async () => storedTokens,
+        setTokens: async (tokens) => {
+            storedTokens = tokens;
+        },
+        removeTokens: async () => {
+            storedTokens = null;
+        },
+        getUser: async () => storedUser,
+        setUser: async (user) => {
+            storedUser = user;
+        },
+    };
+}
+function createMicrosoftAuthTokenStore(storage, prefix = 'local-lite-microsoft-auth') {
+    const tokensKey = `${prefix}-tokens`;
+    const userKey = `${prefix}-user`;
+    return {
+        getTokens: async () => {
+            const raw = await storage.getItem(tokensKey);
+            return validateTokens(raw) ? raw : null;
+        },
+        setTokens: tokens => storage.setItem(tokensKey, tokens),
+        removeTokens: () => storage.removeItem(tokensKey),
+        getUser: async () => {
+            const raw = await storage.getItem(userKey);
+            return validateUser(raw) ? raw : null;
+        },
+        setUser: async (user) => {
+            if (user) {
+                await storage.setItem(userKey, user);
+            }
+            else {
+                await storage.removeItem(userKey);
+            }
+        },
+    };
+}
+exports.createOneDriveAuthTokenStore = createMicrosoftAuthTokenStore;
+class MicrosoftAuthClient {
+    options;
+    tokenStore;
+    fetcher;
+    listeners = new Set();
+    tenant;
+    currentUser = null;
+    constructor(options) {
+        this.options = options;
+        if (!options.clientId?.trim()) {
+            throw new Error('Microsoft OAuth client ID is required.');
+        }
+        if (!options.redirectUri?.trim()) {
+            throw new Error('Microsoft OAuth redirect URI is required.');
+        }
+        this.tenant = options.tenantId?.trim() || 'common';
+        this.fetcher = options.fetch ?? fetch;
+        if (options.tokenStore) {
+            this.tokenStore = options.tokenStore;
+        }
+        else if (options.storage) {
+            this.tokenStore = createMicrosoftAuthTokenStore(options.storage);
+        }
+        else {
+            this.tokenStore = createInMemoryMicrosoftTokenStore();
+        }
+    }
+    get authorizationEndpoint() {
+        return `https://login.microsoftonline.com/${this.tenant}/oauth2/v2.0/authorize`;
+    }
+    get tokenEndpoint() {
+        return `https://login.microsoftonline.com/${this.tenant}/oauth2/v2.0/token`;
+    }
+    onAuthStateChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify(user) {
+        this.currentUser = user;
+        for (const listener of this.listeners) {
+            try {
+                listener(user);
+            }
+            catch (err) {
+                console.error('Error in MicrosoftAuthClient listener:', err);
+            }
+        }
+    }
+    async signIn() {
+        const randomBytes = this.options.randomBytes ?? secureRandomBytes;
+        const verifierBytes = randomBytes(32);
+        const stateBytes = randomBytes(32);
+        if (verifierBytes.length !== 32 || stateBytes.length !== 32) {
+            throw new Error('The randomBytes provider returned an invalid number of bytes.');
+        }
+        const codeVerifier = base64UrlEncode(verifierBytes);
+        const codeChallenge = base64UrlEncode((0, sha2_js_1.sha256)((0, utils_js_1.utf8ToBytes)(codeVerifier)));
+        const state = base64UrlEncode(stateBytes);
+        const scopes = this.options.scopes && this.options.scopes.length > 0
+            ? this.options.scopes
+            : exports.DEFAULT_MICROSOFT_AUTH_SCOPES;
+        const authorizationParams = new URLSearchParams({
+            client_id: this.options.clientId,
+            response_type: 'code',
+            redirect_uri: this.options.redirectUri,
+            response_mode: 'query',
+            scope: scopes.join(' '),
+            prompt: this.options.prompt ?? 'select_account',
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+            state,
+        });
+        const authorization = await this.options.authorize({
+            authorizationUrl: `${this.authorizationEndpoint}?${authorizationParams.toString()}`,
+            redirectUri: this.options.redirectUri,
+            state,
+        });
+        if (!authorization) {
+            return null;
+        }
+        if (authorization.state !== state) {
+            throw new Error('Microsoft OAuth state validation failed. Please try connecting again.');
+        }
+        if (!authorization.code) {
+            throw new Error('Microsoft OAuth did not return an authorization code.');
+        }
+        const response = await this.fetcher(this.tokenEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                client_id: this.options.clientId,
+                code: authorization.code,
+                code_verifier: codeVerifier,
+                grant_type: 'authorization_code',
+                redirect_uri: this.options.redirectUri,
+                scope: scopes.join(' '),
+            }).toString(),
+        });
+        const payload = (await response.json());
+        if (!response.ok) {
+            throw new Error(payload.error_description || payload.error || `Microsoft OAuth token request failed (${response.status}).`);
+        }
+        if (!payload.access_token) {
+            throw new Error('Microsoft OAuth did not return an access token.');
+        }
+        const priorTokens = await this.tokenStore.getTokens();
+        const storedTokens = {
+            accessToken: payload.access_token,
+            refreshToken: payload.refresh_token ?? priorTokens?.refreshToken,
+            idToken: payload.id_token ?? priorTokens?.idToken,
+            expiresAt: Date.now() + (payload.expires_in ?? 3600) * 1000,
+            tokenType: payload.token_type,
+            scope: payload.scope,
+        };
+        await this.tokenStore.setTokens(storedTokens);
+        const user = await this.fetchUserProfile(storedTokens.accessToken);
+        await this.tokenStore.setUser(user);
+        this.notify(user);
+        return user;
+    }
+    async signOut() {
+        await this.tokenStore.removeTokens();
+        await this.tokenStore.setUser(null);
+        this.notify(null);
+    }
+    async isSignedIn() {
+        const tokens = await this.tokenStore.getTokens();
+        return validateTokens(tokens);
+    }
+    async getUser() {
+        if (this.currentUser) {
+            return this.currentUser;
+        }
+        const cached = await this.tokenStore.getUser();
+        if (cached) {
+            this.currentUser = cached;
+            return cached;
+        }
+        const tokens = await this.tokenStore.getTokens();
+        if (!validateTokens(tokens)) {
+            return null;
+        }
+        try {
+            const accessToken = await this.getValidAccessToken();
+            const user = await this.fetchUserProfile(accessToken);
+            await this.tokenStore.setUser(user);
+            this.currentUser = user;
+            return user;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getValidAccessToken() {
+        const tokens = await this.tokenStore.getTokens();
+        if (!validateTokens(tokens)) {
+            throw new Error('No Microsoft account signed in. Please sign in first.');
+        }
+        if (tokens.expiresAt > Date.now() + 60_000) {
+            return tokens.accessToken;
+        }
+        if (!tokens.refreshToken) {
+            throw new Error('Your Microsoft sign-in session expired. Please sign in again.');
+        }
+        const scopes = this.options.scopes && this.options.scopes.length > 0
+            ? this.options.scopes
+            : exports.DEFAULT_MICROSOFT_AUTH_SCOPES;
+        const response = await this.fetcher(this.tokenEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                client_id: this.options.clientId,
+                grant_type: 'refresh_token',
+                refresh_token: tokens.refreshToken,
+                scope: scopes.join(' '),
+            }).toString(),
+        });
+        const payload = (await response.json());
+        if (!response.ok) {
+            throw new Error(payload.error_description || payload.error || `Microsoft OAuth token refresh failed (${response.status}).`);
+        }
+        if (!payload.access_token) {
+            throw new Error('Microsoft OAuth token refresh did not return an access token.');
+        }
+        const updatedTokens = {
+            accessToken: payload.access_token,
+            refreshToken: payload.refresh_token ?? tokens.refreshToken,
+            idToken: payload.id_token ?? tokens.idToken,
+            expiresAt: Date.now() + (payload.expires_in ?? 3600) * 1000,
+            tokenType: payload.token_type ?? tokens.tokenType,
+            scope: payload.scope ?? tokens.scope,
+        };
+        await this.tokenStore.setTokens(updatedTokens);
+        return updatedTokens.accessToken;
+    }
+    async fetchUserProfile(accessToken) {
+        const res = await this.fetcher(`${exports.MICROSOFT_GRAPH_ENDPOINT}/me`, {
+            headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to fetch Microsoft user profile (${res.status}).`);
+        }
+        const raw = (await res.json());
+        const email = raw.mail || raw.userPrincipalName || `${raw.id}@microsoft.account`;
+        return {
+            id: raw.id,
+            email,
+            name: raw.displayName || raw.givenName || email,
+            givenName: raw.givenName,
+            familyName: raw.surname,
+            userPrincipalName: raw.userPrincipalName,
+        };
+    }
+}
+exports.MicrosoftAuthClient = MicrosoftAuthClient;
+exports.OneDriveAuthClient = MicrosoftAuthClient;

package/dist/backups/encryption.d.ts

@@ -0,0 +1,18 @@
+import type { BackupDatabase, BackupStorage } from './index.js';
+export interface EncryptedBackupOptions {
+    passphrase: string;
+    fileName?: string;
+    iterations?: number;
+}
+export interface RestoreEncryptedBackupOptions {
+    passphrase: string;
+}
+export declare function isEncryptedBackup(data: Uint8Array): boolean;
+export declare function encryptBackupData(plainData: Uint8Array, passphrase: string, options?: {
+    iterations?: number;
+}): Promise<Uint8Array>;
+export declare function decryptBackupData(encryptedData: Uint8Array, passphrase: string, options?: {
+    iterations?: number;
+}): Promise<Uint8Array>;
+export declare function createEncryptedDatabaseBackup(database: BackupDatabase, storage: BackupStorage, options: EncryptedBackupOptions): Promise<string>;
+export declare function restoreEncryptedDatabaseBackup(database: BackupDatabase, storage: BackupStorage, fileName: string, options: RestoreEncryptedBackupOptions): Promise<void>;

package/dist/backups/encryption.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEncryptedBackup = isEncryptedBackup;
+exports.encryptBackupData = encryptBackupData;
+exports.decryptBackupData = decryptBackupData;
+exports.createEncryptedDatabaseBackup = createEncryptedDatabaseBackup;
+exports.restoreEncryptedDatabaseBackup = restoreEncryptedDatabaseBackup;
+const pbkdf2_js_1 = require("@noble/hashes/pbkdf2.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/hashes/utils.js");
+const MAGIC_HEADER = new Uint8Array([0x4c, 0x4c, 0x45, 0x4e, 0x43, 0x31]); // "LLENC1"
+const SALT_LENGTH = 16;
+const IV_LENGTH = 12;
+const DEFAULT_ITERATIONS = 50000;
+function getRandomBytes(length) {
+    const crypto = globalThis.crypto;
+    if (!crypto?.getRandomValues) {
+        throw new Error('Secure random generation is unavailable for backup encryption.');
+    }
+    return crypto.getRandomValues(new Uint8Array(length));
+}
+const ITERATIONS_LENGTH = 4;
+function isEncryptedBackup(data) {
+    if (data.length < MAGIC_HEADER.length + ITERATIONS_LENGTH + SALT_LENGTH + IV_LENGTH + 16) {
+        return false;
+    }
+    for (let i = 0; i < MAGIC_HEADER.length; i++) {
+        if (data[i] !== MAGIC_HEADER[i])
+            return false;
+    }
+    return true;
+}
+async function encryptBackupData(plainData, passphrase, options = {}) {
+    if (!passphrase || !passphrase.trim()) {
+        throw new Error('A non-empty passphrase is required for backup encryption.');
+    }
+    const iterations = options.iterations ?? DEFAULT_ITERATIONS;
+    const salt = getRandomBytes(SALT_LENGTH);
+    const iv = getRandomBytes(IV_LENGTH);
+    // Derive 256-bit AES key using PBKDF2 with SHA-256
+    const keyBytes = (0, pbkdf2_js_1.pbkdf2)(sha2_js_1.sha256, (0, utils_js_1.utf8ToBytes)(passphrase), salt, {
+        c: iterations,
+        dkLen: 32,
+    });
+    const crypto = globalThis.crypto;
+    if (!crypto?.subtle) {
+        throw new Error('WebCrypto subtle is unavailable for AES-GCM encryption.');
+    }
+    const cryptoKey = await crypto.subtle.importKey('raw', keyBytes, 'AES-GCM', false, ['encrypt']);
+    const encryptedBuffer = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv }, cryptoKey, plainData);
+    const ciphertext = new Uint8Array(encryptedBuffer);
+    // Payload format: [MAGIC(6)][ITERATIONS(4)][SALT(16)][IV(12)][CIPHERTEXT+TAG]
+    const headerSize = MAGIC_HEADER.length + ITERATIONS_LENGTH + SALT_LENGTH + IV_LENGTH;
+    const result = new Uint8Array(headerSize + ciphertext.length);
+    result.set(MAGIC_HEADER, 0);
+    const view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+    view.setUint32(MAGIC_HEADER.length, iterations, false); // big-endian
+    result.set(salt, MAGIC_HEADER.length + ITERATIONS_LENGTH);
+    result.set(iv, MAGIC_HEADER.length + ITERATIONS_LENGTH + SALT_LENGTH);
+    result.set(ciphertext, headerSize);
+    return result;
+}
+async function decryptBackupData(encryptedData, passphrase, options = {}) {
+    if (!passphrase || !passphrase.trim()) {
+        throw new Error('A non-empty passphrase is required for backup decryption.');
+    }
+    if (!isEncryptedBackup(encryptedData)) {
+        throw new Error('Invalid backup file format: missing LLENC1 encryption header.');
+    }
+    const view = new DataView(encryptedData.buffer, encryptedData.byteOffset, encryptedData.byteLength);
+    const storedIterations = view.getUint32(MAGIC_HEADER.length, false);
+    const iterations = options.iterations ?? (storedIterations > 0 ? storedIterations : DEFAULT_ITERATIONS);
+    const saltOffset = MAGIC_HEADER.length + ITERATIONS_LENGTH;
+    const ivOffset = saltOffset + SALT_LENGTH;
+    const ciphertextOffset = ivOffset + IV_LENGTH;
+    const salt = encryptedData.slice(saltOffset, ivOffset);
+    const iv = encryptedData.slice(ivOffset, ciphertextOffset);
+    const ciphertext = encryptedData.slice(ciphertextOffset);
+    const keyBytes = (0, pbkdf2_js_1.pbkdf2)(sha2_js_1.sha256, (0, utils_js_1.utf8ToBytes)(passphrase), salt, {
+        c: iterations,
+        dkLen: 32,
+    });
+    const crypto = globalThis.crypto;
+    if (!crypto?.subtle) {
+        throw new Error('WebCrypto subtle is unavailable for AES-GCM decryption.');
+    }
+    const cryptoKey = await crypto.subtle.importKey('raw', keyBytes, 'AES-GCM', false, ['decrypt']);
+    try {
+        const decryptedBuffer = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv }, cryptoKey, ciphertext);
+        return new Uint8Array(decryptedBuffer);
+    }
+    catch {
+        throw new Error('Backup decryption failed: Incorrect passphrase or corrupted database backup.');
+    }
+}
+async function createEncryptedDatabaseBackup(database, storage, options) {
+    const fileName = options.fileName ??
+        `local-lite-enc-${new Date().toISOString().replace(/[:.]/g, '-')}.enc.db`;
+    if (!fileName || /[\\/]/.test(fileName)) {
+        throw new Error('Backup file name must be a single file name.');
+    }
+    const plainBytes = await database.exportDatabase();
+    if (plainBytes.length === 0) {
+        throw new Error('Cannot create a backup from an empty database.');
+    }
+    const encryptedBytes = await encryptBackupData(plainBytes, options.passphrase, {
+        iterations: options.iterations,
+    });
+    await storage.save(fileName, encryptedBytes);
+    return fileName;
+}
+async function restoreEncryptedDatabaseBackup(database, storage, fileName, options) {
+    if (!fileName || /[\\/]/.test(fileName)) {
+        throw new Error('Backup file name must be a single file name.');
+    }
+    const rawBytes = await storage.read(fileName);
+    if (rawBytes.length === 0) {
+        throw new Error('Cannot restore an empty database backup.');
+    }
+    const decryptedBytes = await decryptBackupData(rawBytes, options.passphrase);
+    await database.importDatabase(decryptedBytes);
+}

package/dist/backups/index.d.ts

@@ -1,4 +1,6 @@
 export { type BackupAccessTokenProvider, type CloudBackupFile, type GoogleDriveAuthorizationRequest, type GoogleDriveAuthorizationResponse, type GoogleDriveBackupClientOptions, type GoogleDriveKeyValueStorage, type GoogleDriveTokenStore, type GoogleDriveTokens, GoogleDriveBackupClient, GoogleDriveBackupStorage, createGoogleDriveTokenStore, } from './cloud-storage.js';
+export { MICROSOFT_GRAPH_DRIVE, OneDriveBackupStorage, OneDriveBackupClient, } from './onedrive.js';
+export { type EncryptedBackupOptions, type RestoreEncryptedBackupOptions, isEncryptedBackup, encryptBackupData, decryptBackupData, createEncryptedDatabaseBackup, restoreEncryptedDatabaseBackup, } from './encryption.js';
 export interface BackupDatabase {
     exportDatabase(): Promise<Uint8Array>;
     importDatabase(data: Uint8Array): Promise<void>;

package/dist/backups/index.js

@@ -1,12 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGoogleDriveTokenStore = exports.GoogleDriveBackupStorage = exports.GoogleDriveBackupClient = void 0;
+exports.restoreEncryptedDatabaseBackup = exports.createEncryptedDatabaseBackup = exports.decryptBackupData = exports.encryptBackupData = exports.isEncryptedBackup = exports.OneDriveBackupClient = exports.OneDriveBackupStorage = exports.MICROSOFT_GRAPH_DRIVE = exports.createGoogleDriveTokenStore = exports.GoogleDriveBackupStorage = exports.GoogleDriveBackupClient = void 0;
 exports.createDatabaseBackup = createDatabaseBackup;
 exports.restoreDatabaseBackup = restoreDatabaseBackup;
 var cloud_storage_js_1 = require("./cloud-storage.js");
 Object.defineProperty(exports, "GoogleDriveBackupClient", { enumerable: true, get: function () { return cloud_storage_js_1.GoogleDriveBackupClient; } });
 Object.defineProperty(exports, "GoogleDriveBackupStorage", { enumerable: true, get: function () { return cloud_storage_js_1.GoogleDriveBackupStorage; } });
 Object.defineProperty(exports, "createGoogleDriveTokenStore", { enumerable: true, get: function () { return cloud_storage_js_1.createGoogleDriveTokenStore; } });
+var onedrive_js_1 = require("./onedrive.js");
+Object.defineProperty(exports, "MICROSOFT_GRAPH_DRIVE", { enumerable: true, get: function () { return onedrive_js_1.MICROSOFT_GRAPH_DRIVE; } });
+Object.defineProperty(exports, "OneDriveBackupStorage", { enumerable: true, get: function () { return onedrive_js_1.OneDriveBackupStorage; } });
+Object.defineProperty(exports, "OneDriveBackupClient", { enumerable: true, get: function () { return onedrive_js_1.OneDriveBackupClient; } });
+var encryption_js_1 = require("./encryption.js");
+Object.defineProperty(exports, "isEncryptedBackup", { enumerable: true, get: function () { return encryption_js_1.isEncryptedBackup; } });
+Object.defineProperty(exports, "encryptBackupData", { enumerable: true, get: function () { return encryption_js_1.encryptBackupData; } });
+Object.defineProperty(exports, "decryptBackupData", { enumerable: true, get: function () { return encryption_js_1.decryptBackupData; } });
+Object.defineProperty(exports, "createEncryptedDatabaseBackup", { enumerable: true, get: function () { return encryption_js_1.createEncryptedDatabaseBackup; } });
+Object.defineProperty(exports, "restoreEncryptedDatabaseBackup", { enumerable: true, get: function () { return encryption_js_1.restoreEncryptedDatabaseBackup; } });
 function validateFileName(fileName) {
     if (!fileName || /[\\/]/.test(fileName)) {
         throw new Error('Backup file name must be a single file name.');

package/dist/backups/onedrive.d.ts

@@ -0,0 +1,22 @@
+import type { BackupAccessTokenProvider, BackupStorage, CloudBackupFile } from './index.js';
+import { type MicrosoftAuthClientOptions } from '../auth/microsoft.js';
+export declare const MICROSOFT_GRAPH_DRIVE = "https://graph.microsoft.com/v1.0/me/drive";
+export declare class OneDriveBackupStorage implements BackupStorage {
+    private readonly getAccessToken;
+    private readonly fetcher;
+    constructor(getAccessToken: BackupAccessTokenProvider, fetcher?: typeof fetch);
+    save(fileName: string, data: Uint8Array): Promise<void>;
+    read(fileIdOrName: string): Promise<Uint8Array>;
+    list(): Promise<CloudBackupFile[]>;
+}
+export declare class OneDriveBackupClient implements BackupStorage {
+    private readonly storage;
+    private readonly authClient;
+    constructor(options: MicrosoftAuthClientOptions);
+    connect(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    isConnected(): Promise<boolean>;
+    save(fileName: string, data: Uint8Array): Promise<void>;
+    read(fileId: string): Promise<Uint8Array>;
+    list(): Promise<CloudBackupFile[]>;
+}