@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/common/ConnectionString.js

@@ -0,0 +1,179 @@
+const PROXY_SCHEME = "https";
+function parseSlsUri(uriString) {
+  const match = uriString.match(/^sls\+([^:]+):(.*)$/);
+  if (!match) {
+    throw new Error(`Unsupported URI: ${uriString}`);
+  }
+  const subscheme = match[1];
+  const rest = match[2];
+  return { url: new URL(`${PROXY_SCHEME}:${rest}`), subscheme };
+}
+function withSlsScheme(url, subscheme) {
+  const out = url.toString();
+  return `sls+${subscheme}:${out.slice(PROXY_SCHEME.length + 1)}`;
+}
+class ConnectionStringParser {
+  /**
+   * Restore settings from URI
+   */
+  static parse(uriString) {
+    const match = uriString.match(/^sls\+([^:]+):/);
+    if (!match) {
+      throw new Error(`Unsupported URI: ${uriString}`);
+    }
+    const subscheme = match[1];
+    if (subscheme === "p2p") {
+      return {
+        type: "p2p",
+        settings: this.parseP2P(uriString)
+      };
+    }
+    const { url } = parseSlsUri(uriString);
+    switch (subscheme) {
+      case "http":
+      case "https":
+        return {
+          type: "couchdb",
+          settings: this.parseCouchDB(url, subscheme)
+        };
+      case "s3":
+        return {
+          type: "s3",
+          settings: this.parseS3(url)
+        };
+      default:
+        throw new Error(`Unsupported protocol: sls+${subscheme}`);
+    }
+  }
+  /**
+   * 設定からURIを生成する
+   */
+  static serialize(config) {
+    switch (config.type) {
+      case "couchdb":
+        return this.serializeCouchDB(config.settings);
+      case "s3":
+        return this.serializeS3(config.settings);
+      case "p2p":
+        return this.serializeP2P(config.settings);
+      default:
+        throw new Error(`Unsupported type: ${config.type}`);
+    }
+  }
+  static parseCouchDB(url, originalScheme) {
+    return {
+      couchDB_URI: `${originalScheme}://${url.host}${url.pathname === "/" ? "" : url.pathname}`,
+      couchDB_USER: decodeURIComponent(url.username),
+      couchDB_PASSWORD: decodeURIComponent(url.password),
+      couchDB_DBNAME: url.searchParams.get("db") || "",
+      couchDB_CustomHeaders: url.searchParams.get("headers") || "",
+      useJWT: url.searchParams.get("useJWT") === "true",
+      jwtAlgorithm: url.searchParams.get("jwtAlg") || "",
+      jwtKey: url.searchParams.get("jwtKey") || "",
+      jwtKid: url.searchParams.get("jwtKid") || "",
+      jwtSub: url.searchParams.get("jwtSub") || "",
+      jwtExpDuration: parseInt(url.searchParams.get("jwtExp") || "5"),
+      useRequestAPI: url.searchParams.get("useRequestAPI") === "true"
+    };
+  }
+  static serializeCouchDB(settings) {
+    const url = new URL(settings.couchDB_URI);
+    const subscheme = url.protocol.replace(":", "");
+    const newUrl = new URL(`${PROXY_SCHEME}://${url.host}${url.pathname}`);
+    newUrl.username = encodeURIComponent(settings.couchDB_USER);
+    newUrl.password = encodeURIComponent(settings.couchDB_PASSWORD);
+    newUrl.searchParams.set("db", settings.couchDB_DBNAME);
+    if (settings.couchDB_CustomHeaders) newUrl.searchParams.set("headers", settings.couchDB_CustomHeaders);
+    if (settings.useJWT) {
+      newUrl.searchParams.set("useJWT", "true");
+      newUrl.searchParams.set("jwtAlg", settings.jwtAlgorithm);
+      if (settings.jwtKey) newUrl.searchParams.set("jwtKey", settings.jwtKey);
+      if (settings.jwtKid) newUrl.searchParams.set("jwtKid", settings.jwtKid);
+      if (settings.jwtSub) newUrl.searchParams.set("jwtSub", settings.jwtSub);
+      newUrl.searchParams.set("jwtExp", `${settings.jwtExpDuration || 5}`);
+    }
+    if (settings.useRequestAPI) newUrl.searchParams.set("useRequestAPI", "true");
+    return withSlsScheme(newUrl, subscheme);
+  }
+  static parseS3(url) {
+    const endpoint = url.searchParams.get("endpoint") || `https://${url.host}`;
+    return {
+      accessKey: decodeURIComponent(url.username),
+      secretKey: decodeURIComponent(url.password),
+      endpoint,
+      bucket: url.searchParams.get("bucket") || "",
+      region: url.searchParams.get("region") || "auto",
+      bucketPrefix: url.searchParams.get("prefix") || "",
+      useCustomRequestHandler: url.searchParams.get("useProxy") === "true",
+      bucketCustomHeaders: url.searchParams.get("headers") || "",
+      forcePathStyle: url.searchParams.get("pathStyle") !== "false"
+    };
+  }
+  static serializeS3(settings) {
+    const url = new URL(settings.endpoint);
+    const newUrl = new URL(`${PROXY_SCHEME}://${url.host}`);
+    newUrl.username = encodeURIComponent(settings.accessKey);
+    newUrl.password = encodeURIComponent(settings.secretKey);
+    newUrl.searchParams.set("endpoint", settings.endpoint);
+    newUrl.searchParams.set("bucket", settings.bucket);
+    newUrl.searchParams.set("region", settings.region);
+    if (settings.bucketPrefix) newUrl.searchParams.set("prefix", settings.bucketPrefix);
+    if (settings.bucketCustomHeaders) newUrl.searchParams.set("headers", settings.bucketCustomHeaders);
+    if (settings.useCustomRequestHandler) newUrl.searchParams.set("useProxy", "true");
+    if (!settings.forcePathStyle) newUrl.searchParams.set("pathStyle", "false");
+    return withSlsScheme(newUrl, "s3");
+  }
+  static parseP2P(uriString) {
+    const match = uriString.match(/^sls\+p2p:\/\/([^?#]+)(?:\?([^#]*))?(?:#(.*))?$/);
+    if (!match) {
+      throw new Error(`Invalid P2P URI: ${uriString}`);
+    }
+    const authority = match[1];
+    const queryString = match[2] || "";
+    let userinfo = "";
+    let host = authority;
+    const lastAtIndex = authority.lastIndexOf("@");
+    if (lastAtIndex !== -1) {
+      userinfo = authority.slice(0, lastAtIndex);
+      host = authority.slice(lastAtIndex + 1);
+    }
+    let password = "";
+    if (userinfo) {
+      const colonIndex = userinfo.indexOf(":");
+      if (colonIndex !== -1) {
+        password = userinfo.slice(colonIndex + 1);
+      }
+    }
+    const searchParams = new URLSearchParams(queryString);
+    return {
+      P2P_Enabled: searchParams.get("enabled") !== "false",
+      P2P_roomID: decodeURIComponent(host),
+      P2P_passphrase: decodeURIComponent(password),
+      P2P_relays: searchParams.get("relays") || "",
+      P2P_AppID: searchParams.get("appId") || "self-hosted-livesync",
+      P2P_AutoStart: searchParams.get("autoStart") === "true",
+      P2P_AutoBroadcast: searchParams.get("autoBroadcast") === "true",
+      P2P_turnServers: searchParams.get("turnServers") || "",
+      P2P_turnUsername: searchParams.get("turnUser") || "",
+      P2P_turnCredential: searchParams.get("turnPass") || ""
+    };
+  }
+  static serializeP2P(settings) {
+    const searchParams = new URLSearchParams();
+    if (!settings.P2P_Enabled) searchParams.set("enabled", "false");
+    searchParams.set("relays", settings.P2P_relays);
+    searchParams.set("appId", settings.P2P_AppID);
+    if (settings.P2P_AutoStart) searchParams.set("autoStart", "true");
+    if (settings.P2P_AutoBroadcast) searchParams.set("autoBroadcast", "true");
+    if (settings.P2P_turnServers) searchParams.set("turnServers", settings.P2P_turnServers);
+    if (settings.P2P_turnUsername) searchParams.set("turnUser", settings.P2P_turnUsername);
+    if (settings.P2P_turnCredential) searchParams.set("turnPass", settings.P2P_turnCredential);
+    const credentials = settings.P2P_passphrase ? `:${encodeURIComponent(settings.P2P_passphrase)}@` : "";
+    const host = encodeURIComponent(settings.P2P_roomID);
+    const query = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    return `sls+p2p://${credentials}${host}${query}`;
+  }
+}
+export {
+  ConnectionStringParser
+};

package/dist/common/LSError.d.ts

@@ -0,0 +1,48 @@
+import type { Constructor } from "./utils.type.js";
+interface ErrorWithCause extends Error {
+    cause?: unknown;
+}
+/**
+ * Error class for Self-hosted LiveSync errors.
+ * This class extends the base LiveSyncError class and provides additional context for errors related to LiveSync operations.
+ * It includes a name property and a cause property to capture the original error.
+ * The status property returns the HTTP status code if available, defaulting to 500 for internal server errors.
+ * The class also includes static methods to check whether an error is caused by a specific error class.
+ */
+export declare class LiveSyncError extends Error implements ErrorWithCause {
+    name: string;
+    cause?: Error | object | string;
+    overrideStatus?: number;
+    /**
+     * Returns the HTTP status code associated with the error, if available.
+     * If the error has a status property, it returns that; otherwise, it defaults to 500 (Internal Server Error).
+     * @returns {number} The HTTP status code.
+     */
+    get status(): number;
+    /**
+     * Constructs a new LiveSyncError instance.
+     * @param message The error message to be displayed.
+     */
+    constructor(message: string, options?: {
+        cause?: unknown;
+        status?: number;
+    });
+    /**
+     * Determines whether an error is caused by a specific error class.
+     * @param error The error to examine.
+     * @param errorClass The error class to compare against.
+     * @returns True if the error is caused by the specified error class; otherwise, false.
+     * @example
+     * LiveSyncError.isCausedBy(someSyncParamsFetchError, SyncParamsNotFoundError); // Returns true if the error is caused by SyncParamsNotFoundError; this is usually represented as SyncParamsFetchError at the uppermost layer.
+     */
+    static isCausedBy<T extends LiveSyncError>(error: unknown, errorClass: Constructor<T>): boolean;
+    /**
+     * Creates a new instance of the error class from an existing error.
+     * @param error The error to wrap.
+     * @returns A new instance of the error class with the original error's message and stack trace.
+     */
+    static fromError<T extends typeof LiveSyncError>(this: T, error: unknown): InstanceType<T>;
+}
+export declare class LiveSyncFatalError extends LiveSyncError {
+}
+export {};

package/dist/common/LSError.js

@@ -0,0 +1,112 @@
+function getStatusFromError(error) {
+  if (error && typeof error === "object") {
+    if ("status" in error && typeof error.status === "number") {
+      return error.status;
+    }
+    if ("cause" in error) {
+      return getStatusFromError(error.cause);
+    }
+  }
+  return 500;
+}
+function getMessageFromError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null) {
+    return JSON.stringify(error);
+  }
+  return String(error);
+}
+function getErrorCause(error) {
+  if (error && typeof error === "object" && "cause" in error) {
+    return error.cause;
+  }
+  return void 0;
+}
+class LiveSyncError extends Error {
+  name = this.constructor.name;
+  cause;
+  overrideStatus;
+  /**
+   * Returns the HTTP status code associated with the error, if available.
+   * If the error has a status property, it returns that; otherwise, it defaults to 500 (Internal Server Error).
+   * @returns {number} The HTTP status code.
+   */
+  get status() {
+    if (this.overrideStatus !== void 0) {
+      return this.overrideStatus;
+    }
+    if (this.cause) {
+      const status = getStatusFromError(this.cause);
+      if (status !== void 0) {
+        return status;
+      }
+    }
+    return 500;
+  }
+  /**
+   * Constructs a new LiveSyncError instance.
+   * @param message The error message to be displayed.
+   */
+  constructor(message, options) {
+    super(message);
+    if (options?.cause) {
+      const actualCause = getErrorCause(options);
+      this.cause = actualCause instanceof Error ? actualCause : new Error(`Unknown cause: ${getMessageFromError(actualCause)}`);
+    }
+    if (options?.status !== void 0) {
+      this.overrideStatus = options.status;
+    }
+  }
+  /**
+   * Determines whether an error is caused by a specific error class.
+   * @param error The error to examine.
+   * @param errorClass The error class to compare against.
+   * @returns True if the error is caused by the specified error class; otherwise, false.
+   * @example
+   * LiveSyncError.isCausedBy(someSyncParamsFetchError, SyncParamsNotFoundError); // Returns true if the error is caused by SyncParamsNotFoundError; this is usually represented as SyncParamsFetchError at the uppermost layer.
+   */
+  static isCausedBy(error, errorClass) {
+    if (!error) {
+      return false;
+    }
+    if (error instanceof errorClass) {
+      return true;
+    }
+    if (typeof error === "object" && !!error && "cause" in error) {
+      const cause = getErrorCause(error);
+      if (cause === error) {
+        return false;
+      }
+      return LiveSyncError.isCausedBy(cause, errorClass);
+    }
+    return false;
+  }
+  /**
+   * Creates a new instance of the error class from an existing error.
+   * @param error The error to wrap.
+   * @returns A new instance of the error class with the original error's message and stack trace.
+   */
+  static fromError(error) {
+    if (error instanceof this) {
+      return error;
+    }
+    const instance = new this(`${this.name}: ${getMessageFromError(error)}`, {
+      cause: error,
+      status: getStatusFromError(error)
+    });
+    if (error instanceof Error) {
+      instance.stack = error.stack;
+    } else {
+      instance.stack = new Error().stack;
+    }
+    return instance;
+  }
+}
+class LiveSyncFatalError extends LiveSyncError {
+}
+export {
+  LiveSyncError,
+  LiveSyncFatalError
+};

package/dist/common/configForDoc.d.ts

@@ -0,0 +1,79 @@
+import type { Confirm } from "../interfaces/Confirm.js";
+import type { MessageTranslator } from "../services/base/MessageTranslator.js";
+import { type ObsidianLiveSyncSettings } from "./types.js";
+declare enum ConditionType {
+    PLATFORM_CASE_INSENSITIVE = "platform-case-insensitive",
+    PLATFORM_CASE_SENSITIVE = "platform-case-sensitive",
+    REMOTE_CASE_SENSITIVE = "remote-case-sensitive"
+}
+export declare enum RuleLevel {
+    Must = 0,
+    Necessary = 1,
+    Recommended = 2,
+    Optional = 3
+}
+type BaseRule<TType extends string, TValue> = {
+    level?: RuleLevel;
+    requireRebuild?: boolean;
+    requireRebuildLocal?: boolean;
+    recommendRebuild?: boolean;
+    reason?: string;
+    reasonFunc?: (settings: Partial<ObsidianLiveSyncSettings>, translate: MessageTranslator) => string;
+    condition?: ConditionType[];
+    detectionFunc?: (settings: Partial<ObsidianLiveSyncSettings>) => boolean;
+    value?: TValue;
+    valueDisplay?: string;
+    valueDisplayFunc?: (settings: Partial<ObsidianLiveSyncSettings>) => string;
+    obsoleteValues?: TValue[];
+};
+type NumberRuleExact = BaseRule<"number", number> & {};
+type NumberRuleRange = BaseRule<"number", number> & {
+    min?: number;
+    max?: number;
+    step?: number;
+};
+type StringRangeRule = BaseRule<"string", string> & {
+    minLength?: number;
+    maxLength?: number;
+    regexp?: string;
+};
+type StringRule = BaseRule<"string", string> & {};
+type BooleanRule = BaseRule<"boolean", boolean> & {};
+export type RuleForType<T> = T extends number ? NumberRuleExact | NumberRuleRange : T extends string ? StringRule | StringRangeRule : T extends boolean ? BooleanRule : never;
+type DoctorCheckSettings = Omit<Partial<ObsidianLiveSyncSettings>, "remoteConfigurations" | "pluginSyncExtendedSetting">;
+export type DoctorRegulation = {
+    version: string;
+    rules: {
+        [P in keyof DoctorCheckSettings]: RuleForType<DoctorCheckSettings[P]>;
+    };
+};
+export declare const DoctorRegulationV0_24_16: DoctorRegulation;
+export declare const DoctorRegulationV0_24_30: DoctorRegulation;
+export declare const DoctorRegulationV0_25_0: DoctorRegulation;
+export declare const DoctorRegulationV0_25_27: DoctorRegulation;
+export declare const DoctorRegulation: DoctorRegulation;
+export declare function checkUnsuitableValues(setting: Partial<ObsidianLiveSyncSettings>, regulation?: DoctorRegulation): DoctorRegulation;
+export declare const RebuildOptions: {
+    readonly AutomaticAcceptable: 0;
+    readonly ConfirmIfRequired: 1;
+    readonly SkipEvenIfRequired: 2;
+};
+export type RebuildOptionsType = (typeof RebuildOptions)[keyof typeof RebuildOptions];
+export type DoctorOptions = {
+    localRebuild: RebuildOptionsType;
+    remoteRebuild: RebuildOptionsType;
+    activateReason?: string;
+    forceRescan?: boolean;
+};
+export type DoctorResult = {
+    settings: ObsidianLiveSyncSettings;
+    shouldRebuild: boolean;
+    shouldRebuildLocal: boolean;
+    isModified: boolean;
+};
+export type HasConfirm = {
+    confirm: Confirm;
+    translate: MessageTranslator;
+};
+export declare function performDoctorConsultation(env: HasConfirm, settings: ObsidianLiveSyncSettings, { localRebuild, remoteRebuild, activateReason, forceRescan, }: DoctorOptions): Promise<DoctorResult>;
+export {};