@onyx-p/imlib-web 3.0.0 → 3.0.2

package/package.json

@@ -1,9 +1,24 @@
 {
   "name": "@onyx-p/imlib-web",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "main": "index.umd.js",
   "module": "index.esm.js",
   "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.umd.js"
+    },
+    "./main": {
+      "types": "./types/database/main-entry.d.ts",
+      "require": "./database/main.cjs"
+    },
+    "./preload": {
+      "types": "./types/database/preload-entry.d.ts",
+      "require": "./database/preload.cjs"
+    }
+  },
   "files": [
     "index.umd.js",
     "index.esm.js",
@@ -11,9 +26,20 @@
     "types/types.d.ts",
     "types/model",
     "types/constants",
+    "types/database",
+    "database",
     "README.md"
   ],
+  "dependencies": {
+    "@signalapp/sqlcipher": "4.0.5",
+    "crypto-js": "^4.2.0",
+    "long": "^5.2.3",
+    "protobufjs": "^7.4.0"
+  },
+  "peerDependencies": {
+    "electron": ">=30.0.0"
+  },
   "keywords": ["im"],
   "author": "zimu",
   "license": "MIT"
-} 
+}

package/types/database/contracts.d.ts

@@ -0,0 +1,44 @@
+export declare const DATABASE_GLOBAL: "acimDatabase";
+export declare const DATABASE_CHANNEL: "acim-database:request";
+export declare const READ_METHOD_NAMES: readonly ["getMessages", "getLatestMessage", "getLatestMessages", "getDialogLoadedState", "getMessageById", "getMessageByUId", "getMessageIdRange", "searchMessages", "searchTextMessages", "getLegacyMigrationState"];
+export declare const WRITE_METHOD_NAMES: readonly ["addMessages", "clearConversationCache", "clearAllCache", "removeMessagesByUId", "updateMessageReceiptStatus", "clearBurnAfterReadingExpiredMessages", "upsertMessage", "convertToRecallMessages", "importLegacyBatch", "completeLegacyMigration"];
+export type DatabaseReadMethod = (typeof READ_METHOD_NAMES)[number];
+export type DatabaseWriteMethod = (typeof WRITE_METHOD_NAMES)[number];
+export type DatabaseMethod = DatabaseReadMethod | DatabaseWriteMethod;
+export declare const READ_METHODS: ReadonlySet<string>;
+export declare const WRITE_METHODS: ReadonlySet<string>;
+export type DatabaseOpenOptions = Readonly<{
+    appKey: string;
+    userId: string;
+}>;
+export type LegacyMigrationState = 'pending' | 'in_progress' | 'complete';
+export type DatabaseRequest = Readonly<{
+    type: 'open';
+    options: DatabaseOpenOptions;
+}> | Readonly<{
+    type: 'close';
+}> | Readonly<{
+    type: 'read';
+    method: DatabaseReadMethod;
+    args: ReadonlyArray<unknown>;
+}> | Readonly<{
+    type: 'write';
+    method: DatabaseWriteMethod;
+    args: ReadonlyArray<unknown>;
+}>;
+export type SerializedDatabaseError = Readonly<{
+    name: string;
+    message: string;
+    stack: string | undefined;
+}>;
+export type DatabaseResponse = Readonly<{
+    ok: true;
+    value: unknown;
+}> | Readonly<{
+    ok: false;
+    error: SerializedDatabaseError;
+}>;
+export interface DatabaseBridge {
+    request(request: DatabaseRequest): Promise<DatabaseResponse>;
+}
+export declare function serializeDatabaseError(error: unknown): SerializedDatabaseError;

package/types/database/main/index.d.ts

@@ -0,0 +1,2 @@
+export { DatabaseKeyStore, type SafeStorageAdapter } from './keyStore';
+export { MainDatabaseService, ThreadWorkerClient, createThreadWorkerFactory, type DatabaseWorkerClient, type WorkerClientFactory } from './service';

package/types/database/main/ipc.d.ts

@@ -0,0 +1,18 @@
+import { type DatabaseOpenOptions, type DatabaseReadMethod, type DatabaseResponse, type DatabaseWriteMethod } from '../contracts';
+export interface DatabaseIpcMain {
+    handle(channel: string, handler: (event: unknown, request: unknown) => Promise<DatabaseResponse>): void;
+    removeHandler(channel: string): void;
+}
+export interface DatabaseServiceLike {
+    open(options: DatabaseOpenOptions): Promise<void>;
+    close(): Promise<void>;
+    read(method: DatabaseReadMethod, args: ReadonlyArray<unknown>): Promise<unknown>;
+    write(method: DatabaseWriteMethod, args: ReadonlyArray<unknown>): Promise<unknown>;
+}
+type RegisterDatabaseIpcOptions = Readonly<{
+    ipcMain: DatabaseIpcMain;
+    service: DatabaseServiceLike;
+    isTrustedEvent?: (event: unknown) => boolean;
+}>;
+export declare function registerDatabaseIpc({ ipcMain, service, isTrustedEvent }: RegisterDatabaseIpcOptions): () => void;
+export {};

package/types/database/main/keyStore.d.ts

@@ -0,0 +1,14 @@
+export interface SafeStorageAdapter {
+    encryptString(value: string): Uint8Array;
+    decryptString(value: Uint8Array): string;
+}
+export declare class DatabaseKeyStore {
+    private readonly directory;
+    private readonly safeStorage;
+    private readonly filePath;
+    constructor(directory: string, safeStorage: SafeStorageAdapter);
+    getOrCreate(accountId: string): string;
+    private readKeys;
+    private writeKeys;
+    private validateKey;
+}

package/types/database/main/messageStore.d.ts

@@ -0,0 +1,58 @@
+import type { LegacyMigrationState } from '../contracts';
+import type { SqlDatabase } from './sqlTypes';
+export type StoredMessage = {
+    messageId: number;
+    messageUId?: string;
+    sentTime: string;
+    content?: any;
+    quotedReply?: any;
+    receivedStatus?: number;
+    burnAfterReadingFlag?: boolean;
+    burnAfterReadingTime?: number;
+    messageType?: number;
+    isPersited?: boolean;
+    [key: string]: any;
+};
+export type DialogState = Readonly<{
+    dialogId: string;
+    isEnd: boolean;
+    updateTime?: number;
+}>;
+export type LegacyImportBatch = Readonly<{
+    messages: ReadonlyArray<StoredMessage & {
+        dialogId?: string;
+    }>;
+    dialogStates: ReadonlyArray<DialogState>;
+}>;
+export declare class MessageStore {
+    private readonly database;
+    constructor(database: SqlDatabase);
+    addMessages(messages: ReadonlyArray<StoredMessage>, dialogId: string, isEnd?: boolean): void;
+    upsertMessage(message: StoredMessage, dialogId: string): void;
+    getMessages(dialogId: string, timestamp?: string, count?: number, isForward?: boolean): {
+        messages: StoredMessage[];
+        hasMore: boolean;
+    };
+    getLatestMessage(dialogId: string): StoredMessage | null;
+    getLatestMessages(dialogIds: ReadonlyArray<string>): Record<string, StoredMessage | null>;
+    getMessageById(messageId: number): StoredMessage | null;
+    getMessageByUId(messageUId: string): StoredMessage | null;
+    getMessageIdRange(): {
+        newest: number;
+        oldest: number;
+    } | null;
+    getDialogLoadedState(dialogId: string): boolean;
+    clearConversationCache(dialogId: string): void;
+    clearAllCache(): void;
+    removeMessagesByUId(messageUIds: ReadonlyArray<string>): void;
+    updateMessageReceiptStatus(messageUIds: ReadonlyArray<string>, receivedStatus: number): void;
+    clearBurnAfterReadingExpiredMessages(dialogId: string, now?: number): string[];
+    convertToRecallMessages(messageUIds: ReadonlyArray<string>, recallMessageType: number): void;
+    searchTextMessages(dialogId: string, keyword: string): StoredMessage[];
+    searchMessages(keyword: string, dialogId?: string, limit?: number): StoredMessage[];
+    getLegacyMigrationState(): LegacyMigrationState;
+    importLegacyBatch(batch: LegacyImportBatch): void;
+    completeLegacyMigration(): void;
+    private setDialogState;
+    private setMetadata;
+}

package/types/database/main/migrations.d.ts

@@ -0,0 +1,9 @@
+import type { SqlDatabase } from './sqlTypes';
+export type SchemaMigration = Readonly<{
+    version: number;
+    up(database: SqlDatabase): void;
+}>;
+export declare const SCHEMA_MIGRATIONS: ReadonlyArray<SchemaMigration>;
+export declare const LATEST_SCHEMA_VERSION: number;
+export declare function validateMigrations(migrations: ReadonlyArray<SchemaMigration>): void;
+export declare function runMigrations(database: SqlDatabase, migrations?: ReadonlyArray<SchemaMigration>): void;

package/types/database/main/service.d.ts

@@ -0,0 +1,36 @@
+import { Worker } from 'node:worker_threads';
+import type { DatabaseOpenOptions, DatabaseReadMethod, DatabaseWriteMethod } from '../contracts';
+import type { DatabaseKeyStore } from './keyStore';
+import type { DatabaseWorkerRequest } from './workerProtocol';
+export interface DatabaseWorkerClient {
+    request(request: DatabaseWorkerRequest): Promise<unknown>;
+    close(): Promise<void>;
+}
+export type WorkerClientFactory = (index: number) => DatabaseWorkerClient;
+export type MainDatabaseServiceOptions = Readonly<{
+    userDataPath: string;
+    keyStore: DatabaseKeyStore;
+    workerFactory: WorkerClientFactory;
+    workerCount?: number;
+}>;
+export declare class MainDatabaseService {
+    private readonly options;
+    private readonly workerCount;
+    private readonly pool;
+    private accountId;
+    constructor(options: MainDatabaseServiceOptions);
+    open(options: DatabaseOpenOptions): Promise<void>;
+    read(method: DatabaseReadMethod, args: ReadonlyArray<unknown>): Promise<unknown>;
+    write(method: DatabaseWriteMethod, args: ReadonlyArray<unknown>): Promise<unknown>;
+    close(): Promise<void>;
+    private assertOpen;
+}
+export declare class ThreadWorkerClient implements DatabaseWorkerClient {
+    private readonly worker;
+    private sequence;
+    private readonly pending;
+    constructor(worker: Worker);
+    request(request: DatabaseWorkerRequest): Promise<unknown>;
+    close(): Promise<void>;
+}
+export declare function createThreadWorkerFactory(workerPath: string): WorkerClientFactory;

package/types/database/main/sqlTypes.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from '@signalapp/sqlcipher';
+export type SqlDatabase = Database;

package/types/database/main/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/types/database/main/workerProtocol.d.ts

@@ -0,0 +1,34 @@
+import { type DatabaseMethod } from '../contracts';
+export type DatabaseWorkerRequest = Readonly<{
+    type: 'init';
+    dbPath: string;
+    key: string;
+    isPrimary: boolean;
+}> | Readonly<{
+    type: 'call';
+    access: 'read' | 'write';
+    method: DatabaseMethod | string;
+    args: ReadonlyArray<unknown>;
+}> | Readonly<{
+    type: 'close';
+}>;
+export type WrappedWorkerRequest = Readonly<{
+    sequence: number;
+    request: DatabaseWorkerRequest;
+}>;
+export type WrappedWorkerResponse = Readonly<{
+    sequence: number;
+    ok: boolean;
+    value?: unknown;
+    error?: Readonly<{
+        name: string;
+        message: string;
+        stack?: string;
+    }>;
+}>;
+export declare class WorkerDispatcher {
+    private database;
+    private store;
+    private isPrimary;
+    handle(request: DatabaseWorkerRequest): unknown;
+}

package/types/database/main-entry.d.ts

@@ -0,0 +1,12 @@
+import { MainDatabaseService } from './main/service';
+export type InitializeDatabaseMainOptions = Readonly<{
+    userDataPath?: string;
+    workerPath?: string;
+    isTrustedEvent?: (event: unknown) => boolean;
+}>;
+export type DatabaseMainController = Readonly<{
+    service: MainDatabaseService;
+    dispose(): Promise<void>;
+}>;
+export declare function initializeDatabaseMain(options?: InitializeDatabaseMainOptions): DatabaseMainController;
+export * from './main/index';

package/types/database/preload-entry.d.ts

@@ -0,0 +1 @@
+export { exposeDatabaseBridge } from './preload';

package/types/database/preload.d.ts

@@ -0,0 +1,8 @@
+import { type DatabaseRequest, type DatabaseResponse } from './contracts';
+export interface ContextBridgeLike {
+    exposeInMainWorld(name: string, value: unknown): void;
+}
+export interface IpcRendererLike {
+    invoke(channel: string, request: DatabaseRequest): Promise<DatabaseResponse>;
+}
+export declare function exposeDatabaseBridge(contextBridge: ContextBridgeLike, ipcRenderer: IpcRendererLike): void;

package/types/database/renderer/bridge.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseBridge, DatabaseRequest } from '../contracts';
+export declare function invokeDatabase(bridge: DatabaseBridge, request: DatabaseRequest): Promise<unknown>;
+export declare function getDatabaseBridge(): DatabaseBridge;

package/types/database/renderer/legacyIndexedDbMigration.d.ts

@@ -0,0 +1,28 @@
+import CryptoJS from 'crypto-js';
+import type { DatabaseBridge } from '../contracts';
+type LegacySecret = {
+    key: string;
+    iv: string;
+};
+export type LegacyMigrationProgress = Readonly<{
+    processedMessages: number;
+    processedDialogStates: number;
+}>;
+export type LegacyMigrationResult = Readonly<{
+    migrated: boolean;
+    messages: number;
+    dialogStates: number;
+}>;
+type MigrationOptions = Readonly<{
+    appKey: string;
+    userId: string;
+    bridge: DatabaseBridge;
+    indexedDBFactory?: IDBFactory;
+    keyRange?: typeof IDBKeyRange;
+    batchSize?: number;
+    onProgress?: (progress: LegacyMigrationProgress) => void;
+}>;
+export declare function deriveLegacyEncryptionKey(appKey: string, userId: string): LegacySecret;
+export declare function decryptLegacyMessage<T extends Record<string, any>>(source: T, secret: LegacySecret, crypto?: typeof CryptoJS): T;
+export declare function migrateLegacyIndexedDb({ appKey, userId, bridge, indexedDBFactory, keyRange, batchSize, onProgress }: MigrationOptions): Promise<LegacyMigrationResult>;
+export {};

package/types/database/renderer/messageRepository.d.ts

@@ -0,0 +1,43 @@
+import type IReceivedMessage from '../../model/iReceivedMessage';
+import type { IConversationOption, IReceiptReceivedEvent } from '../../types';
+import type { DatabaseBridge } from '../contracts';
+import { type LegacyMigrationProgress, type LegacyMigrationResult } from './legacyIndexedDbMigration';
+export declare class SqlMessageRepository {
+    private readonly appKey;
+    private readonly userId;
+    private readonly bridge;
+    private initialization;
+    constructor(appKey: string, userId: string, bridge?: DatabaseBridge);
+    initDB(): Promise<void>;
+    migrateLegacyDatabase(onProgress?: (progress: LegacyMigrationProgress) => void): Promise<LegacyMigrationResult>;
+    close(): Promise<void>;
+    addMessages(messages: IReceivedMessage[], conversation: IConversationOption, isEnd?: boolean): Promise<void>;
+    getMessages(conversation: IConversationOption, timestamp?: string, count?: number, isForward?: boolean): Promise<{
+        messages: IReceivedMessage[];
+        hasMore: boolean;
+    }>;
+    getPreviousMessages(conversation: IConversationOption, timestamp?: string, count?: number): Promise<{
+        messages: IReceivedMessage[];
+        hasMore: boolean;
+    }>;
+    getLatestMessage(conversation: IConversationOption): Promise<IReceivedMessage | null>;
+    getLatestMessages(conversations: ReadonlyArray<IConversationOption>): Promise<Record<string, IReceivedMessage | null>>;
+    getMessageById(messageId: number): Promise<IReceivedMessage | null>;
+    getMessageByUId(messageUId: string): Promise<IReceivedMessage | null>;
+    getMessageIdRange(): Promise<{
+        newest: number;
+        oldest: number;
+    } | null>;
+    getDialogLoadedState(dialogId: string): Promise<boolean>;
+    clearConversationCache(conversation: IConversationOption): Promise<void>;
+    clearAllCache(): Promise<void>;
+    removeMessagesByUId(messageUIds: string[]): Promise<void>;
+    updateMessageReceiptStatus(event: IReceiptReceivedEvent, type: 0 | 1): Promise<void>;
+    clearBurnAfterReadingExpiredMessages(conversation: IConversationOption): Promise<string[]>;
+    upsertMessage(message: IReceivedMessage): Promise<void>;
+    convertToRecallMessages(messageUIds: string[]): Promise<void>;
+    searchTextMessages(conversation: IConversationOption, keyword: string): Promise<IReceivedMessage[]>;
+    searchMessages(keyword: string, limit?: number): Promise<IReceivedMessage[]>;
+    private read;
+    private write;
+}

package/types/index.d.ts

@@ -7,6 +7,7 @@ import IReceivedConversation from './model/iReceivedConversation';
 import { CommonReqResult, PBCodec } from './net/connection/webSocketServer';
 import { BaseResp } from './net/pbs/rpc.base';
 import { IChatRecordMsgDetail } from './model/messages/otherMediaMessages';
+import type { LegacyMigrationProgress, LegacyMigrationResult } from './database/renderer/legacyIndexedDbMigration';
 export { TextMessage, ImageMessage, HQVoiceMessage, GIFMessage, FileMessage, VideoMessage, RecallCommandMessage, LocationMessage, ChatRecordMessage, ContactMessage, InvitationMessage, RedEnvelopeMessage, TransferMessage, LinkMessage, PrivateOpenBurnAfterReadingMessage, PrivateCloseBurnAfterReadingMessage, GroupOpenBurnAfterReadingMessage, GroupCloseBurnAfterReadingMessage } from './model/messages';
 export type { ITextMessageBody, IImageMessageBody, IGIFMessageBody, IFileMessageBody, IHQVoiceMessageBody, IRecallCommandMessageBody, IVideoMessageBody, ILocationMessageBody, IChatRecordMessageBody, IContactMessageBody, IInvitationMessageBody, IRedEnvelopeMessageBody, ITransferMessageBody, IBurnAfterReadingMessageBody, ILinkMessageBody } from './model/messages';
 export { MessageTypes, NotiMessageTypes } from './constants/messageTypes';
@@ -18,6 +19,11 @@ export * from './model/statusTypes';
  * @param initOption
  */
 export declare const init: (initOption: IInitOption) => void;
+/**
+ * Explicitly retries the one-time IndexedDB to SQLCipher migration.
+ * Migration also runs automatically when the current user's database opens.
+ */
+export declare const migrateLegacyDatabase: (onProgress?: (progress: LegacyMigrationProgress) => void) => Promise<LegacyMigrationResult>;
 /**
  * 建立 IM 连接
  * @param token
@@ -28,8 +34,8 @@ export declare const connect: () => IPromiseResult<void>;
  * @description 调用后将不再接收消息，不可发送消息，不可获取历史消息，不可获取会话列表
  */
 export declare const disconnect: () => Promise<void>;
-export declare const setUserLogged: (info: ProfileInfo) => void;
-export declare const logOut: () => void;
+export declare const setUserLogged: (info: ProfileInfo) => Promise<void>;
+export declare const logOut: () => Promise<void>;
 /**
  * 获取 IM 连接状态
  */
@@ -286,3 +292,8 @@ export declare const getMessageById: (messageId: number) => IPromiseResult<IRece
  */
 export declare const getMessageByUId: (messageUId: string) => IPromiseResult<IReceivedMessage | null | undefined>;
 export declare const searchTextMessages: (conversation: IConversationOption, keyword: string) => IPromiseResult<IReceivedMessage[]>;
+/**
+ * 全局搜索本地消息，按发送时间倒序返回。
+ * 默认最多返回 500 条，与 Signal Desktop 的全局搜索默认值一致。
+ */
+export declare const searchMessages: (keyword: string, limit?: number) => IPromiseResult<IReceivedMessage[]>;