sayance-matrix-native-module
Version:
Native Matrix client module for Expo using Rust SDK
283 lines • 10.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.HybridMatrixClient = exports.MatrixMigrationHelper = void 0;
exports.createMigrationHelper = createMigrationHelper;
exports.createHybridClient = createHybridClient;
const index_1 = require("./index");
const StorageBridge_1 = require("./StorageBridge");
class MatrixMigrationHelper {
constructor() {
Object.defineProperty(this, "nativeClient", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "storageBridge", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "migrationStatus", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.nativeClient = new index_1.SayanceMatrixClient();
this.migrationStatus = {
initialized: false,
cryptoMigrated: false,
eventsMigrated: false,
};
}
async initialize(realm, asyncStorage) {
try {
this.storageBridge = (0, StorageBridge_1.createStorageBridge)(realm, asyncStorage);
this.nativeClient.setStorageBridge(this.storageBridge);
this.migrationStatus.initialized = true;
console.log('Migration helper initialized successfully');
}
catch (error) {
console.error('Failed to initialize migration helper:', error);
throw error;
}
}
async migrateCryptoData() {
if (!this.storageBridge) {
throw new Error('Migration helper not initialized');
}
try {
console.log('Starting crypto data migration...');
const result = await this.storageBridge.migrateCryptoDataFromAsyncStore();
if (result.errors.length === 0) {
this.migrationStatus.cryptoMigrated = true;
console.log(`Successfully migrated ${result.migrated} crypto keys`);
}
else {
console.warn(`Migration completed with ${result.errors.length} errors:`, result.errors);
}
return {
success: result.errors.length === 0,
migrated: result.migrated,
errors: result.errors,
};
}
catch (error) {
console.error('Crypto data migration failed:', error);
return {
success: false,
migrated: 0,
errors: [`Migration failed: ${error}`],
};
}
}
async migrateEventData() {
if (!this.storageBridge) {
throw new Error('Migration helper not initialized');
}
try {
console.log('Starting event data migration...');
const result = await this.storageBridge.migrateEventDataFromRealm();
if (result.errors.length === 0) {
this.migrationStatus.eventsMigrated = true;
console.log(`Successfully migrated ${result.migrated} room event sets`);
}
else {
console.warn(`Migration completed with ${result.errors.length} errors:`, result.errors);
}
return {
success: result.errors.length === 0,
migrated: result.migrated,
errors: result.errors,
};
}
catch (error) {
console.error('Event data migration failed:', error);
return {
success: false,
migrated: 0,
errors: [`Migration failed: ${error}`],
};
}
}
async initializeNativeClient(config) {
try {
console.log('Initializing native Matrix client...');
await this.nativeClient.initializeClient(config);
if (this.migrationStatus.cryptoMigrated) {
await this.nativeClient.setupEncryption();
console.log('Native encryption setup completed');
}
console.log('Native Matrix client initialized successfully');
}
catch (error) {
console.error('Failed to initialize native client:', error);
throw error;
}
}
async verifyMigration() {
if (!this.storageBridge) {
throw new Error('Migration helper not initialized');
}
try {
console.log('Verifying migration integrity...');
const result = await this.storageBridge.verifyMigration();
const success = result.issues.length === 0;
if (success) {
console.log(`Migration verification successful: ${result.cryptoKeysVerified} crypto keys, ${result.eventsVerified} event sets verified`);
}
else {
console.warn(`Migration verification found ${result.issues.length} issues:`, result.issues);
}
return {
success,
details: result,
};
}
catch (error) {
console.error('Migration verification failed:', error);
return {
success: false,
details: {
cryptoKeysVerified: 0,
eventsVerified: 0,
issues: [`Verification failed: ${error}`],
},
};
}
}
getMigrationStatus() {
return { ...this.migrationStatus };
}
getNativeClient() {
return this.nativeClient;
}
async runPhase1Migration(config, realm, asyncStorage) {
const steps = {
initialization: false,
cryptoMigration: { success: false, migrated: 0, errors: [] },
eventMigration: { success: false, migrated: 0, errors: [] },
nativeClientInit: false,
verification: { success: false, details: {} },
};
try {
await this.initialize(realm, asyncStorage);
steps.initialization = true;
steps.cryptoMigration = await this.migrateCryptoData();
steps.eventMigration = await this.migrateEventData();
await this.initializeNativeClient(config);
steps.nativeClientInit = true;
steps.verification = await this.verifyMigration();
const success = steps.initialization &&
steps.cryptoMigration.success &&
steps.eventMigration.success &&
steps.nativeClientInit &&
steps.verification.success;
return { success, steps };
}
catch (error) {
console.error('Phase 1 migration failed:', error);
return { success: false, steps };
}
}
}
exports.MatrixMigrationHelper = MatrixMigrationHelper;
class HybridMatrixClient {
constructor(jsClient) {
Object.defineProperty(this, "nativeClient", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "jsClient", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "migrationHelper", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "useNativeForCrypto", {
enumerable: true,
configurable: true,
writable: true,
value: false
});
Object.defineProperty(this, "useNativeForEvents", {
enumerable: true,
configurable: true,
writable: true,
value: false
});
this.jsClient = jsClient;
this.nativeClient = new index_1.SayanceMatrixClient();
this.migrationHelper = new MatrixMigrationHelper();
}
async initialize(config, realm, asyncStorage) {
await this.migrationHelper.initialize(realm, asyncStorage);
const migrationStatus = this.migrationHelper.getMigrationStatus();
this.useNativeForCrypto = migrationStatus.cryptoMigrated;
this.useNativeForEvents = migrationStatus.eventsMigrated;
if (this.useNativeForCrypto || this.useNativeForEvents) {
await this.nativeClient.initializeClient(config);
}
}
async sendMessage(roomId, body) {
if (this.useNativeForCrypto) {
const room = this.jsClient.getRoom(roomId);
if (room && room.hasEncryptionStateEvent()) {
return this.nativeClient.sendEncryptedMessage({ roomId, body });
}
}
return this.jsClient.sendMessage({ roomId, body });
}
async getRoomEvents(roomId, limit = 50) {
if (this.useNativeForEvents) {
return this.nativeClient.getRoomEvents(roomId, limit);
}
const room = this.jsClient.getRoom(roomId);
return room ? room.getLiveTimeline().getEvents().slice(-limit) : [];
}
async setupEncryption() {
if (this.useNativeForCrypto) {
return this.nativeClient.setupEncryption();
}
return this.jsClient.initCrypto();
}
async verifyDevice(userId, deviceId) {
if (this.useNativeForCrypto) {
return this.nativeClient.verifyDevice(userId, deviceId);
}
const crypto = this.jsClient.getCrypto();
if (crypto) {
const device = await crypto.getDevice(userId, deviceId);
if (device) {
return device.verify();
}
}
}
getMigrationHelper() {
return this.migrationHelper;
}
enableNativeCrypto() {
this.useNativeForCrypto = true;
}
enableNativeEvents() {
this.useNativeForEvents = true;
}
}
exports.HybridMatrixClient = HybridMatrixClient;
function createMigrationHelper() {
return new MatrixMigrationHelper();
}
function createHybridClient(jsClient) {
return new HybridMatrixClient(jsClient);
}
//# sourceMappingURL=MigrationHelper.js.map