Fixing many typing issues

Author: acrodrig

src/db.ts

@@ -1,7 +1,7 @@
 import { blue, bold, white } from "@std/fmt/colors";
-import { ConsoleHandler, getLogger, LevelName } from "@std/log";
+import { ConsoleHandler, getLogger, type LevelName, type Logger } from "@std/log";
 import { DDL } from "./ddl.ts";
-import { Class, Identifiable, Parameter, Row, Schema } from "./types.ts";
+import type { Class, Identifiable, Parameter, Row, Schema } from "./types.ts";
 import { Repository } from "./repository.ts";
 
 const TTY = Deno.stderr.isTerminal();
@@ -161,16 +161,16 @@ export class DB {
   static readonly ALL = Number.MAX_SAFE_INTEGER;
   static client: Client;
   static debug = false;
-  static schemas = new Map<string, Schema>();
+  static #schemas = new Map<string, Schema>();
   static type: string;
   static capacity = this.DEFAULT_CAPACITY;
 
-  static get logger() {
+  static get logger(): Logger {
     return this.mainLogger();
   }
 
   // Get parent logger and if the logger has not been set, it will add a handler and level
-  static mainLogger(level: LevelName = "INFO") {
+  static mainLogger(level: LevelName = "INFO"): Logger {
     const logger = getLogger("gateways");
     if (logger.handlers.length === 0) logger.handlers.push(new ConsoleHandler("DEBUG"));
     const debug = Deno.env.get("DEBUG")?.includes(logger.loggerName) || this.debug;
@@ -190,8 +190,8 @@ export class DB {
 
     // Iterate over the schemas and map them by name and type if it exists
     schemas?.forEach((s) => {
-      DB.schemas.set(s.name, s);
-      if (s.type) DB.schemas.set(s.type, s);
+      DB.#schemas.set(s.name, s);
+      if (s.type) DB.#schemas.set(s.type, s);
     });
     if (DB.client) return Promise.resolve(DB.client);
     DB.type = config.type;
@@ -251,7 +251,7 @@ export class DB {
     }
   }
 
-  static execute(sql: string, parameters?: Parameter[] | { [key: string]: Parameter }, debug?: boolean) {
+  static execute(sql: string, parameters?: Parameter[] | { [key: string]: Parameter }, debug?: boolean): Promise<{ affectedRows?: number; lastInsertId?: number }> {
     // If values are not an array, they need to be transformed (as well as the SQL)
     const arrayParameters: Parameter[] = [];
     if (parameters && !Array.isArray(parameters)) {
@@ -285,21 +285,21 @@ export class DB {
   }
 
   // Repository cache
-  static repositories = new Map<string | Class<Identifiable>, Repository<Identifiable>>();
+  static #repositories = new Map<string | Class<Identifiable>, Repository<Identifiable>>();
 
   // deno-lint-ignore no-explicit-any
   static getRepository(tableName: string): Repository<any>;
   static getRepository<T extends Identifiable>(target: Class<T>): Repository<T>;
   static getRepository<T extends Identifiable>(target: string | Class<T>, schema?: Schema): Repository<T> {
-    let repository = this.repositories.get(target) as Repository<T>;
+    let repository = this.#repositories.get(target) as Repository<T>;
     if (repository) return repository;
 
     // Figure out target, schema and name
     const name = typeof target === "string" ? target : target.name;
     if (typeof target === "string") target = Object as unknown as Class<T>;
-    if (!schema) schema = DB.schemas.get(name);
+    if (!schema) schema = DB.#schemas.get(name);
     repository = new Repository(target, schema, schema?.name ?? name, this.capacity);
-    this.repositories.set(target, repository as Repository<Identifiable>);
+    this.#repositories.set(target, repository as Repository<Identifiable>);
 
     // Return repository
     return repository;

src/ddl.ts

@@ -1,4 +1,4 @@
-import { Column, Constraint, Index, Relation, Schema } from "./types.ts";
+import type { Column, Constraint, Index, Relation, Schema } from "./types.ts";
 import DB from "./db.ts";
 
 const dataTypes = {
@@ -161,14 +161,14 @@ export class DDL {
     if (fullTextColumns.length) sql += this.createFullTextIndex(dbType, fullTextColumns, 0, table);
 
     const fixDanglingComma = (sql: string) => sql.replace(/,\n\)/, "\n);");
-    if (dbType === DB.Provider.POSTGRES) sql = this.postgres(sql);
+    if (dbType === DB.Provider.POSTGRES) sql = this.#postgres(sql);
     sql = fixDanglingComma(sql);
 
     return sql;
   }
 
   // Function to accommodate the differences between MySQL and Postgres
-  static postgres(sql: string) {
+  static #postgres(sql: string) {
     return sql.replace(/\w+/g, (m: string) => {
       if (m === "DATETIME") return "TIMESTAMP";
       if (m === "JSON_EXTRACT") return "JSONB_EXTRACT_PATH";

src/repository.ts

@@ -1,6 +1,6 @@
 import { assert } from "@std/assert";
 import { DB } from "./db.ts";
-import { Class, Condition, Filter, Identifiable, Order, Primitive, Schema, Where } from "./types.ts";
+import type { Class, Condition, Filter, Identifiable, Order, Primitive, Schema, Where } from "./types.ts";
 
 // Import direct version so that version plays well with other modules
 // TODO: Port mnemonist to deno land?

test/basic.test.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S deno test -A
 
 import { assert, assertEquals, assertExists } from "@std/assert";
-import { Schema } from "../src/types.ts";
+import type { Schema } from "../src/types.ts";
 import { dbInit, getProvider } from "./helpers.ts";
 import AccountModel from "../resources/account.ts";
 import AccountSchema from "../resources/account.json" with { type: "json" };

test/ddl.test.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env -S deno test -A --no-check
 
 import { assertEquals } from "@std/assert";
-import { Schema } from "../src/types.ts";
 import { DDL } from "../src/ddl.ts";
+import type { Schema } from "../src/types.ts";
 import { createTables, dbInit, getProvider } from "./helpers.ts";
 import AccountSchema from "../resources/account.json" with { type: "json" };
 

test/helpers.ts

@@ -1,7 +1,7 @@
 import { ConsoleHandler, setup } from "@std/log";
 import { DB } from "../src/db.ts";
 import { DDL } from "../src/ddl.ts";
-import { Schema } from "../src/types.ts";
+import type { Schema } from "../src/types.ts";
 
 const PROVIDER = Deno.env.get("TEST_PROVIDER") ?? Deno.args[0];
 if (!PROVIDER) console.warn("\n⚠️  Assuming SQLITE provider. You can use 'TEST_PROVIDER=<provider>' or '-- <provider>' (mysql, mysql2, postgres, sqlite)\n");

test/schema.test.ts

@@ -1,11 +1,9 @@
 #!/usr/bin/env -S deno test -A --check
 
-import { JSONSchema7 } from "schema";
+import type { JSONSchema7 } from "schema";
 import AccountSchema from "../resources/account.json" with { type: "json" };
 
-const test = Deno.test;
-
-test("Schema Types are proper JSON Schema", function () {
+Deno.test("Schema Types are proper JSON Schema", function () {
   // Validate that property is a JSON Schema
   const _schema = AccountSchema as JSONSchema7;