@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/httplib.d.ts

@@ -0,0 +1,75 @@
+import type { CouchDBCredentials, JWTCredentials, JWTHeader, JWTParams, JWTPayload, PreparedJWT, RemoteDBSettings } from "../common/types.js";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
+/**
+ * Generates a credential object based on the provided settings.
+ * @param settings - RemoteDBSettings
+ * @returns {CouchDBCredentials} credentials object
+ */
+export declare function generateCredentialObject(settings: RemoteDBSettings): {
+    jwtAlgorithm: import("../common/models/auth.type.js").JWTAlgorithm;
+    jwtKey: string;
+    jwtKid: string;
+    jwtSub: string;
+    jwtExpDuration: number;
+    type: "jwt";
+    username?: undefined;
+    password?: undefined;
+} | {
+    username: string;
+    password: string;
+    type: "basic";
+    jwtAlgorithm?: undefined;
+    jwtKey?: undefined;
+    jwtKid?: undefined;
+    jwtSub?: undefined;
+    jwtExpDuration?: undefined;
+};
+/**
+ * Generates a basic authentication header for CouchDB credentials using the provided username and password.
+ * And it caches the result for performance if the credentials are not changed.
+ */
+export declare class BasicHeaderGenerator {
+    _header: Computed<[source: CouchDBCredentials], string>;
+    /**
+     * Generates a basic authentication header for CouchDB credentials using the provided username and password.
+     * @param auth - CouchDBCredentials
+     * @returns {Promise<string>} The basic authentication header (without "Basic" prefix).
+     */
+    getBasicHeader(auth: CouchDBCredentials): Promise<string>;
+}
+/**
+ * Generates a JWT token based on the provided credentials and parameters.
+ * And it caches the result for performance if the credentials are not changed.
+ */
+export declare class JWTTokenGenerator {
+    _importKey(auth: JWTCredentials): Promise<CryptoKey>;
+    _currentCryptoKey: Computed<[auth: JWTCredentials], CryptoKey>;
+    _jwt: Computed<[params: JWTParams], {
+        token: string;
+        header: JWTHeader;
+        payload: JWTPayload;
+        credentials: JWTCredentials;
+    }>;
+    _jwtParams: Computed<[source: JWTCredentials], {
+        header: JWTHeader;
+        payload: {
+            exp: number;
+            iat: number;
+            sub: string;
+            "_couchdb.roles": string[];
+        };
+        credentials: JWTCredentials;
+    }>;
+    getJWT(auth: JWTCredentials): Promise<PreparedJWT>;
+    /**
+     * Generates a JWT token based on the provided credentials and parameters.
+     * @param auth - JWTCredentials
+     * @returns {Promise<string>} The JWT token (with "Bearer" prefix).
+     */
+    getBearerToken(auth: JWTCredentials): Promise<string>;
+}
+export declare class AuthorizationHeaderGenerator {
+    _basicHeader: BasicHeaderGenerator;
+    _jwtHeader: JWTTokenGenerator;
+    getAuthorizationHeader(auth: CouchDBCredentials): Promise<string>;
+}

package/dist/replication/httplib.js

@@ -0,0 +1,187 @@
+import { arrayBufferToBase64Single, writeString } from "../string_and_binary/convert.js";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+function generateCredentialObject(settings) {
+  if (settings.useJWT) {
+    return {
+      jwtAlgorithm: settings.jwtAlgorithm,
+      jwtKey: settings.jwtKey,
+      jwtKid: settings.jwtKid,
+      jwtSub: settings.jwtSub,
+      jwtExpDuration: settings.jwtExpDuration,
+      type: "jwt"
+    };
+  } else {
+    return {
+      username: settings.couchDB_USER,
+      password: settings.couchDB_PASSWORD,
+      type: "basic"
+    };
+  }
+  throw new Error("Invalid credentials");
+}
+class BasicHeaderGenerator {
+  _header = new Computed({
+    evaluation: (source) => {
+      if ("username" in source) {
+        const userNameAndPassword = source.username && source.password ? `${source.username}:${source.password}` : "";
+        return `Basic ${btoa(userNameAndPassword)}`;
+      }
+      return "";
+    }
+  });
+  /**
+   * Generates a basic authentication header for CouchDB credentials using the provided username and password.
+   * @param auth - CouchDBCredentials
+   * @returns {Promise<string>} The basic authentication header (without "Basic" prefix).
+   */
+  async getBasicHeader(auth) {
+    return (await this._header.update(auth)).value;
+  }
+}
+class JWTTokenGenerator {
+  _importKey(auth) {
+    if (auth.jwtAlgorithm == "HS256" || auth.jwtAlgorithm == "HS512") {
+      const key = (auth.jwtKey || "").trim();
+      if (key == "") {
+        throw new Error("JWT key is empty");
+      }
+      const binaryDerString = compatGlobal.atob(key);
+      const binaryDer = new Uint8Array(binaryDerString.length);
+      for (let i = 0; i < binaryDerString.length; i++) {
+        binaryDer[i] = binaryDerString.charCodeAt(i);
+      }
+      const hashName = auth.jwtAlgorithm == "HS256" ? "SHA-256" : "SHA-512";
+      return crypto.subtle.importKey("raw", binaryDer, { name: "HMAC", hash: { name: hashName } }, true, [
+        "sign"
+      ]);
+    } else if (auth.jwtAlgorithm == "ES256" || auth.jwtAlgorithm == "ES512") {
+      const pem = auth.jwtKey.replace(/-----BEGIN [^-]+-----/, "").replace(/-----END [^-]+-----/, "").replace(/\s+/g, "");
+      const binaryDerString = compatGlobal.atob(pem);
+      const binaryDer = new Uint8Array(binaryDerString.length);
+      for (let i = 0; i < binaryDerString.length; i++) {
+        binaryDer[i] = binaryDerString.charCodeAt(i);
+      }
+      const namedCurve = auth.jwtAlgorithm == "ES256" ? "P-256" : "P-521";
+      const param = { name: "ECDSA", namedCurve };
+      return crypto.subtle.importKey("pkcs8", binaryDer, param, true, ["sign"]);
+    } else {
+      throw new Error("Supplied JWT algorithm is not supported.");
+    }
+  }
+  _currentCryptoKey = new Computed({
+    evaluation: async (auth) => {
+      return await this._importKey(auth);
+    }
+  });
+  _jwt = new Computed({
+    evaluation: async (params) => {
+      const encodedHeader = btoa(JSON.stringify(params.header));
+      const encodedPayload = btoa(JSON.stringify(params.payload));
+      const buff = `${encodedHeader}.${encodedPayload}`.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+      const key = (await this._currentCryptoKey.update(params.credentials)).value;
+      let token = "";
+      if (params.header.alg == "ES256" || params.header.alg == "ES512") {
+        const digestAlg = params.header.alg == "ES256" ? "SHA-256" : "SHA-512";
+        const jwt = await crypto.subtle.sign(
+          { name: "ECDSA", hash: { name: digestAlg } },
+          key,
+          writeString(buff)
+        );
+        token = (await arrayBufferToBase64Single(jwt)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+      } else if (params.header.alg == "HS256" || params.header.alg == "HS512") {
+        const jwt = await crypto.subtle.sign(
+          { name: "HMAC", hash: { name: params.header.alg } },
+          key,
+          writeString(buff)
+        );
+        token = (await arrayBufferToBase64Single(jwt)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+      } else {
+        throw new Error("JWT algorithm is not supported.");
+      }
+      return {
+        ...params,
+        token: `${buff}.${token}`
+      };
+    }
+  });
+  _jwtParams = new Computed({
+    evaluation(source) {
+      const kid = source.jwtKid || void 0;
+      const sub = (source.jwtSub || "").trim();
+      if (sub == "") {
+        throw new Error("JWT sub is empty");
+      }
+      const algorithm = source.jwtAlgorithm || "";
+      if (!algorithm) {
+        throw new Error("JWT algorithm is not configured.");
+      }
+      if (algorithm != "HS256" && algorithm != "HS512" && algorithm != "ES256" && algorithm != "ES512") {
+        throw new Error("JWT algorithm is not supported.");
+      }
+      const header = {
+        alg: source.jwtAlgorithm || "HS256",
+        typ: "JWT",
+        kid
+      };
+      const iat = ~~((/* @__PURE__ */ new Date()).getTime() / 1e3);
+      const exp = iat + (source.jwtExpDuration || 5) * 60;
+      const payload = {
+        exp,
+        iat,
+        sub: source.jwtSub || "",
+        "_couchdb.roles": ["_admin"]
+      };
+      return {
+        header,
+        payload,
+        credentials: source
+      };
+    },
+    requiresUpdate(args, previousArgs, previous) {
+      if (!previous || previous instanceof Error) {
+        return true;
+      }
+      const ttl = previous.payload.exp - previous.payload.iat;
+      const margin20p = ttl * 0.1;
+      const margin = Math.min(10, Math.max(margin20p, 60));
+      const d = ~~((/* @__PURE__ */ new Date()).getTime() / 1e3) + margin;
+      if (previous.payload.exp < d) {
+        return true;
+      }
+      return false;
+    }
+  });
+  async getJWT(auth) {
+    const params = (await this._jwtParams.update(auth)).value;
+    const jwt = (await this._jwt.update(params)).value;
+    return jwt;
+  }
+  /**
+   * Generates a JWT token based on the provided credentials and parameters.
+   * @param auth - JWTCredentials
+   * @returns {Promise<string>} The JWT token (with "Bearer" prefix).
+   */
+  async getBearerToken(auth) {
+    const jwt = await this.getJWT(auth);
+    return `Bearer ${jwt.token}`;
+  }
+}
+class AuthorizationHeaderGenerator {
+  _basicHeader = new BasicHeaderGenerator();
+  _jwtHeader = new JWTTokenGenerator();
+  async getAuthorizationHeader(auth) {
+    if ("username" in auth) {
+      return await this._basicHeader.getBasicHeader(auth);
+    } else if ("jwtAlgorithm" in auth) {
+      return await this._jwtHeader.getBearerToken(auth);
+    }
+    return "";
+  }
+}
+export {
+  AuthorizationHeaderGenerator,
+  BasicHeaderGenerator,
+  JWTTokenGenerator,
+  generateCredentialObject
+};

package/dist/replication/journal/JournalSyncCore.d.ts

@@ -0,0 +1,70 @@
+import { type EntryDoc, type SyncParameters, type BucketSyncSetting, type RemoteDBSettings } from "../../common/types.js";
+import type { ReplicationCallback, ReplicationStat } from "../LiveSyncAbstractReplicator.js";
+import { type SimpleStore } from "../../common/utils.js";
+import { type CheckPointInfo } from "./JournalSyncTypes.js";
+import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
+import type { IJournalStorage } from "./objectstore/JournalStorageAdapter.js";
+type ProcessingEntry = PouchDB.Core.PutDocument<EntryDoc> & PouchDB.Core.GetMeta;
+export declare class JournalSyncCore {
+    _settings: BucketSyncSetting;
+    storage: IJournalStorage;
+    get db(): PouchDB.Database<EntryDoc>;
+    get currentSettings(): import("../../common/types.js").ObsidianLiveSyncSettings;
+    hash: string;
+    processReplication: ReplicationCallback;
+    batchSize: number;
+    env: LiveSyncJournalReplicatorEnv;
+    store: SimpleStore<CheckPointInfo>;
+    requestedStop: boolean;
+    getInitialSyncParameters(): Promise<SyncParameters>;
+    getSyncParameters(): Promise<SyncParameters>;
+    putSyncParameters(params: SyncParameters): Promise<boolean>;
+    getHash(settings: BucketSyncSetting): string;
+    constructor(settings: BucketSyncSetting, store: SimpleStore<CheckPointInfo>, env: LiveSyncJournalReplicatorEnv, storage: IJournalStorage);
+    downloadJson<T>(key: string): Promise<T | false>;
+    uploadJson<T>(key: string, body: T): Promise<boolean>;
+    applyNewConfig(settings: BucketSyncSetting, store: SimpleStore<CheckPointInfo>, env: LiveSyncJournalReplicatorEnv): void;
+    updateInfo(info: Partial<ReplicationStat>): void;
+    updateCheckPointInfo(func: (infoFrom: CheckPointInfo) => CheckPointInfo): Promise<CheckPointInfo>;
+    _currentCheckPointInfo: {
+        lastLocalSeq: number | string;
+        journalEpoch: string;
+        knownIDs: Set<string>;
+        sentIDs: Set<string>;
+        receivedFiles: Set<string>;
+        sentFiles: Set<string>;
+    };
+    getCheckpointInfo(): Promise<CheckPointInfo>;
+    resetAllCaches(): void;
+    resetCheckpointInfo(): Promise<void>;
+    private getJournalEpochFromSyncParams;
+    ensureCheckpointCachesAreFresh(): Promise<void>;
+    isAvailable(): Promise<boolean>;
+    resetBucket(): Promise<boolean>;
+    getRemoteKey(): string;
+    getReplicationPBKDF2Salt(refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    isEncryptionPrevented(fileName: string): boolean;
+    private decryptDataV2;
+    private decryptDataV1;
+    decryptDownloaded(key: string, encrypted: Uint8Array<ArrayBuffer>, set: RemoteDBSettings): Promise<Uint8Array<ArrayBuffer>>;
+    encryptForUpload(key: string, data: Uint8Array<ArrayBuffer>, set: RemoteDBSettings): Promise<Uint8Array<ArrayBuffer>>;
+    getDocKey(doc: EntryDoc): string;
+    _createJournalPack(override?: number | string): Promise<{
+        changes: EntryDoc[];
+        hasNext: boolean;
+        packLastSeq: string | number;
+    }>;
+    private _createSendReadableStream;
+    private _createSendCompressTransformStream;
+    private _createSendUploadWritableStream;
+    sendLocalJournal(showMessage?: boolean): Promise<boolean>;
+    _getRemoteJournals(): Promise<string[]>;
+    processDocuments(allDocs: ProcessingEntry[]): Promise<boolean>;
+    private _createReceiveReadableStream;
+    private _createReceiveTransformStream;
+    private _createReceiveWritableStream;
+    receiveRemoteJournal(showMessage?: boolean): Promise<boolean>;
+    sync(showResult?: boolean): Promise<boolean>;
+    requestStop(): void;
+}
+export {};