fontastic 0.1.3 → 0.2.0

package/app/core/ConfigManager.ts

@@ -1,137 +1,150 @@
-import SystemManager from './SystemManager';
-import { database } from '../config/database';
-import { StorageType } from '../enums/StorageType';
-
-const Store = require('electron-store');
-const store = new Store();
-
-export default class ConfigManager {
-
-  systemManager: SystemManager;
-
-  constructor(systemManager: SystemManager) {
-    this.systemManager = systemManager;
-  }
-
-  set(key: string, value: any): void {
-    store.set(key, value);
-  }
-
-  get(key: string = null): any {
-    if (key) {
-      return store.get(key);
-    }
-    return store.store;
-  }
-
-  has(key: string): boolean {
-    return store.has(key);
-  }
-
-  delete(key: string): any {
-    return store.delete(key);
-  }
-
-  clear(): any {
-    return store.clear();
-  }
-
-  toArray(): any {
-    return store.store;
-  }
-
-  initialize(): void {
-    this.initDatabaseConfig();
-    this.initSettingsConfig();
-  }
-
-  initSettingsConfig(): void {
-    const settings = {
-      import: {
-        type: 'ask'
-      }
-    };
-    if (this.has(StorageType.Options)) {
-      const saved = this.get(StorageType.Options);
-      this.set(StorageType.Options, { ...settings, ...saved });
-    } else {
-      this.set(StorageType.Options, settings);
-    }
-  }
-
-  initDatabaseConfig(): void {
-    let store = this.get(StorageType.Database);
-
-    // @TODO Remove MySQL connection if not in production.
-    // Problematic when switching between production and development. Problem arises when connection is not enabled.
-    // database.connections = this.systemManager.isProduction() ? database.connections.filter((item: any) => item.name === 'default') : database.connections;
-
-    // Assign user data path to default database.
-    database.connections = database.connections.filter((item: any) => {
-      if (item.name === 'default' && item.type === 'sqlite') {
-        item.database = this.systemManager.getDatabasePath(item.database);
-      }
-      return item;
-    })
-
-    if (!store) {
-      this.set(StorageType.Database, database);
-    } else {
-      // Resets database.
-      //this.set(StorageType.Database, database);
-    }
-  }
-
-  createDbConnection(options: any): void {
-    if (options.name === 'default') {
-      return;
-    }
-
-    let connections = this.get(StorageType.Database).connections;
-
-    const found = connections.find((item: any) => item.name === options.name);
-
-    if (found) {
-      for (const i in connections) {
-        if (connections[i].name == options.name) {
-          connections[i] = options;
-        }
-      }
-      this.set(StorageType.DatabaseConnections, connections);
-    } else {
-      this.set(StorageType.DatabaseConnections, connections.push(options));
-    }
-  }
-
-  enableDbConnection(options: any): void {
-    let config = this.get(StorageType.Database);
-
-    config.connections = config.connections.filter((item: any) => {
-      item.enabled = (item.name === options.name) ? true : false;
-      return item;
-    })
-
-    this.set(StorageType.Database, config);
-
-    return config;
-  }
-
-  deleteDbConnection(options: any): void {
-    if (options.name === 'default') {
-      return;
-    }
-
-    let connections = this.get(StorageType.Database).connections;
-
-    const found = connections.find((item: any) => item.name === options.name);
-
-    if (found) {
-      for (const i in connections) {
-        if (connections[i].name == options.name) {
-          connections.splice(i, 1);
-        }
-      }
-      this.set(StorageType.DatabaseConnections, connections);
-    }
-  }
-}
+import SystemManager from './SystemManager';
+import { database } from '../config/database';
+import { StorageType } from '../enums/StorageType';
+
+const Store = require('electron-store');
+const store = new Store();
+
+export default class ConfigManager {
+  systemManager: SystemManager;
+
+  constructor(systemManager: SystemManager) {
+    this.systemManager = systemManager;
+  }
+
+  set(key: string, value: any): void {
+    store.set(key, value);
+  }
+
+  get(key: string = null): any {
+    if (key) {
+      return store.get(key);
+    }
+    return store.store;
+  }
+
+  has(key: string): boolean {
+    return store.has(key);
+  }
+
+  delete(key: string): any {
+    return store.delete(key);
+  }
+
+  clear(): any {
+    return store.clear();
+  }
+
+  toArray(): any {
+    return store.store;
+  }
+
+  initialize(): void {
+    this.initDatabaseConfig();
+    this.initSettingsConfig();
+  }
+
+  initSettingsConfig(): void {
+    const settings = {
+      import: {
+        type: 'ask',
+      },
+    };
+    if (this.has(StorageType.Options)) {
+      const saved = this.get(StorageType.Options);
+      this.set(StorageType.Options, { ...settings, ...saved });
+    } else {
+      this.set(StorageType.Options, settings);
+    }
+  }
+
+  initDatabaseConfig(): void {
+    let store = this.get(StorageType.Database);
+
+    // @TODO Remove MySQL connection if not in production.
+    // Problematic when switching between production and development. Problem arises when connection is not enabled.
+    // database.connections = this.systemManager.isProduction() ? database.connections.filter((item: any) => item.name === 'default') : database.connections;
+
+    // Assign user data path to default database.
+    database.connections = database.connections.filter((item: any) => {
+      if (item.name === 'default' && item.type === 'better-sqlite3') {
+        item.database = this.systemManager.getDatabasePath(item.database);
+      }
+      return item;
+    });
+
+    if (!store) {
+      this.set(StorageType.Database, database);
+    } else {
+      // Ensure the default SQLite connection exists and has the correct path.
+      const connections = store.connections || [];
+      const defaultConn = connections.find((item: any) => item.name === 'default' && item.type === 'better-sqlite3');
+      if (defaultConn) {
+        defaultConn.database = this.systemManager.getDatabasePath('fontastic.sqlite');
+      } else {
+        connections.unshift(database.connections.find((item: any) => item.name === 'default'));
+      }
+      // Ensure at least the default SQLite connection is enabled.
+      const hasEnabled = connections.some((item: any) => item.enabled);
+      if (!hasEnabled) {
+        const sqliteConn = connections.find((item: any) => item.name === 'default' && item.type === 'better-sqlite3');
+        if (sqliteConn) sqliteConn.enabled = true;
+      }
+      store.connections = connections;
+      this.set(StorageType.Database, store);
+    }
+  }
+
+  createDbConnection(options: any): void {
+    if (options.name === 'default') {
+      return;
+    }
+
+    let connections = this.get(StorageType.Database).connections;
+
+    const found = connections.find((item: any) => item.name === options.name);
+
+    if (found) {
+      for (const i in connections) {
+        if (connections[i].name == options.name) {
+          connections[i] = options;
+        }
+      }
+      this.set(StorageType.DatabaseConnections, connections);
+    } else {
+      this.set(StorageType.DatabaseConnections, connections.push(options));
+    }
+  }
+
+  enableDbConnection(options: any): void {
+    let config = this.get(StorageType.Database);
+
+    config.connections = config.connections.filter((item: any) => {
+      item.enabled = item.name === options.name ? true : false;
+      return item;
+    });
+
+    this.set(StorageType.Database, config);
+
+    return config;
+  }
+
+  deleteDbConnection(options: any): void {
+    if (options.name === 'default') {
+      return;
+    }
+
+    let connections = this.get(StorageType.Database).connections;
+
+    const found = connections.find((item: any) => item.name === options.name);
+
+    if (found) {
+      for (const i in connections) {
+        if (connections[i].name == options.name) {
+          connections.splice(i, 1);
+        }
+      }
+      this.set(StorageType.DatabaseConnections, connections);
+    }
+  }
+}

package/app/core/ConnectionManager.js

@@ -1,83 +1,94 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const typeorm_1 = require("typeorm");
-const entity_1 = require("../database/entity");
-const repository_1 = require("../database/repository");
-const StorageType_1 = require("../enums/StorageType");
-class ConnectionManager {
-    constructor(configManager) {
-        this.schemas = [entity_1.Collection, entity_1.Store, entity_1.Logger];
-        this.subscribers = [];
-        this.migrations = [];
-        this.omitables = ['title', 'description', 'enabled'];
-        this.configManager = configManager;
-        this.options = this.normalize(this.configManager.get(StorageType_1.StorageType.DatabaseConnections));
-        this.registerEntities(this.options);
-        this.registerSubscribers(this.options);
-        this.registerMigrations(this.options);
-        this.dataSource = new typeorm_1.DataSource(this.options[0]);
-    }
-    initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.dataSource.initialize();
-        });
-    }
-    isInitialized() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.dataSource.isInitialized;
-        });
-    }
-    getDataSource() {
-        return this.dataSource;
-    }
-    createDataSource(options) {
-        return new typeorm_1.DataSource(this.discardOmitables(options)).initialize();
-    }
-    registerEntities(options) {
-        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { entities: this.schemas })));
-    }
-    registerSubscribers(options) {
-        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { subscribers: this.subscribers })));
-    }
-    registerMigrations(options) {
-        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { migrations: this.migrations })));
-    }
-    discardOmitables(options) {
-        return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
-    }
-    normalize(options) {
-        return options.filter((item) => this.discardOmitables(item)).filter((item) => item.enabled);
-    }
-    /**
-     * Proxy methods
-     */
-    getCollection() {
-        return this.dataSource.getRepository(entity_1.Collection);
-    }
-    getLogger() {
-        return this.dataSource.getRepository(entity_1.Logger);
-    }
-    getStore() {
-        return this.dataSource.getRepository(entity_1.Store);
-    }
-    getCollectionRepository() {
-        return this.getCollection().extend(repository_1.CollectionRepository);
-    }
-    getLoggerRepository() {
-        return this.getLogger().extend(repository_1.LoggerRepository);
-    }
-    getStoreRepository() {
-        return this.getStore().extend(repository_1.StoreRepository);
-    }
-}
-exports.default = ConnectionManager;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const entity_1 = require("../database/entity");
+const repository_1 = require("../database/repository");
+const StorageType_1 = require("../enums/StorageType");
+class ConnectionManager {
+    constructor(configManager) {
+        this.schemas = [entity_1.Collection, entity_1.Store, entity_1.Logger];
+        this.subscribers = [];
+        this.migrations = [];
+        this.omitables = ['title', 'description', 'enabled'];
+        this.configManager = configManager;
+        const allConnections = this.configManager.get(StorageType_1.StorageType.DatabaseConnections) || [];
+        this.options = this.normalize(allConnections);
+        this.registerEntities(this.options);
+        this.registerSubscribers(this.options);
+        this.registerMigrations(this.options);
+        this.dataSource = new typeorm_1.DataSource(this.getDefaultOptions(allConnections));
+    }
+    getDefaultOptions(allConnections) {
+        // Prefer sqlite from enabled options, then from all connections as fallback.
+        const fromEnabled = this.options.find((item) => item.type === 'better-sqlite3');
+        if (fromEnabled)
+            return this.discardOmitables(fromEnabled);
+        const fromAll = allConnections.find((item) => item.type === 'better-sqlite3');
+        if (fromAll)
+            return this.discardOmitables(Object.assign(Object.assign({}, fromAll), { entities: this.schemas, subscribers: this.subscribers, migrations: this.migrations }));
+        return this.discardOmitables(this.options[0]);
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataSource.initialize();
+        });
+    }
+    isInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dataSource.isInitialized;
+        });
+    }
+    getDataSource() {
+        return this.dataSource;
+    }
+    createDataSource(options) {
+        return new typeorm_1.DataSource(this.discardOmitables(options)).initialize();
+    }
+    registerEntities(options) {
+        this.options = options.map((obj) => (Object.assign(Object.assign({}, obj), { entities: this.schemas })));
+    }
+    registerSubscribers(options) {
+        this.options = options.map((obj) => (Object.assign(Object.assign({}, obj), { subscribers: this.subscribers })));
+    }
+    registerMigrations(options) {
+        this.options = options.map((obj) => (Object.assign(Object.assign({}, obj), { migrations: this.migrations })));
+    }
+    discardOmitables(options) {
+        return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
+    }
+    normalize(options) {
+        return options.filter((item) => this.discardOmitables(item)).filter((item) => item.enabled);
+    }
+    /**
+     * Proxy methods
+     */
+    getCollection() {
+        return this.dataSource.getRepository(entity_1.Collection);
+    }
+    getLogger() {
+        return this.dataSource.getRepository(entity_1.Logger);
+    }
+    getStore() {
+        return this.dataSource.getRepository(entity_1.Store);
+    }
+    getCollectionRepository() {
+        return this.getCollection().extend(repository_1.CollectionRepository);
+    }
+    getLoggerRepository() {
+        return this.getLogger().extend(repository_1.LoggerRepository);
+    }
+    getStoreRepository() {
+        return this.getStore().extend(repository_1.StoreRepository);
+    }
+}
+exports.default = ConnectionManager;
 //# sourceMappingURL=ConnectionManager.js.map