@ghom/orm 1.7.1 → 1.8.0

package/.github/workflows/test.yml

@@ -0,0 +1,40 @@
+# This is a basic workflow to help you get started with Actions
+
+name: Test
+
+# Controls when the action will run.
+on:
+  # Triggers the workflow on push or pull request events but only for the master branch
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  test:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build the source
+        run: npm run build
+
+      - name: Start the tests
+        run: npm run test

package/.run/All Tests.run.xml

@@ -0,0 +1,22 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="All Tests" type="JavaScriptTestRunnerJest" nameIsGenerated="true">
+    <node-interpreter value="project" />
+    <node-options value="--experimental-vm-modules" />
+    <jest-package value="$PROJECT_DIR$/node_modules/jest" />
+    <working-dir value="$PROJECT_DIR$" />
+    <jest-options value="tests/test.js --detectOpenHandles" />
+    <envs />
+    <scope-kind value="ALL" />
+    <method v="2">
+      <option name="NpmBeforeRunTask" enabled="true">
+        <package-json value="$PROJECT_DIR$/package.json" />
+        <command value="run" />
+        <scripts>
+          <script value="build" />
+        </scripts>
+        <node-interpreter value="project" />
+        <envs />
+      </option>
+    </method>
+  </configuration>
+</component>

package/dist/app/backup.js

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+import util from "util";
+import csv from "json-2-csv";
+import csvParser from "csv-parser";
+import { DEFAULT_BACKUP_CHUNK_SIZE, DEFAULT_BACKUP_LOCATION, DEFAULT_LOGGER_HIGHLIGHT, DEFAULT_LOGGER_RAW_VALUE, } from "./util.js";
+export async function backupTable(table, dirname) {
+    if (!table.orm)
+        throw new Error("missing ORM");
+    let offset = 0;
+    let chunkIndex = 0;
+    const chunkDir = path.join(table.orm.config.backups?.location ?? DEFAULT_BACKUP_LOCATION, dirname ?? "");
+    if (!fs.existsSync(chunkDir)) {
+        fs.mkdirSync(chunkDir, { recursive: true });
+        console.log(`Backup directory ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, path.relative(process.cwd(), chunkDir))} created.`);
+    }
+    try {
+        // Compter le nombre total d'enregistrements dans la table
+        const rowCount = await table.count();
+        const limit = 1000; // Limite par requête
+        const chunkCount = Math.ceil(rowCount / limit);
+        let writeStream = null;
+        const closePromises = []; // Tableau pour stocker les promesses de fermeture
+        while (offset < rowCount) {
+            // Récupérer un "chunk" de données
+            const rows = await table.query.select("*").limit(limit).offset(offset);
+            // Convertir les données en CSV
+            const csvData = csv.json2csv(rows);
+            // Si aucun fichier n'est créé ou qu'on a dépassé la taille max du chunk, on crée un nouveau fichier CSV
+            if (!writeStream ||
+                writeStream.bytesWritten + Buffer.byteLength(csvData, "utf8") >
+                    (table.orm.config.backups?.chunkSize ?? DEFAULT_BACKUP_CHUNK_SIZE)) {
+                if (writeStream) {
+                    closePromises.push(new Promise((resolve) => writeStream.end(resolve))); // Ajouter la promesse de fermeture
+                }
+                const chunkFile = path.join(chunkDir, `${table.options.name}_chunk_${chunkIndex}.csv`);
+                writeStream = fs.createWriteStream(chunkFile, { flags: "a" });
+                chunkIndex++;
+            }
+            // Écrire les données dans le stream
+            writeStream.write(csvData);
+            offset += limit;
+            process.stdout.write(`\rBacking up table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)}: ${util.styleText(table.orm.config.loggerStyles?.rawValue ?? DEFAULT_LOGGER_RAW_VALUE, String(Math.round((chunkIndex / chunkCount) * 100)))}%`);
+        }
+        if (writeStream) {
+            closePromises.push(new Promise((resolve) => writeStream.end(resolve))); // Ajouter la promesse de fermeture pour le dernier stream
+        }
+        // Attendre que tous les flux d'écriture soient fermés
+        await Promise.all(closePromises);
+        console.log(`\nBackup of table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)} completed.`);
+    }
+    catch (error) {
+        console.error(`\nError while backing up table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)}:`, error);
+    }
+}
+export async function restoreBackup(table, dirname) {
+    if (!table.orm)
+        throw new Error("missing ORM");
+    const chunkDir = path.join(table.orm.config.backups?.location ?? DEFAULT_BACKUP_LOCATION, dirname ?? "");
+    const chunkFiles = fs
+        .readdirSync(chunkDir)
+        .filter((file) => file.split("_chunk_")[0] === table.options.name);
+    await table.query.truncate();
+    try {
+        const limit = 1000; // Limite par requête
+        for (let chunkFile of chunkFiles) {
+            const filePath = path.join(chunkDir, chunkFile);
+            let rows = [];
+            await new Promise((resolve, reject) => {
+                fs.createReadStream(filePath)
+                    .pipe(csvParser())
+                    .on("data", async (row) => {
+                    rows.push(row);
+                    if (rows.length > limit) {
+                        const rowsCopy = rows.slice();
+                        rows = [];
+                        await table.query.insert(rowsCopy);
+                    }
+                })
+                    .on("end", async () => {
+                    // Insérer les données dans la table une fois le fichier entièrement lu
+                    if (rows.length > 0)
+                        await table.query.insert(rows);
+                    console.log(`Restored chunk ${util.styleText(table.orm.config.loggerStyles?.highlight ??
+                        DEFAULT_LOGGER_HIGHLIGHT, chunkFile)} into table ${util.styleText(table.orm.config.loggerStyles?.highlight ??
+                        DEFAULT_LOGGER_HIGHLIGHT, table.options.name)}.`);
+                    resolve();
+                })
+                    .on("error", reject);
+            });
+        }
+    }
+    catch (error) {
+        console.error(`Error while restoring backup of table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)}:`, error);
+    }
+    console.log(`Backup of table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)} restored.`);
+}
+export async function disableForeignKeys(orm) {
+    const result = await Promise.allSettled([
+        orm.raw("SET session_replication_role = replica;"),
+        orm.raw("PRAGMA foreign_keys = OFF;"),
+        orm.raw("SET FOREIGN_KEY_CHECKS = 0;"), // for mysql2
+    ]);
+    const errors = result.filter((r) => r.status === "rejected");
+    if (errors.length === 3) {
+        throw new Error("Failed to disable foreign key constraints.");
+    }
+}
+export async function enableForeignKeys(orm) {
+    const result = await Promise.allSettled([
+        orm.raw("SET session_replication_role = DEFAULT;"),
+        orm.raw("PRAGMA foreign_keys = ON;"),
+        orm.raw("SET FOREIGN_KEY_CHECKS = 1;"), // for mysql2
+    ]);
+    const errors = result.filter((r) => r.status === "rejected");
+    if (errors.length === 3) {
+        throw new Error("Failed to enable foreign key constraints.");
+    }
+}

package/dist/app/caching.js

@@ -0,0 +1,36 @@
+/**
+ * Advanced cache for async queries
+ */
+export class ResponseCache {
+    _request;
+    _timeout;
+    _cache = new Map();
+    constructor(_request, _timeout) {
+        this._request = _request;
+        this._timeout = _timeout;
+    }
+    get(id, ...params) {
+        const cached = this._cache.get(id);
+        if (!cached || cached.expires < Date.now()) {
+            this._cache.set(id, {
+                value: this._request(...params),
+                expires: Date.now() + this._timeout,
+            });
+        }
+        return this._cache.get(id).value;
+    }
+    fetch(id, ...params) {
+        this._cache.set(id, {
+            value: this._request(...params),
+            expires: Date.now() + this._timeout,
+        });
+        return this._cache.get(id).value;
+    }
+    invalidate(id) {
+        if (!id) {
+            this._cache.clear();
+            return;
+        }
+        this._cache.delete(id);
+    }
+}

package/dist/app/orm.js

@@ -0,0 +1,109 @@
+import url from "url";
+import { Handler } from "@ghom/handler";
+import { default as knex } from "knex";
+import { isCJS } from "./util.js";
+import { Table } from "./table.js";
+import { backupTable, restoreBackup, disableForeignKeys, enableForeignKeys, } from "./backup.js";
+import { ResponseCache } from "./caching";
+export class ORM {
+    config;
+    _ready = false;
+    database;
+    handler;
+    _rawCache;
+    constructor(config) {
+        this.config = config;
+        this.database = knex(config.database ?? {
+            client: "sqlite3",
+            useNullAsDefault: true,
+            connection: {
+                filename: ":memory:",
+            },
+        });
+        this.handler = new Handler(config.tableLocation, {
+            loader: (filepath) => import(isCJS ? filepath : url.pathToFileURL(filepath).href).then((file) => file.default),
+            pattern: /\.js$/,
+        });
+        this._rawCache = new ResponseCache((raw) => this.raw(raw), config.caching ?? Infinity);
+    }
+    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 === 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();
+        await enableForeignKeys(this);
+        this.handler.elements.set("migration", new Table({
+            name: "migration",
+            priority: Infinity,
+            setup: (table) => {
+                table.string("table").unique().notNullable();
+                table.integer("version").notNullable();
+            },
+        }));
+        for (const table of this.cachedTables.sort((a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0))) {
+            table.orm = this;
+            await table.make();
+        }
+        this._ready = true;
+    }
+    raw(sql) {
+        if (this._ready)
+            this.cache.invalidate();
+        return this.database.raw(sql);
+    }
+    cache = {
+        raw: (sql, anyDataUpdated) => {
+            if (anyDataUpdated)
+                this.cache.invalidate();
+            return this._rawCache.get(sql, sql);
+        },
+        invalidate: () => {
+            this._rawCache.invalidate();
+            this.cachedTables.forEach((table) => table.cache.invalidate());
+        },
+    };
+    /**
+     * Create a backup of the database. <br>
+     * The backup will be saved in the location specified in the config.
+     */
+    async createBackup(dirname) {
+        try {
+            for (let table of this.cachedTables) {
+                await backupTable(table, dirname);
+            }
+            console.log("Database backup created.");
+        }
+        catch (error) {
+            console.error("Error while creating backup of the database.", error);
+        }
+    }
+    /**
+     * Restore the database from the backup. <br>
+     * @warning This will delete all the data in the tables.
+     */
+    async restoreBackup(dirname) {
+        try {
+            await disableForeignKeys(this);
+            for (let table of this.cachedTables) {
+                await restoreBackup(table, dirname);
+            }
+            await enableForeignKeys(this);
+            console.log("Database restored from backup.");
+        }
+        catch (error) {
+            console.error("Error while restoring backup of the database.", error);
+        }
+    }
+}

package/dist/{esm/app → app}/table.js

@@ -1,7 +1,11 @@
-import chalk from "chalk";
+import util from "util";
+import { ResponseCache } from "./caching.js";
+import { DEFAULT_LOGGER_DESCRIPTION, DEFAULT_LOGGER_HIGHLIGHT, DEFAULT_LOGGER_RAW_VALUE, } from "./util.js";
 export class Table {
     options;
     orm;
+    _whereCache;
+    _countCache;
     constructor(options) {
         this.options = options;
     }
@@ -13,6 +17,30 @@ export class Table {
     get query() {
         return this.db(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: (id, cb) => {
+                return this._whereCache.get(id, cb);
+            },
+            set: (cb) => {
+                // todo: invalidate only the related tables
+                this.orm.cache.invalidate();
+                return cb(this.query);
+            },
+            count: (where) => {
+                return this._countCache.get(where ?? "*", where ?? null);
+            },
+            invalidate: () => {
+                this._whereCache.invalidate();
+                this._countCache.invalidate();
+                this.orm._rawCache.invalidate();
+            },
+        };
+    }
     async count(where) {
         return this.query
             .select(this.db.raw("count(*) as total"))
@@ -32,32 +60,36 @@ export class Table {
         return this.getColumns().then(Object.keys);
     }
     async isEmpty() {
-        return this.count().then((count) => count === 0);
+        return this.count().then((count) => +count === 0);
     }
     async make() {
         if (!this.orm)
             throw new Error("missing ORM");
+        this._whereCache = new ResponseCache((cb) => cb(this.query), this.options.caching ?? this.orm?.config.caching ?? Infinity);
+        this._countCache = new ResponseCache((where) => 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)}${this.options.description
-                ? ` ${chalk[this.orm.config.loggerColors?.description ?? "grey"](this.options.description)}`
+            this.orm.config.logger?.log(`created table ${util.styleText(this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, this.options.name)}${this.options.description
+                ? ` ${util.styleText(this.orm.config.loggerStyles?.description ??
+                    DEFAULT_LOGGER_DESCRIPTION, this.options.description)}`
                 : ""}`);
         }
         catch (error) {
             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!`);
+                this.orm.config.logger?.error(`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)}${this.options.description
-                    ? ` ${chalk[this.orm.config.loggerColors?.description ?? "grey"](this.options.description)}`
+                this.orm.config.logger?.log(`loaded table ${util.styleText(this.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, this.options.name)}${this.options.description
+                    ? ` ${util.styleText(this.orm.config.loggerStyles?.description ??
+                        DEFAULT_LOGGER_DESCRIPTION, this.options.description)}`
                     : ""}`);
             }
         }
         try {
             const migrated = await this.migrate();
             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)}`);
+                this.orm.config.logger?.log(`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) {

package/dist/app/util.js

@@ -0,0 +1,18 @@
+import path from "path";
+import fs from "fs";
+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 = 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/dist/index.js

@@ -0,0 +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/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ghom/orm",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "license": "MIT",
   "type": "module",
-  "main": "dist/esm/index.js",
-  "types": "dist/typings/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "description": "TypeScript KnexJS ORM & handler",
+  "homepage": "https://github.com/GhomKrosmonaute/orm",
   "prettier": {
     "semi": false
   },
@@ -14,17 +15,18 @@
     "require": "./dist/cjs/index.js"
   },
   "scripts": {
-    "format": "prettier --write src tsconfig.*",
-    "build": "rm -fr dist/* && tsc -p tsconfig-esm.json && tsc -p tsconfig-cjs.json && fixup.sh",
+    "format": "prettier --write src tsconfig.json tests",
+    "build": "rimraf dist && tsc",
     "test": "npm run build && node --experimental-vm-modules node_modules/jest/bin/jest.js tests/test.js --detectOpenHandles",
     "prepublishOnly": "npm run format && npm test"
   },
   "devDependencies": {
     "@types/jest": "^29.5.6",
-    "@types/node": "^20.8.9",
+    "@types/node": "^22.0.0",
     "dotenv": "^16.3.1",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
+    "rimraf": "^6.0.1",
     "typescript": "^5.2.2"
   },
   "optionalDependencies": {
@@ -34,6 +36,15 @@
   },
   "dependencies": {
     "@ghom/handler": "^2.0.0",
+    "csv-parser": "^3.0.0",
+    "json-2-csv": "^5.5.6",
     "knex": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "url": "https://github.com/GhomKrosmonaute/orm.git",
+    "type": "git"
   }
 }

package/readme.md

@@ -1,5 +1,7 @@
 # TypeScript KnexJS ORM & handler
 
+![test workflow badge](https://github.com/GhomKrosmonaute/orm/actions/workflows/test.yml/badge.svg)
+
 ## Install
 
 ```bash
@@ -13,18 +15,29 @@ import { ORM } from "@ghom/orm"
 
 const orm = new ORM({
   // tables directory
-  lcoation: "./tables",
+  tableLocation: "./tables",
   
   // knex config (sqlite3 by default)
   database: { ... },
   
   // custom logger (console by default)
   logger: console,
-  loggerColors: { ... }
+  loggerColors: { ... },
+  
+  // caching options for all tables and rawCache queries (default to Infinity)
+  caching: 10 * 60 * 1000,
+
+  // configuration for the database backups
+  backups: {
+    location: "./backups",
+  }
 })
+
+// start handling of tables
+await orm.init()
 ```
 
-## Tables
+## Add tables
 
 The tables are automatically loaded from the `location` directory.
 
@@ -33,7 +46,12 @@ The tables are automatically loaded from the `location` directory.
 
 import { Table } from "@ghom/orm"
 
-export default new Table({
+interface User {
+  username: string
+  password: string
+}
+
+export default new Table<User>({
   name: "user",
   
   // the higher the priority, the earlier the table is compiled
@@ -55,24 +73,111 @@ export default new Table({
   // the then is executed after the table is created and the migrations are runned
   then: ({ query }) => {
     query.insert({ username: "admin", password: "admin" })
-  }
+  },
+  
+  caching: 10 * 60 * 1000 // The table cache. Default to the ORM cache or Infinity
 })
 ```
 
-## Query
+## Launch a query
+
+For more information about the query builder, see [knexjs.org](https://knexjs.org/).  
+You can launch a SQL query on a table like that
+
+```typescript
+import user from "./tables/user"
+
+export async function compareHash(username, hash): Promise<boolean> {
+  const user = await user.query
+    .select()
+    .where("username", username)
+    .first()
+
+  return user && user.password === hash
+}
+```
+
+## Backup
+
+You can backup the database by calling the `createBackup` and `restoreBackup` methods on the ORM instance. The backup is stored in the `config.backups.location` directory.
+
+```typescript
+await orm.createBackup() // on the root backup directory (not recommended)
+await orm.createBackup("2021-01-01T00:00:00.000Z") // with dirname as backup ID
 
-For more information about the query builder, see [knexjs.org](https://knexjs.org/).
+await orm.restoreBackup()
+await orm.restoreBackup("2021-01-01T00:00:00.000Z")
+```
 
-## Import/extract
+## Caching
 
-You can transfer the data from one instance of the ORM to another (between two database clients, for example between "pg" and "mysql2").
+The cache is automatically managed by the ORM. When a table is requested from the `<Table>.cache` property, the ORM will automatically use caching for all your queries. The cache is useful when you have a lot of requests on the same table, and you don't want to query the database every time.
 
 ```typescript
-await orm1.extract()
+// get the number of rows in the table with caching
+await table.cache.count() // => 10
+
+// add a row with caching
+await table.cache.set((query) => {
+  return query.insert({ name: "test" })
+})
+
+await table.cache.count() // => 11
+
+// Get the row with caching.
+// After the first call, the row is cached until
+// the cache is invalidate by a "cache.set" or "cache.invalidate" call
+await table.cache.get("named test", (query) => {
+  return query.where("name", "test").first()
+}) // => { name: "test" }
+
+// delete the row without caching
+await table.query.delete().where("name", "test")
+
+await table.cache.count() // => 11 (unchanged)
+
+// indicate that the cache is invalidate
+// and force the cache to be updated
+table.cache.invalidate()
+
+await table.cache.count() // => 10
+await table.cache.count() // => 10 (no more query to the database)
+
+// remove all rows from a table with caching
+await table.cache.set((query) => {
+  return query.truncate()
+})
+
+await table.cache.count() // => 0
 ```
 
+> ⚠️ For a cache-style usage, you should use the `cache` property for all your queries. If you use the `query` property, the cache will not be updated, and it will cause a cache inconsistency.
+
+### Raw cache
+
+You can also cache raw queries with the `<ORM>.cache.raw` property. The raw cache is useful when you have a complex query that you want to cache.
+
 ```typescript
-await orm2.import()
+const fooUser = await orm.cache.raw("select * from user where name = 'foo'") // query the database
+const barUser = await orm.cache.raw("select * from user where name = 'bar'") // query the database
+const fooUserCached = await orm.cache.raw("select * from user where name = 'foo'") // no query to the database
 ```
 
-The SQL structure isn't transferred, only the data. You must copy the table files to the other project.
+The cache of the `<ORM>.cache.raw` method is automatically invalidated when the database is updated.
+
+## Future features
+
+- [x] Add timed caching system
+- [x] Add backup option
+- [ ] Dependency management between tables
+- [ ] Auto typings for tables from the column definitions
+- [ ] Add specific methods for relations and joins
+- [ ] Add admin panel
+- [ ] Make possible to switch the data between all possible clients (pg, mysql, sqlite3)
+- [ ] Add a way to set up timezone directly in the ORM constructor
+
+## Used by
+
+[<img src="https://github.com/GhomKrosmonaute.png?size=50" width=50>](https://github.com/GhomKrosmonaute)
+[<img src="https://github.com/Les-Laboratoires.png?size=50" width=50>](https://github.com/Les-Laboratoires)
+[<img src="https://github.com/bot-ts.png?size=50" width=50>](https://github.com/bot-ts)