@ghom/orm 1.7.2 → 1.8.1

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.d.ts

@@ -0,0 +1,6 @@
+import { ORM } from "./orm.js";
+import { Table } from "./table.js";
+export declare function backupTable(table: Table, dirname?: string): Promise<void>;
+export declare function restoreBackup(table: Table, dirname?: string): Promise<void>;
+export declare function disableForeignKeys(orm: ORM): Promise<void>;
+export declare function enableForeignKeys(orm: ORM): Promise<void>;

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.d.ts

@@ -0,0 +1,18 @@
+export interface ResponseCacheData<Value> {
+    value: Value;
+    expires: number;
+    outdated?: boolean;
+}
+/**
+ * Advanced cache for async queries
+ */
+export declare class ResponseCache<Params extends any[], Value> {
+    private _request;
+    private _timeout;
+    private _cache;
+    constructor(_request: (...params: Params) => Value, _timeout: number);
+    get(id: string, ...params: Params): Value;
+    fetch(id: string, ...params: Params): Value;
+    invalidate(): void;
+    invalidate(id: string): void;
+}

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/{typings/app → app}/orm.d.ts

@@ -1,7 +1,8 @@
 import { Handler } from "@ghom/handler";
 import { Knex } from "knex";
+import { TextStyle } from "./util.js";
 import { Table } from "./table.js";
-import { Color } from "chalk";
+import { ResponseCache } from "./caching";
 export interface ILogger {
     log: (message: string) => void;
     error: (error: string | Error) => void;
@@ -11,7 +12,7 @@ export interface ORMConfig {
     /**
      * path to the directory that contains js files of tables
      */
-    location: string;
+    tableLocation: string;
     /**
      * database configuration
      */
@@ -22,18 +23,32 @@ export interface ORMConfig {
     logger?: ILogger;
     /**
      * Pattern used on logs when the table files are loaded or created. <br>
-     * Based on Chalk color-method names.
+     * Based on node:util.styleText style names.
      */
-    loggerColors?: {
-        highlight: typeof Color;
-        rawValue: typeof Color;
-        description: typeof Color;
+    loggerStyles?: {
+        highlight: TextStyle;
+        rawValue: TextStyle;
+        description: TextStyle;
     };
+    /**
+     * Configuration for the database backups.
+     */
+    backups?: {
+        location?: string;
+        chunkSize?: number;
+    };
+    /**
+     * The cache time in milliseconds. <br>
+     * Default is `Infinity`.
+     */
+    caching?: number;
 }
 export declare class ORM {
     config: ORMConfig;
+    private _ready;
     database: Knex;
     handler: Handler<Table<any>>;
+    _rawCache: ResponseCache<[sql: string], Knex.Raw>;
     constructor(config: ORMConfig);
     get cachedTables(): Table<any>[];
     get cachedTableNames(): string[];
@@ -44,4 +59,18 @@ export declare class ORM {
      */
     init(): Promise<void>;
     raw(sql: Knex.Value): Knex.Raw;
+    cache: {
+        raw: (sql: string, anyDataUpdated?: boolean) => Knex.Raw;
+        invalidate: () => void;
+    };
+    /**
+     * Create a backup of the database. <br>
+     * The backup will be saved in the location specified in the config.
+     */
+    createBackup(dirname?: string): Promise<void>;
+    /**
+     * Restore the database from the backup. <br>
+     * @warning This will delete all the data in the tables.
+     */
+    restoreBackup(dirname?: string): Promise<void>;
 }

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/{typings/app → app}/table.d.ts

@@ -1,5 +1,6 @@
 import { Knex } from "knex";
 import { ORM } from "./orm.js";
+import { ResponseCache } from "./caching.js";
 export interface MigrationData {
     table: string;
     version: number;
@@ -8,6 +9,11 @@ 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;
     };
@@ -17,6 +23,10 @@ export interface TableOptions<Type extends object = object> {
 export declare class Table<Type extends object = object> {
     readonly options: TableOptions<Type>;
     orm?: ORM;
+    _whereCache?: ResponseCache<[
+        cb: (query: Table<Type>["query"]) => unknown
+    ], unknown>;
+    _countCache?: ResponseCache<[where: string | null], Promise<number>>;
     constructor(options: TableOptions<Type>);
     get db(): Knex<any, any[]>;
     get query(): Knex.QueryBuilder<Type, {
@@ -28,6 +38,12 @@ export declare class Table<Type extends object = object> {
         _intersectProps: {};
         _unionProps: never;
     }[]>;
+    get cache(): {
+        get: <Return>(id: string, cb: (table: Pick<Table<Type>["query"], "select" | "count" | "avg" | "sum" | "countDistinct" | "avgDistinct" | "sumDistinct">) => Return) => Return;
+        set: <Return_1>(cb: (table: Pick<Table<Type>["query"], "update" | "delete" | "insert" | "upsert" | "truncate" | "jsonInsert">) => Return_1) => Return_1;
+        count: (where?: string) => Promise<number>;
+        invalidate: () => void;
+    };
     count(where?: string): Promise<number>;
     hasColumn(name: keyof Type & string): Promise<boolean>;
     getColumn(name: keyof Type & string): Promise<Knex.ColumnInfo>;

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.d.ts

@@ -0,0 +1,9 @@
+import util from "util";
+export type TextStyle = Parameters<typeof util.styleText>[0];
+export declare const DEFAULT_BACKUP_LOCATION: string;
+export declare const DEFAULT_BACKUP_CHUNK_SIZE: number;
+export declare const DEFAULT_LOGGER_HIGHLIGHT = "blueBright";
+export declare const DEFAULT_LOGGER_DESCRIPTION = "grey";
+export declare const DEFAULT_LOGGER_RAW_VALUE = "magentaBright";
+declare let isCJS: boolean;
+export { isCJS };

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.d.ts

@@ -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/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.2",
+  "version": "1.8.1",
   "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"
   }
 }