Merge pull request #8 from Rubenennj/master

Added typings and some code cleanup and improvements

Author: avonrylew

lib/index.ts

@@ -9,20 +9,20 @@ import { Events } from './typings/types/Events';
 import { DEFAULT_TABLE } from './util/constants';
 import { methods } from './methods/exportMethods';
 import { findTables } from './functions/findTables';
+import { Data } from './typings/types/Data';
+import { sanitize } from './functions/sanitize';
 
-export class ByteDatabase extends EventEmitter<Events> {
- public _raw: TypeDatabase;
- public options: DefaultByteProperties;
+export class ByteDatabase<T extends Data = Data> extends EventEmitter<Events> {
+ public readonly _raw: TypeDatabase;
 
  constructor(
- path: string,
- options: DefaultByteProperties = {
+ path = ':memory:',
+ public readonly options: DefaultByteProperties = {
  sanitize: true,
  },
  ) {
  super();
 
- path ??= ":memory:"
  this.options = options;
  this._raw = new Database(path, options);
  this._raw
@@ -32,20 +32,24 @@ export class ByteDatabase extends EventEmitter<Events> {
  .run();
  }
 
- public findTables() {
+ private trySanitize(what: string) {
+ return this.options.sanitize ? sanitize(what) : what
+ }
+
+ public findTables(): any[] {
  return findTables(this);
  }
 
- public insert(key: string, val: any, table: string = DEFAULT_TABLE) {
+ public insert(key: string, val: T, table: string = DEFAULT_TABLE): Database.RunResult {
  return methods.insert(key, val, table, this);
  }
 
- public find(key: string, table: string = DEFAULT_TABLE) {
+ public find(key: string, table: string = DEFAULT_TABLE): T {
  return methods.find(key, table, this);
  }
 
- public all(table: string = DEFAULT_TABLE) {
- return methods.all(table, this);
+ public all(table: string = DEFAULT_TABLE): T[] {
+ return methods.all(table, this) as T[];
  }
 
  public wipe(table: string = DEFAULT_TABLE) {

lib/methods/exportMethods.ts

@@ -5,9 +5,9 @@ import { wipe } from './wipe';
 import { del } from './delete';
 
 export const methods = {
- insert: insert,
- find: find,
- all: all,
- wipe: wipe,
- delete: del,
-};
+ insert,
+ all,
+ wipe,
+ find,
+ delete: del
+} as const;

lib/methods/insert.ts

@@ -3,6 +3,7 @@ import { ByteError } from '../structures/ByteError';
 import { DEFAULT_TABLE } from '../util/constants';
 import { set } from 'lodash';
 import { RowManager } from '../structures/RowManager';
+import { Data } from '../typings/types/Data';
 
 export function insert(
  key: string,
@@ -26,14 +27,14 @@ export function insert(
  if (key.includes('.')) {
  let splitted = key.split('.');
  let ParentKey = splitted[0];
- let got = db.find(ParentKey);
+ let got = db.find(ParentKey) as object;
  let _ = set(got ?? {}, splitted.slice(1).join('.'), value);
 
- return _rows.insertRowByKey(ParentKey, _, table);
+ return _rows.insertRowByKey(ParentKey, _ as Data, table);
  } else {
- let got = db.find(key);
+ let got = db.find(key) as object;
  let _ = set(got ?? {}, key, value);
 
- return _rows.insertRowByKey(key, _, table);
+ return _rows.insertRowByKey(key, _ as Data, table);
  }
 }

lib/structures/RowManager.ts

@@ -1,9 +1,8 @@
 import { ByteDatabase } from '../index';
-import { sanitize } from '../functions/sanitize';
 import { DEFAULT_TABLE } from '../util/constants';
 
 export class RowManager {
- _database: ByteDatabase;
+ private readonly _database: ByteDatabase;
 
  constructor(db: ByteDatabase) {
  this._database = db;
@@ -15,7 +14,7 @@ export class RowManager {
  table: string = DEFAULT_TABLE,
  ) {
  value = value !== 'string' ? JSON.stringify(value) : value;
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  return this._database._raw
  .prepare(`INSERT INTO ${table} (ID,Json) VALUES (?,?)`)
  .run(key, value);
@@ -27,22 +26,26 @@ export class RowManager {
  table: string = DEFAULT_TABLE,
  ) {
  value = value !== 'string' ? JSON.stringify(value) : value;
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  return this._database._raw
  .prepare(`UPDATE ${table} SET Json = (?) WHERE ID = (?)`)
  .run(key, value);
  }
 
+ private trySanitize(...args: Parameters<ByteDatabase["trySanitize"]>) {
+ return this._database["trySanitize"](...args)
+ }
+
  findRowByKey(key: string, table: string = DEFAULT_TABLE) {
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  const val = this._database._raw
  .prepare(`SELECT Json FROM ${table} WHERE ID = @key`)
  .get({ key });
  return val != null ? JSON.parse(val.Json) : null;
  }
 
  findAllRows(table: string = DEFAULT_TABLE) {
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  const val = this._database._raw.prepare(`SELECT * FROM ${table}`).iterate();
  const data: object[] = [];
  for (const i of val) {
@@ -57,12 +60,12 @@ export class RowManager {
  }
 
  deleteAllRows(table: string = DEFAULT_TABLE) {
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  return this._database._raw.prepare(`DELETE FROM ${table}`).run();
  }
 
  deleteRowByKey(key: string, table: string = DEFAULT_TABLE) {
- table = this._database.options.sanitize ? sanitize(table) : table;
+ table = this.trySanitize(table)
  return this._database._raw
  .prepare(`DELETE FROM ${table} WHERE ID = @key`)
  .run({ key });

lib/structures/Table.ts

@@ -3,8 +3,8 @@ import { CREATE_TABLE_REGEX } from '../util/constants';
 import { ByteError } from './ByteError';
 
 export class Table {
- private _database: ByteDatabase;
- private _tableName: string;
+ private readonly _database: ByteDatabase;
+ private readonly _tableName: string;
 
  constructor(name: string, db: ByteDatabase) {
  this._database = db;

lib/typings/types/Data.ts

@@ -0,0 +1,3 @@
+export type Data = {
+ [key: PropertyKey]: unknown
+} | string | unknown[]

lib/typings/types/ToRecord.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts an interface to a typed record
+ */
+export type ToRecord<T> = {
+ [P in keyof T]: T[P]
+}