341 lines
11 KiB
TypeScript
341 lines
11 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import {Database, Q} from '@nozbe/watermelondb';
|
|
import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs';
|
|
|
|
import {MM_TABLES} from '@constants/database';
|
|
import DefaultMigration from '@database/default/migration';
|
|
import {App, Global, Servers} from '@database/default/models';
|
|
import {defaultSchema} from '@database/default/schema';
|
|
import ServerMigration from '@database/server/migration';
|
|
import {
|
|
Channel,
|
|
ChannelInfo,
|
|
ChannelMembership,
|
|
CustomEmoji,
|
|
Draft,
|
|
File,
|
|
Group,
|
|
GroupMembership,
|
|
GroupsInChannel,
|
|
GroupsInTeam,
|
|
MyChannel,
|
|
MyChannelSettings,
|
|
MyTeam,
|
|
Post,
|
|
PostMetadata,
|
|
PostsInChannel,
|
|
PostsInThread,
|
|
Preference,
|
|
Reaction,
|
|
Role,
|
|
SlashCommand,
|
|
System,
|
|
Team,
|
|
TeamChannelHistory,
|
|
TeamMembership,
|
|
TeamSearchHistory,
|
|
TermsOfService,
|
|
User,
|
|
} from '@database/server/models';
|
|
import {serverSchema} from '@database/server/schema';
|
|
import logger from '@nozbe/watermelondb/utils/common/logger';
|
|
import type {
|
|
ActiveServerDatabaseArgs,
|
|
DatabaseConnectionArgs,
|
|
DatabaseInstance,
|
|
DatabaseInstances,
|
|
DefaultNewServerArgs,
|
|
Models,
|
|
} from '@typings/database/database';
|
|
import {DatabaseType} from '@typings/database/enums';
|
|
import IServers from '@typings/database/servers';
|
|
|
|
const {SERVERS} = MM_TABLES.DEFAULT;
|
|
|
|
if (__DEV__) {
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
// @ts-ignore
|
|
logger.silence();
|
|
}
|
|
|
|
class DatabaseManager {
|
|
private activeDatabase: DatabaseInstance;
|
|
private defaultDatabase: DatabaseInstance;
|
|
private readonly defaultModels: Models;
|
|
private readonly iOSAppGroupDatabase: string | null;
|
|
private readonly androidFilesDirectory: string | null;
|
|
private readonly serverModels: Models;
|
|
|
|
constructor() {
|
|
this.defaultModels = [App, Global, Servers];
|
|
this.serverModels = [
|
|
Channel,
|
|
ChannelInfo,
|
|
ChannelMembership,
|
|
CustomEmoji,
|
|
Draft,
|
|
File,
|
|
Group,
|
|
GroupMembership,
|
|
GroupsInChannel,
|
|
GroupsInTeam,
|
|
MyChannel,
|
|
MyChannelSettings,
|
|
MyTeam,
|
|
Post,
|
|
PostMetadata,
|
|
PostsInChannel,
|
|
PostsInThread,
|
|
Preference,
|
|
Reaction,
|
|
Role,
|
|
SlashCommand,
|
|
System,
|
|
Team,
|
|
TeamChannelHistory,
|
|
TeamMembership,
|
|
TeamSearchHistory,
|
|
TermsOfService,
|
|
User,
|
|
];
|
|
|
|
this.iOSAppGroupDatabase = null;
|
|
this.androidFilesDirectory = null;
|
|
}
|
|
|
|
/**
|
|
* createDatabaseConnection: Creates database connection and registers the new connection into the default database. However,
|
|
* if a database connection could not be created, it will return undefined.
|
|
* @param {DatabaseConfigs} databaseConnection
|
|
* @param {boolean} shouldAddToDefaultDatabase
|
|
*
|
|
* @returns {Promise<DatabaseInstance>}
|
|
*/
|
|
createDatabaseConnection = async ({configs, shouldAddToDefaultDatabase = true}: DatabaseConnectionArgs): Promise<DatabaseInstance> => {
|
|
const {
|
|
actionsEnabled = true,
|
|
dbName = 'default',
|
|
dbType = DatabaseType.DEFAULT,
|
|
serverUrl = undefined,
|
|
} = configs;
|
|
|
|
try {
|
|
const databaseName = dbType === DatabaseType.DEFAULT ? 'default' : dbName;
|
|
|
|
// const databaseFilePath = this.getDatabaseDirectory(databaseName);
|
|
const migrations = dbType === DatabaseType.DEFAULT ? DefaultMigration : ServerMigration;
|
|
const modelClasses = dbType === DatabaseType.DEFAULT ? this.defaultModels : this.serverModels;
|
|
const schema = dbType === DatabaseType.DEFAULT ? defaultSchema : serverSchema;
|
|
|
|
const adapter = new LokiJSAdapter({
|
|
dbName: databaseName,
|
|
migrations,
|
|
schema,
|
|
useWebWorker: false,
|
|
useIncrementalIndexedDB: true,
|
|
});
|
|
|
|
// Registers the new server connection into the DEFAULT database
|
|
if (serverUrl && shouldAddToDefaultDatabase) {
|
|
await this.addServerToDefaultDatabase({
|
|
databaseFilePath: databaseName,
|
|
displayName: dbName,
|
|
serverUrl,
|
|
});
|
|
}
|
|
return new Database({adapter, actionsEnabled, modelClasses});
|
|
} catch (e) {
|
|
// eslint-disable-next-line no-console
|
|
console.log('ERROR ==========================\n', e);
|
|
}
|
|
|
|
return undefined;
|
|
};
|
|
|
|
/**
|
|
* setActiveServerDatabase: Set the new active server database. The serverUrl is used to ensure that we do not duplicate entries in the default database.
|
|
* This method should be called when switching to another server.
|
|
* @param {string} displayName
|
|
* @param {string} serverUrl
|
|
* @returns {Promise<void>}
|
|
*/
|
|
setActiveServerDatabase = async ({displayName, serverUrl}: ActiveServerDatabaseArgs) => {
|
|
const isServerPresent = await this.isServerPresent(serverUrl);
|
|
|
|
this.activeDatabase = await this.createDatabaseConnection({
|
|
configs: {
|
|
actionsEnabled: true,
|
|
dbName: displayName,
|
|
dbType: DatabaseType.SERVER,
|
|
serverUrl,
|
|
},
|
|
shouldAddToDefaultDatabase: Boolean(!isServerPresent),
|
|
});
|
|
};
|
|
|
|
/**
|
|
* isServerPresent : Confirms if the current serverUrl does not already exist in the database
|
|
* @param {String} serverUrl
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
isServerPresent = async (serverUrl: String) => {
|
|
const allServers = await this.getAllServers();
|
|
const existingServer = allServers?.filter((server) => {
|
|
return server.url === serverUrl;
|
|
});
|
|
return existingServer && existingServer.length > 0;
|
|
};
|
|
|
|
/**
|
|
* getActiveServerDatabase: The DatabaseManager should be the only one setting the active database. Hence, we have made the activeDatabase property private.
|
|
* Use this getter method to retrieve the active database if it has been set in your code.
|
|
* @returns {DatabaseInstance}
|
|
*/
|
|
getActiveServerDatabase = (): DatabaseInstance => {
|
|
return this.activeDatabase;
|
|
};
|
|
|
|
/**
|
|
* getDefaultDatabase : Returns the default database.
|
|
* @returns {Database} default database
|
|
*/
|
|
getDefaultDatabase = async (): Promise<DatabaseInstance> => {
|
|
if (!this.defaultDatabase) {
|
|
await this.setDefaultDatabase();
|
|
}
|
|
return this.defaultDatabase;
|
|
};
|
|
|
|
/**
|
|
* retrieveDatabaseInstances: Using an array of server URLs, this method creates a database connection for each URL
|
|
* and return them to the caller.
|
|
*
|
|
* @param {string[]} serverUrls
|
|
* @returns {Promise<DatabaseInstances[] | null>}
|
|
*/
|
|
retrieveDatabaseInstances = async (serverUrls?: string[]): Promise<DatabaseInstances[] | null> => {
|
|
if (serverUrls?.length) {
|
|
// Retrieve all server records from the default db
|
|
const allServers = await this.getAllServers();
|
|
|
|
// Filter only those servers that are present in the serverUrls array
|
|
const servers = allServers!.filter((server: IServers) => {
|
|
return serverUrls.includes(server.url);
|
|
});
|
|
|
|
// Creates server database instances
|
|
if (servers.length) {
|
|
const databasePromises = servers.map(async (server: IServers) => {
|
|
const {displayName, url} = server;
|
|
|
|
// Since we are retrieving existing URL ( and so database connections ) from the 'DEFAULT' database, shouldAddToDefaultDatabase is set to false
|
|
const dbInstance = await this.createDatabaseConnection({
|
|
configs: {
|
|
actionsEnabled: true,
|
|
dbName: displayName,
|
|
dbType: DatabaseType.SERVER,
|
|
serverUrl: url,
|
|
},
|
|
shouldAddToDefaultDatabase: false,
|
|
});
|
|
|
|
return {url, dbInstance};
|
|
});
|
|
|
|
const databaseInstances = await Promise.all(databasePromises);
|
|
return databaseInstances;
|
|
}
|
|
return null;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* deleteDatabase: Removes the *.db file from the App-Group directory for iOS or the files directory on Android.
|
|
* Also, it removes its entry in the 'servers' table from the DEFAULT database
|
|
* @param {string} serverUrl
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
deleteDatabase = async (serverUrl: string): Promise<boolean> => {
|
|
try {
|
|
const defaultDB = await this.getDefaultDatabase();
|
|
let server: IServers;
|
|
|
|
if (defaultDB) {
|
|
const serversRecords = (await defaultDB.collections.get(SERVERS).query(Q.where('url', serverUrl)).fetch()) as IServers[];
|
|
server = serversRecords?.[0] ?? undefined;
|
|
|
|
if (server) {
|
|
// Perform a delete operation for this server record on the 'servers' table in default database
|
|
await defaultDB.action(async () => {
|
|
await server.destroyPermanently();
|
|
});
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return false;
|
|
} catch (e) {
|
|
// console.log('An error occurred while trying to delete database with name ', databaseName);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* getAllServers : Retrieves all the servers registered in the default database
|
|
* @returns {Promise<undefined | Servers[]>}
|
|
*/
|
|
private getAllServers = async () => {
|
|
// Retrieve all server records from the default db
|
|
const defaultDatabase = await this.getDefaultDatabase();
|
|
const allServers = defaultDatabase && ((await defaultDatabase.collections.get(MM_TABLES.DEFAULT.SERVERS).query().fetch()) as IServers[]);
|
|
return allServers;
|
|
};
|
|
|
|
/**
|
|
* setDefaultDatabase : Sets the default database.
|
|
* @returns {Promise<DatabaseInstance>}
|
|
*/
|
|
private setDefaultDatabase = async (): Promise<DatabaseInstance> => {
|
|
this.defaultDatabase = await this.createDatabaseConnection({
|
|
configs: {dbName: 'default'},
|
|
shouldAddToDefaultDatabase: false,
|
|
});
|
|
|
|
return this.defaultDatabase;
|
|
};
|
|
|
|
/**
|
|
* addServerToDefaultDatabase: Adds a record into the 'default' database - into the 'servers' table - for this new server connection
|
|
* @param {string} databaseFilePath
|
|
* @param {string} displayName
|
|
* @param {string} serverUrl
|
|
* @returns {Promise<void>}
|
|
*/
|
|
private addServerToDefaultDatabase = async ({databaseFilePath, displayName, serverUrl}: DefaultNewServerArgs) => {
|
|
try {
|
|
const defaultDatabase = await this.getDefaultDatabase();
|
|
const isServerPresent = await this.isServerPresent(serverUrl);
|
|
|
|
if (defaultDatabase && !isServerPresent) {
|
|
await defaultDatabase.action(async () => {
|
|
const serversCollection = defaultDatabase.collections.get('servers');
|
|
await serversCollection.create((server: IServers) => {
|
|
server.dbPath = databaseFilePath;
|
|
server.displayName = displayName;
|
|
server.mentionCount = 0;
|
|
server.unreadCount = 0;
|
|
server.url = serverUrl;
|
|
});
|
|
});
|
|
}
|
|
} catch (e) {
|
|
// console.log({catchError: e});
|
|
}
|
|
};
|
|
}
|
|
|
|
export default new DatabaseManager();
|