fontastic 0.1.7 → 0.2.0

package/app/core/ConnectionManager.ts

@@ -1,95 +1,107 @@
-import { DataSource, DataSourceOptions } from 'typeorm'
-import { Collection, Store, Logger } from '../database/entity';
-import { CollectionRepository, LoggerRepository, StoreRepository } from '../database/repository';
-import ConfigManager from './ConfigManager';
-import { StorageType } from '../enums/StorageType';
-
-export default class ConnectionManager {
-
-  configManager: ConfigManager;
-  options: DataSourceOptions[];
-  
-  dataSource: DataSource;
-
-  schemas: any[] = [Collection, Store, Logger];
-  subscribers: any[] = []
-  migrations: any[] = [];
-
-  omitables: any[] = ['title', 'description', 'enabled'];
-
-  constructor(configManager: ConfigManager) {
-    this.configManager = configManager;
-
-    this.options = this.normalize(this.configManager.get(StorageType.DatabaseConnections));
-
-    this.registerEntities(this.options);
-    this.registerSubscribers(this.options);
-    this.registerMigrations(this.options);
-
-    this.dataSource = new DataSource(this.options[0]);
-  }
-
-  async initialize() {
-    return await this.dataSource.initialize();
-  }
-
-  async isInitialized() {
-    return this.dataSource.isInitialized;
-  }
-
-  getDataSource(): DataSource {
-    return this.dataSource;
-  }
-
-  createDataSource(options: DataSourceOptions) {
-    return new DataSource(this.discardOmitables(options)).initialize()
-  }
-
-  registerEntities(options: DataSourceOptions[]) {
-    this.options = options.map(obj => ({ ...obj, entities: this.schemas }))
-  }
-
-  registerSubscribers(options: DataSourceOptions[]) {
-    this.options = options.map(obj => ({ ...obj, subscribers: this.subscribers }))
-  }
-
-  registerMigrations(options: DataSourceOptions[]) {
-    this.options = options.map(obj => ({ ...obj, migrations: this.migrations }))
-  }
-
-  discardOmitables(options: object | any): object | any {
-    return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
-  }
-
-  normalize(options: DataSourceOptions[]) {
-    return options.filter((item: DataSourceOptions) => this.discardOmitables(item)).filter((item: any) => item.enabled)
-  }
-
-  /**
-   * Proxy methods 
-   */
-
-  getCollection() {
-    return this.dataSource.getRepository(Collection)
-  }
-
-  getLogger() {
-    return this.dataSource.getRepository(Logger)
-  }
-
-  getStore() {
-    return this.dataSource.getRepository(Store)
-  }
-
-  getCollectionRepository() {
-    return this.getCollection().extend(CollectionRepository);
-  }
-
-  getLoggerRepository() {
-    return this.getLogger().extend(LoggerRepository);
-  }
-
-  getStoreRepository() {
-    return this.getStore().extend(StoreRepository);
-  }
-}
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { Collection, Store, Logger } from '../database/entity';
+import { CollectionRepository, LoggerRepository, StoreRepository } from '../database/repository';
+import ConfigManager from './ConfigManager';
+import { StorageType } from '../enums/StorageType';
+
+export default class ConnectionManager {
+  configManager: ConfigManager;
+  options: DataSourceOptions[];
+
+  dataSource: DataSource;
+
+  schemas: any[] = [Collection, Store, Logger];
+  subscribers: any[] = [];
+  migrations: any[] = [];
+
+  omitables: any[] = ['title', 'description', 'enabled'];
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+
+    const allConnections: DataSourceOptions[] = this.configManager.get(StorageType.DatabaseConnections) || [];
+    this.options = this.normalize(allConnections);
+
+    this.registerEntities(this.options);
+    this.registerSubscribers(this.options);
+    this.registerMigrations(this.options);
+
+    this.dataSource = new DataSource(this.getDefaultOptions(allConnections));
+  }
+
+  getDefaultOptions(allConnections: DataSourceOptions[]): DataSourceOptions {
+    // Prefer sqlite from enabled options, then from all connections as fallback.
+    const fromEnabled = this.options.find((item: any) => item.type === 'better-sqlite3');
+    if (fromEnabled) return this.discardOmitables(fromEnabled);
+
+    const fromAll = allConnections.find((item: any) => item.type === 'better-sqlite3');
+    if (fromAll)
+      return this.discardOmitables({ ...fromAll, entities: this.schemas, subscribers: this.subscribers, migrations: this.migrations });
+
+    return this.discardOmitables(this.options[0]);
+  }
+
+  async initialize() {
+    return await this.dataSource.initialize();
+  }
+
+  async isInitialized() {
+    return this.dataSource.isInitialized;
+  }
+
+  getDataSource(): DataSource {
+    return this.dataSource;
+  }
+
+  createDataSource(options: DataSourceOptions) {
+    return new DataSource(this.discardOmitables(options)).initialize();
+  }
+
+  registerEntities(options: DataSourceOptions[]) {
+    this.options = options.map((obj) => ({ ...obj, entities: this.schemas }));
+  }
+
+  registerSubscribers(options: DataSourceOptions[]) {
+    this.options = options.map((obj) => ({ ...obj, subscribers: this.subscribers }));
+  }
+
+  registerMigrations(options: DataSourceOptions[]) {
+    this.options = options.map((obj) => ({ ...obj, migrations: this.migrations }));
+  }
+
+  discardOmitables(options: object | any): object | any {
+    return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
+  }
+
+  normalize(options: DataSourceOptions[]) {
+    return options.filter((item: DataSourceOptions) => this.discardOmitables(item)).filter((item: any) => item.enabled);
+  }
+
+  /**
+   * Proxy methods
+   */
+
+  getCollection() {
+    return this.dataSource.getRepository(Collection);
+  }
+
+  getLogger() {
+    return this.dataSource.getRepository(Logger);
+  }
+
+  getStore() {
+    return this.dataSource.getRepository(Store);
+  }
+
+  getCollectionRepository() {
+    return this.getCollection().extend(CollectionRepository);
+  }
+
+  getLoggerRepository() {
+    return this.getLogger().extend(LoggerRepository);
+  }
+
+  getStoreRepository() {
+    return this.getStore().extend(StoreRepository);
+  }
+}

package/app/core/FontCatalog.js

@@ -1,51 +1,33 @@
-"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 fs = require("fs/promises");
-const path = require('path');
-const exec = require('child_process').exec;
-const child = require('child_process').execFile;
-class FontCatalog {
-    constructor(systemManager) {
-        this.systemManager = systemManager;
-    }
-    createCatalog(folder) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield fs.mkdir(folder, { recursive: true });
-        });
-    }
-    commandHelp(done) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield child(this.systemManager.getExecutable(), ['-h'], done);
-        });
-    }
-    findFonts(src, done) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield child(this.systemManager.getExecutable(), ['fonts', 'find', '--root', src], done);
-        });
-    }
-    copyFiles(files, dest, done) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cmdPath = this.systemManager.getExecutable();
-            const items = files.map((item) => `"${path.normalize(item)}"`).join(" ");
-            const command = `${cmdPath} copy files --destination "${dest}" ${items}`;
-            return exec(command, done);
-        });
-    }
-    copyFolders(src, dest, done) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = ['copy', 'folders', '--source', src, '--destination', dest];
-            return child(this.systemManager.getExecutable(), params, done);
-        });
-    }
-}
-exports.default = FontCatalog;
+"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 fs = require("fs/promises");
+const path = require("path");
+class FontCatalog {
+    createCatalog(folder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield fs.mkdir(folder, { recursive: true });
+        });
+    }
+    copyFiles(files, dest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createCatalog(dest);
+            yield Promise.all(files.map(file => fs.copyFile(file, path.join(dest, path.basename(file)))));
+        });
+    }
+    copyFolder(src, dest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield fs.cp(src, dest, { recursive: true });
+        });
+    }
+}
+exports.default = FontCatalog;
 //# sourceMappingURL=FontCatalog.js.map

package/app/core/FontCatalog.ts

@@ -1,42 +1,20 @@
-import SystemManager from './SystemManager';
-import * as fs from 'fs/promises';
-
-const path = require('path');
-const exec = require('child_process').exec;
-const child = require('child_process').execFile;
-
-export default class FontCatalog {
-
-  systemManager: SystemManager;
-
-  constructor(
-    systemManager: SystemManager,
-  ) {
-    this.systemManager = systemManager;
-  }
-
-  async createCatalog(folder: string): Promise<string> {
-    return await fs.mkdir(folder, { recursive: true });
-  }
-
-  async commandHelp(done: any) {
-    return await child(this.systemManager.getExecutable(), ['-h'], done);
-  }
-
-  async findFonts(src: string, done: any) {
-    return await child(this.systemManager.getExecutable(), ['fonts', 'find', '--root', src], done);
-  }
-
-  async copyFiles(files: any, dest: string, done: any) {
-    const cmdPath = this.systemManager.getExecutable();
-    const items = files.map((item: string) => `"${path.normalize(item)}"`).join(" ");
-    const command = `${cmdPath} copy files --destination "${dest}" ${items}`;
-    return exec(command, done);
-  }
-
-  async copyFolders(src: string, dest: string, done: any) {
-    const params = ['copy', 'folders', '--source', src, '--destination', dest];
-
-    return child(this.systemManager.getExecutable(), params, done);
-  }
-}
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export default class FontCatalog {
+
+  async createCatalog(folder: string): Promise<string> {
+    return await fs.mkdir(folder, { recursive: true });
+  }
+
+  async copyFiles(files: string[], dest: string): Promise<void> {
+    await this.createCatalog(dest);
+    await Promise.all(
+      files.map(file => fs.copyFile(file, path.join(dest, path.basename(file))))
+    );
+  }
+
+  async copyFolder(src: string, dest: string): Promise<void> {
+    await fs.cp(src, dest, { recursive: true });
+  }
+}

package/app/core/FontFinder.js

@@ -1,86 +1,73 @@
-"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 FontObject_1 = require("./FontObject");
-const fs = require("fs");
-const path = require("path");
-const mimes_1 = require("../config/mimes");
-const prettyBytes = require("pretty-bytes");
-const mime = require("mime");
-// https://stackoverflow.com/questions/10049557/reading-all-files-in-a-directory-store-them-in-objects-and-send-the-object
-class FileSystem {
-    constructor(connectionManager) {
-        this.counter = 0;
-        this.errors = [];
-        this.found = [];
-        this.connectionManager = connectionManager;
-        this.counter = 0;
-        this.errors = [];
-    }
-    setCounter(count) {
-        this.counter = count;
-    }
-    getCounter() {
-        return this.counter;
-    }
-    scanFolders(dir, options, done) {
-        fs.readdir(dir, (err, list) => {
-            if (err)
-                return done(err);
-            let i = 0;
-            let next = () => {
-                let file = list[i++];
-                if (!file)
-                    return done(null, this);
-                let fp = path.resolve(dir, file);
-                fs.stat(fp, (err, stat) => __awaiter(this, void 0, void 0, function* () {
-                    if (stat && stat.isDirectory()) {
-                        this.scanFolders(fp, options, (err, res) => next());
-                    }
-                    else {
-                        this.fontInstall(fp, stat, options);
-                        next();
-                    }
-                }));
-            };
-            next();
-        });
-    }
-    scanFiles(files, options, done) {
-        files.forEach((fp) => __awaiter(this, void 0, void 0, function* () {
-            let stat = fs.statSync(fp);
-            if (stat.isFile()) {
-                this.fontInstall(fp, stat, options);
-            }
-        }));
-        return done(null, this);
-    }
-    fontInstall(fp, stat, options) {
-        let font = new FontObject_1.default(fp);
-        if (font.hasError()) {
-            this.errors.push(font.getError());
-        }
-        else {
-            let fileSize = stat.size;
-            let fileType = mime.getType(fp);
-            let data = Object.assign({ file_path: fp, file_name: path.basename(fp), file_size: fileSize, file_size_pretty: prettyBytes(fileSize), file_type: fileType, installable: mimes_1.installable.includes(fileType) }, options);
-            try {
-                this.connectionManager.getStoreRepository().create(Object.assign(Object.assign({}, data), font.getNamesTable()));
-            }
-            catch (err) {
-                this.errors.push(err.message);
-            }
-            this.counter++;
-        }
-    }
-}
-exports.default = FileSystem;
+"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 FontObject_1 = require("./FontObject");
+const fs = require("fs/promises");
+const path = require("path");
+const mimes_1 = require("../config/mimes");
+const prettyBytes = require("pretty-bytes");
+const mime = require("mime");
+class FontFinder {
+    constructor(connectionManager) {
+        this.errors = [];
+        this.counter = 0;
+        this.connectionManager = connectionManager;
+    }
+    isFontFile(filePath) {
+        const fileType = mime.getType(filePath);
+        return fileType && mimes_1.mimeTypes.includes(fileType);
+    }
+    scanFiles(files, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const fp of files) {
+                if (this.isFontFile(fp)) {
+                    const stat = yield fs.stat(fp);
+                    yield this.processFont(fp, stat, options);
+                }
+            }
+        });
+    }
+    scanFolder(dir, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = yield fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fp = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    yield this.scanFolder(fp, options);
+                }
+                else if (this.isFontFile(fp)) {
+                    const stat = yield fs.stat(fp);
+                    yield this.processFont(fp, stat, options);
+                }
+            }
+        });
+    }
+    processFont(fp, stat, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const font = new FontObject_1.default(fp);
+            if (font.hasError()) {
+                this.errors.push(font.getError());
+                return;
+            }
+            const fileType = mime.getType(fp);
+            const data = Object.assign(Object.assign({ file_path: fp, file_name: path.basename(fp), file_size: stat.size, file_size_pretty: prettyBytes(stat.size), file_type: fileType, installable: mimes_1.installable.includes(fileType) }, options), font.getNamesTable());
+            try {
+                yield this.connectionManager.getStoreRepository().create(data);
+                this.counter++;
+            }
+            catch (err) {
+                this.errors.push(err.message);
+            }
+        });
+    }
+}
+exports.default = FontFinder;
 //# sourceMappingURL=FontFinder.js.map