@ghom/orm 1.7.1 → 1.8.0

package/src/app/table.ts

@@ -1,6 +1,12 @@
-import chalk from "chalk"
+import util from "util"
 import { Knex } from "knex"
 import { ORM } from "./orm.js"
+import { ResponseCache } from "./caching.js"
+import {
+  DEFAULT_LOGGER_DESCRIPTION,
+  DEFAULT_LOGGER_HIGHLIGHT,
+  DEFAULT_LOGGER_RAW_VALUE,
+} from "./util.js"
 
 export interface MigrationData {
   table: string
@@ -11,13 +17,25 @@ export interface TableOptions<Type extends object = object> {
   name: string
   description?: string
   priority?: number
+  /**
+   * The cache time in milliseconds. <br>
+   * Default is `Infinity`.
+   */
+  caching?: number
   migrations?: { [version: number]: (table: Knex.CreateTableBuilder) => void }
   then?: (this: Table<Type>, table: Table<Type>) => unknown
   setup: (table: Knex.CreateTableBuilder) => void
 }
 
 export class Table<Type extends object = object> {
-  orm?: ORM
+  public orm?: ORM
+
+  public _whereCache?: ResponseCache<
+    [cb: (query: Table<Type>["query"]) => unknown],
+    unknown
+  >
+
+  public _countCache?: ResponseCache<[where: string | null], Promise<number>>
 
   constructor(public readonly options: TableOptions<Type>) {}
 
@@ -30,6 +48,57 @@ export class Table<Type extends object = object> {
     return this.db<Type>(this.options.name)
   }
 
+  get cache() {
+    if (!this._whereCache || !this._countCache) throw new Error("missing cache")
+
+    if (!this.orm) throw new Error("missing ORM")
+
+    return {
+      get: <Return>(
+        id: string,
+        cb: (
+          table: Pick<
+            Table<Type>["query"],
+            | "select"
+            | "count"
+            | "avg"
+            | "sum"
+            | "countDistinct"
+            | "avgDistinct"
+            | "sumDistinct"
+          >,
+        ) => Return,
+      ): Return => {
+        return this._whereCache!.get(id, cb) as Return
+      },
+      set: <Return>(
+        cb: (
+          table: Pick<
+            Table<Type>["query"],
+            | "update"
+            | "delete"
+            | "insert"
+            | "upsert"
+            | "truncate"
+            | "jsonInsert"
+          >,
+        ) => Return,
+      ) => {
+        // todo: invalidate only the related tables
+        this.orm!.cache.invalidate()
+        return cb(this.query)
+      },
+      count: (where?: string) => {
+        return this._countCache!.get(where ?? "*", where ?? null)
+      },
+      invalidate: () => {
+        this._whereCache!.invalidate()
+        this._countCache!.invalidate()
+        this.orm!._rawCache.invalidate()
+      },
+    }
+  }
+
   async count(where?: string): Promise<number> {
     return this.query
       .select(this.db.raw("count(*) as total"))
@@ -56,21 +125,34 @@ export class Table<Type extends object = object> {
   }
 
   async isEmpty(): Promise<boolean> {
-    return this.count().then((count) => count === 0)
+    return this.count().then((count) => +count === 0)
   }
 
   async make(): Promise<this> {
     if (!this.orm) throw new Error("missing ORM")
 
+    this._whereCache = new ResponseCache(
+      (cb: (query: Knex.QueryBuilder<Type>) => unknown) => cb(this.query),
+      this.options.caching ?? this.orm?.config.caching ?? Infinity,
+    )
+
+    this._countCache = new ResponseCache(
+      (where: string | null) => this.count(where ?? undefined),
+      this.options.caching ?? this.orm?.config.caching ?? Infinity,
+    )
+
     try {
       await this.db.schema.createTable(this.options.name, this.options.setup)
 
       this.orm.config.logger?.log(
-        `created table ${chalk[
-          this.orm.config.loggerColors?.highlight ?? "blueBright"
-        ](this.options.name)}${
+        `created table ${util.styleText(
+          this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT,
+          this.options.name,
+        )}${
           this.options.description
-            ? ` ${chalk[this.orm.config.loggerColors?.description ?? "grey"](
+            ? ` ${util.styleText(
+                this.orm.config.loggerStyles?.description ??
+                  DEFAULT_LOGGER_DESCRIPTION,
                 this.options.description,
               )}`
             : ""
@@ -79,19 +161,23 @@ export class Table<Type extends object = object> {
     } catch (error: any) {
       if (error.toString().includes("syntax error")) {
         this.orm.config.logger?.error(
-          `you need to implement the "setup" method in options of your ${chalk[
-            this.orm.config.loggerColors?.highlight ?? "blueBright"
-          ](this.options.name)} table!`,
+          `you need to implement the "setup" method in options of your ${util.styleText(
+            this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT,
+            this.options.name,
+          )} table!`,
         )
 
         throw error
       } else {
         this.orm.config.logger?.log(
-          `loaded table ${chalk[
-            this.orm.config.loggerColors?.highlight ?? "blueBright"
-          ](this.options.name)}${
+          `loaded table ${util.styleText(
+            this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT,
+            this.options.name,
+          )}${
             this.options.description
-              ? ` ${chalk[this.orm.config.loggerColors?.description ?? "grey"](
+              ? ` ${util.styleText(
+                  this.orm.config.loggerStyles?.description ??
+                    DEFAULT_LOGGER_DESCRIPTION,
                   this.options.description,
                 )}`
               : ""
@@ -105,11 +191,13 @@ export class Table<Type extends object = object> {
 
       if (migrated !== false) {
         this.orm.config.logger?.log(
-          `migrated table ${chalk[
-            this.orm.config.loggerColors?.highlight ?? "blueBright"
-          ](this.options.name)} to version ${chalk[
-            this.orm.config.loggerColors?.rawValue ?? "magentaBright"
-          ](migrated)}`,
+          `migrated table ${util.styleText(
+            this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT,
+            this.options.name,
+          )} to version ${util.styleText(
+            this.orm.config.loggerStyles?.rawValue ?? DEFAULT_LOGGER_RAW_VALUE,
+            String(migrated),
+          )}`,
         )
       }
     } catch (error: any) {

package/src/app/util.ts

@@ -0,0 +1,30 @@
+import util from "util"
+import path from "path"
+import fs from "fs"
+
+export type TextStyle = Parameters<typeof util.styleText>[0]
+
+export const DEFAULT_BACKUP_LOCATION = path.join(process.cwd(), "backup")
+export const DEFAULT_BACKUP_CHUNK_SIZE = 5 * 1024 * 1024 // 5MB
+
+export const DEFAULT_LOGGER_HIGHLIGHT = "blueBright"
+export const DEFAULT_LOGGER_DESCRIPTION = "grey"
+export const DEFAULT_LOGGER_RAW_VALUE = "magentaBright"
+
+let isCJS: boolean = false
+
+try {
+  const pack = JSON.parse(
+    fs.readFileSync(path.join(process.cwd(), "package.json"), "utf8"),
+  )
+
+  isCJS = pack.type === "commonjs" || pack.type == void 0
+} catch {
+  throw new Error(
+    "Missing package.json: Can't detect the type of modules.\n" +
+      "The ORM needs a package.json file present in the process's current working directory.\n" +
+      "Please create a package.json file or run the project from another entry point.",
+  )
+}
+
+export { isCJS }

package/src/index.ts

@@ -1,2 +1,5 @@
 export * from "./app/orm.js"
 export * from "./app/table.js"
+export * from "./app/caching.js"
+export * from "./app/backup.js"
+export * from "./app/util.js"

package/tests/tables/a.js

@@ -1,21 +1,24 @@
-import { Table } from "../.."
-
-export default new Table({
-  name: "a",
-  priority: 0,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-    table
-      .integer("b_id")
-      .references("id")
-      .inTable("b")
-      .onDelete("cascade")
-      .notNullable()
-  },
-  async then({ query }) {
-    await query.insert({
-      id: 0,
-      b_id: 0,
-    })
-  },
-})
+import { Table } from "../.."
+
+/**
+ * @type {Table<{ id: number; b_id: number }>}
+ */
+export default new Table({
+  name: "a",
+  priority: 0,
+  setup(table) {
+    table.increments("id").primary().notNullable()
+    table
+      .integer("b_id")
+      .references("id")
+      .inTable("b")
+      .onDelete("cascade")
+      .notNullable()
+  },
+  async then({ query }) {
+    await query.insert({
+      id: 0,
+      b_id: 0,
+    })
+  },
+})

package/tests/tables/b.js

@@ -1,24 +1,27 @@
-import { Table } from "../.."
-
-export default new Table({
-  name: "b",
-  migrations: {
-    0: (table) =>
-      table
-        .integer("c_id")
-        .references("id")
-        .inTable("c")
-        .onDelete("cascade")
-        .notNullable()
-  },
-  priority: 1,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-  },
-  async then({ query }) {
-    await query.insert({
-      id: 0,
-      c_id: 0,
-    })
-  },
-})
+import { Table } from "../.."
+
+/**
+ * @type {Table<{ id: number; c_id: number }>}
+ */
+export default new Table({
+  name: "b",
+  migrations: {
+    0: (table) =>
+      table
+        .integer("c_id")
+        .references("id")
+        .inTable("c")
+        .onDelete("cascade")
+        .notNullable(),
+  },
+  priority: 1,
+  setup(table) {
+    table.increments("id").primary().notNullable()
+  },
+  async then({ query }) {
+    await query.insert({
+      id: 0,
+      c_id: 0,
+    })
+  },
+})

package/tests/tables/c.js

@@ -1,12 +1,15 @@
-import { Table } from "../.."
-
-export default new Table({
-  name: "c",
-  priority: 2,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-  },
-  async then({ query }) {
-    await query.insert({ id: 0 })
-  },
-})
+import { Table } from "../.."
+
+/**
+ * @type {Table<{ id: number }>}
+ */
+export default new Table({
+  name: "c",
+  priority: 2,
+  setup(table) {
+    table.increments("id").primary().notNullable()
+  },
+  async then({ query }) {
+    await query.insert({ id: 0 })
+  },
+})

package/tests/test.js

@@ -1,4 +1,5 @@
 import dotenv from "dotenv"
+import { rimraf } from "rimraf"
 import path from "path"
 import fs from "fs"
 
@@ -11,7 +12,10 @@ import b from "./tables/b"
 import c from "./tables/c"
 
 const orm = new ORM({
-  location: path.join("tests", "tables"),
+  tableLocation: path.join(process.cwd(), "tests", "tables"),
+  backups: {
+    location: path.join(process.cwd(), "backups"),
+  },
 })
 
 beforeAll(async () => {
@@ -24,7 +28,9 @@ describe("table management", () => {
     expect(await orm.hasTable("a")).toBeTruthy()
     expect(await orm.hasTable("b")).toBeTruthy()
     expect(await orm.hasTable("c")).toBeTruthy()
+  })
 
+  test("table cached", async () => {
     expect(orm.hasCachedTable("migration")).toBeTruthy()
     expect(orm.hasCachedTable("a")).toBeTruthy()
     expect(orm.hasCachedTable("b")).toBeTruthy()
@@ -42,6 +48,8 @@ describe("table management", () => {
   })
 
   test("cascade delete", async () => {
+    expect(await a.isEmpty()).toBeFalsy()
+
     await c.query.del()
 
     expect(await a.isEmpty()).toBeTruthy()
@@ -68,45 +76,51 @@ describe("table column types", () => {
   })
 })
 
-// describe("database extraction", () => {
-//   beforeAll(async () => {
-//     await c.query.insert({ id: 0 })
-//     await b.query.insert({
-//       id: 0,
-//       c_id: 0,
-//     })
-//     await a.query.insert({
-//       id: 0,
-//       b_id: 0,
-//     })
-//   })
-//
-//   test("extract CSV", async () => {
-//     await orm.extract()
-//
-//     expect(fs.existsSync("a.csv")).toBeTruthy()
-//     expect(fs.existsSync("b.csv")).toBeTruthy()
-//     expect(fs.existsSync("c.csv")).toBeTruthy()
-//   })
-//
-//   test("empty tables", async () => {
-//     await a.query.del()
-//     await b.query.del()
-//     await c.query.del()
-//
-//     expect(await a.isEmpty()).toBeTruthy()
-//     expect(await b.isEmpty()).toBeTruthy()
-//     expect(await c.isEmpty()).toBeTruthy()
-//   })
-//
-//   test("import CSV", async () => {
-//     await orm.import()
-//
-//     expect(await a.isEmpty()).toBeFalsy()
-//     expect(await b.isEmpty()).toBeFalsy()
-//     expect(await c.isEmpty()).toBeFalsy()
-//   })
-// })
+describe("database extraction", () => {
+  beforeAll(async () => {
+    await c.query.insert({ id: 0 })
+    await b.query.insert({
+      id: 0,
+      c_id: 0,
+    })
+    await a.query.insert({
+      id: 0,
+      b_id: 0,
+    })
+  })
+
+  test("extract CSV", async () => {
+    await orm.createBackup()
+
+    expect(
+      fs.existsSync(path.join(orm.config.backups.location, "a_chunk_0.csv")),
+    ).toBeTruthy()
+    expect(
+      fs.existsSync(path.join(orm.config.backups.location, "b_chunk_0.csv")),
+    ).toBeTruthy()
+    expect(
+      fs.existsSync(path.join(orm.config.backups.location, "c_chunk_0.csv")),
+    ).toBeTruthy()
+  })
+
+  test("empty tables", async () => {
+    await a.query.del()
+    await b.query.del()
+    await c.query.del()
+
+    expect(await a.isEmpty()).toBeTruthy()
+    expect(await b.isEmpty()).toBeTruthy()
+    expect(await c.isEmpty()).toBeTruthy()
+  })
+
+  test("import CSV", async () => {
+    await orm.restoreBackup()
+
+    expect(await a.isEmpty()).toBeFalsy()
+    expect(await b.isEmpty()).toBeFalsy()
+    expect(await c.isEmpty()).toBeFalsy()
+  })
+})
 
 describe("table getters", () => {
   test("table info", async () => {
@@ -126,9 +140,72 @@ describe("table getters", () => {
   })
 })
 
+describe("data caching", () => {
+  beforeAll(async () => {
+    await c.query.del()
+    await c.query.insert([{ id: 1 }, { id: 2 }, { id: 3 }])
+    await b.query.insert([
+      { id: 1, c_id: 1 },
+      { id: 2, c_id: 2 },
+      { id: 3, c_id: 3 },
+    ])
+    await a.query.insert([
+      { id: 1, b_id: 1 },
+      { id: 2, b_id: 2 },
+      { id: 3, b_id: 3 },
+    ])
+  })
+
+  test("select with caching", async () => {
+    const rows = await a.cache.get("all a", (query) => {
+      return query.select("*")
+    })
+
+    expect(rows.length).toBe(3)
+  })
+
+  test("insert with caching", async () => {
+    await a.cache.set((query) => {
+      return query.insert({ id: 4, b_id: 1 })
+    })
+
+    expect(await a.cache.count()).toBe(4)
+  })
+
+  test("update with caching", async () => {
+    await a.cache.set((query) => {
+      return query.update({ b_id: 3 }).where({ id: 1 })
+    })
+
+    const row = await a.cache.get("a 1", (query) => {
+      return query.select("b_id").where({ id: 1 }).first()
+    })
+
+    expect(row.b_id).toBe(3)
+  })
+
+  test("delete with caching", async () => {
+    await a.cache.set((query) => {
+      return query.delete().where({ id: 1 })
+    })
+
+    expect(await a.cache.count()).toBe(3)
+  })
+
+  test("cache invalidation", async () => {
+    expect(await a.cache.count()).toBe(3)
+
+    await a.query.insert({ id: 5, b_id: 1 })
+
+    expect(await a.cache.count()).toBe(3)
+
+    orm.cache.invalidate()
+
+    expect(await a.cache.count()).toBe(4)
+  })
+})
+
 afterAll(async () => {
   await orm.database.destroy()
-  // fs.unlinkSync("a.csv")
-  // fs.unlinkSync("b.csv")
-  // fs.unlinkSync("c.csv")
+  await rimraf(orm.config.backups.location)
 })

package/tsconfig.json

@@ -2,10 +2,13 @@
   "compilerOptions": {
     "strict": true,
     "rootDir": "src",
-    "target": "es2020",
-    "module": "CommonJS",
+    "outDir": "dist",
+    "module": "esnext",
+    "target": "esnext",
     "lib": ["es2020", "dom"],
     "moduleResolution": "Node",
-    "esModuleInterop": true
-  }
+    "esModuleInterop": true,
+    "typeRoots": ["./node_modules/@types", "./dist/typings"]
+  },
+  "include": ["src/**/*", "dist/typings/**/*"]
 }

package/dist/cjs/app/orm.js

@@ -1,94 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORM = void 0;
-const fs_1 = __importDefault(require("fs"));
-const url_1 = __importDefault(require("url"));
-const path_1 = __importDefault(require("path"));
-const handler_1 = require("@ghom/handler");
-const knex_1 = __importDefault(require("knex"));
-const table_js_1 = require("./table.js");
-const defaultBackupDir = path_1.default.join(process.cwd(), "backup");
-const pack = JSON.parse(fs_1.default.readFileSync(path_1.default.join(process.cwd(), "package.json"), "utf8"));
-const isCJS = pack.type === "commonjs" || pack.type == void 0;
-class ORM {
-    constructor(config) {
-        this.config = config;
-        this.database = (0, knex_1.default)(config.database ?? {
-            client: "sqlite3",
-            useNullAsDefault: true,
-            connection: {
-                filename: ":memory:",
-            },
-        });
-        this.handler = new handler_1.Handler(config.location, {
-            loader: (filepath) => Promise.resolve(`${isCJS ? filepath : url_1.default.pathToFileURL(filepath).href}`).then(s => __importStar(require(s))).then((file) => file.default),
-            pattern: /\.js$/,
-        });
-    }
-    get cachedTables() {
-        return [...this.handler.elements.values()];
-    }
-    get cachedTableNames() {
-        return this.cachedTables.map((table) => table.options.name);
-    }
-    hasCachedTable(name) {
-        return this.cachedTables.some((table) => table.options.name);
-    }
-    async hasTable(name) {
-        return this.database.schema.hasTable(name);
-    }
-    /**
-     * Handle the table files and create the tables in the database.
-     */
-    async init() {
-        await this.handler.init();
-        try {
-            await this.database.raw("PRAGMA foreign_keys = ON;");
-        }
-        catch (error) { }
-        const migration = new table_js_1.Table({
-            name: "migration",
-            priority: Infinity,
-            setup: (table) => {
-                table.string("table").unique().notNullable();
-                table.integer("version").notNullable();
-            },
-        });
-        migration.orm = this;
-        await migration.make();
-        for (const table of this.cachedTables.sort((a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0))) {
-            table.orm = this;
-            await table.make();
-        }
-    }
-    raw(sql) {
-        return this.database.raw(sql);
-    }
-}
-exports.ORM = ORM;