@ghom/orm 1.8.7 → 1.9.0

package/dist/app/backup.js

@@ -1,24 +1,23 @@
-import fs from "fs";
-import path from "path";
-import util from "util";
+import fs from "node:fs";
+import path from "node:path";
 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";
+import { DEFAULT_BACKUP_CHUNK_SIZE, DEFAULT_BACKUP_LOCATION, styled, } from "./util.js";
 export async function backupTable(table, dirname) {
     if (!table.orm)
         throw new Error("missing ORM");
     let offset = 0;
+    let processedRows = 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.`);
+        console.log(`Backup directory ${styled(table.orm, path.relative(process.cwd(), chunkDir), "highlight")} 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) {
@@ -39,18 +38,21 @@ export async function backupTable(table, dirname) {
             }
             // Écrire les données dans le stream
             writeStream.write(csvData);
+            processedRows += rows.length;
             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)))}%`);
+            // Calcul du pourcentage basé sur le nombre de lignes traitées
+            const percentage = Math.round((processedRows / rowCount) * 100);
+            process.stdout.write(`\rBacking up table ${styled(table.orm, table.options.name, "highlight")}: ${styled(table.orm, String(percentage), "rawValue")}%`);
         }
         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.`);
+        console.log(`\nBackup of table ${styled(table.orm, table.options.name, "highlight")} completed.`);
     }
     catch (error) {
-        console.error(`\nError while backing up table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)}:`, error);
+        console.error(`\nError while backing up table ${styled(table.orm, table.options.name, "highlight")}:`, error);
     }
 }
 export async function restoreBackup(table, trx, dirname) {
@@ -63,14 +65,19 @@ export async function restoreBackup(table, trx, dirname) {
     await trx(table.options.name).del();
     try {
         const limit = 1000; // Limite par requête
+        const totalChunks = chunkFiles.length;
+        let processedChunks = 0;
+        let totalRowsRestored = 0;
         for (let chunkFile of chunkFiles) {
             const filePath = path.join(chunkDir, chunkFile);
             let rows = [];
+            let chunkRowsCount = 0;
             await new Promise((resolve, reject) => {
                 fs.createReadStream(filePath)
                     .pipe(csvParser())
                     .on("data", async (row) => {
                     rows.push(row);
+                    chunkRowsCount++;
                     if (rows.length > limit) {
                         const rowsCopy = rows.slice();
                         rows = [];
@@ -81,19 +88,20 @@ export async function restoreBackup(table, trx, dirname) {
                     // Insérer les données dans la table une fois le fichier entièrement lu
                     if (rows.length > 0)
                         await trx(table.options.name).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)}.`);
+                    processedChunks++;
+                    totalRowsRestored += chunkRowsCount;
+                    const percentage = Math.round((processedChunks / totalChunks) * 100);
+                    process.stdout.write(`\rRestoring table ${styled(table.orm, table.options.name, "highlight")}: ${styled(table.orm, String(percentage), "rawValue")}%`);
                     resolve();
                 })
                     .on("error", reject);
             });
         }
+        console.log(`\nBackup of table ${styled(table.orm, table.options.name, "highlight")} restored. Total rows: ${styled(table.orm, String(totalRowsRestored), "rawValue")}`);
     }
     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.error(`\nError while restoring backup of table ${styled(table.orm, table.options.name, "highlight")}:`, error);
     }
-    console.log(`Backup of table ${util.styleText(table.orm.config.loggerStyles?.highlight ?? DEFAULT_LOGGER_HIGHLIGHT, table.options.name)} restored.`);
 }
 export async function enableForeignKeys(orm, trx) {
     const ctx = trx ?? orm;
@@ -105,8 +113,8 @@ export async function enableForeignKeys(orm, trx) {
 }
 export async function disableForeignKeys(orm, run) {
     const trx = orm.clientBasedOperation({
-        sqlite3: () => orm.database,
-    }) ?? (await orm.database.transaction());
+        sqlite3: () => orm.client,
+    }) ?? (await orm.client.transaction());
     const ran = await orm.clientBasedOperation({
         mysql2: async () => {
             const result = await trx.raw("SELECT @@FOREIGN_KEY_CHECKS;");

package/dist/app/orm.d.ts

@@ -8,6 +8,11 @@ export interface ILogger {
     error: (error: string | Error) => void;
     warn: (warning: string) => void;
 }
+export interface LoggerStyles {
+    highlight: TextStyle;
+    rawValue: TextStyle;
+    description: TextStyle;
+}
 export interface ORMConfig {
     /**
      * path to the directory that contains js files of tables
@@ -25,11 +30,7 @@ export interface ORMConfig {
      * Pattern used on logs when the table files are loaded or created. <br>
      * Based on node:util.styleText style names.
      */
-    loggerStyles?: {
-        highlight: TextStyle;
-        rawValue: TextStyle;
-        description: TextStyle;
-    };
+    loggerStyles?: LoggerStyles;
     /**
      * Configuration for the database backups.
      */
@@ -46,9 +47,9 @@ export interface ORMConfig {
 export declare class ORM {
     config: ORMConfig;
     private _ready;
-    database: Knex;
+    client: Knex<any, unknown[]>;
     handler: Handler<Table<any>>;
-    _rawCache: ResponseCache<[sql: string], Knex.Raw>;
+    _rawCache: ResponseCache<[raw: string], Knex.Raw<any>>;
     constructor(config: ORMConfig);
     get cachedTables(): Table<any>[];
     get cachedTableNames(): string[];

package/dist/app/orm.js

@@ -1,4 +1,4 @@
-import url from "url";
+import url from "node:url";
 import { Handler } from "@ghom/handler";
 import { default as knex } from "knex";
 import { isCJS } from "./util.js";
@@ -8,12 +8,12 @@ import { backupTable, restoreBackup, disableForeignKeys, enableForeignKeys, } fr
 export class ORM {
     config;
     _ready = false;
-    database;
+    client;
     handler;
     _rawCache;
     constructor(config) {
         this.config = config;
-        this.database = knex(config.database ?? {
+        this.client = knex(config.database ?? {
             client: "sqlite3",
             useNullAsDefault: true,
             connection: {
@@ -21,8 +21,13 @@ export class ORM {
             },
         });
         this.handler = new Handler(config.tableLocation, {
-            loader: (filepath) => import(isCJS ? filepath : url.pathToFileURL(filepath).href).then((file) => file.default),
-            pattern: /\.js$/,
+            pattern: /\.[jt]s$/,
+            loader: async (filepath) => {
+                const file = await import(isCJS ? filepath : url.pathToFileURL(filepath).href);
+                if (file.default instanceof Table)
+                    return file.default;
+                throw new Error(`${filepath}: default export must be a Table instance`);
+            },
         });
         this._rawCache = new ResponseCache((raw) => this.raw(raw), config.caching ?? Infinity);
     }
@@ -36,7 +41,7 @@ export class ORM {
         return this.cachedTables.some((table) => table.options.name === name);
     }
     async hasTable(name) {
-        return this.database.schema.hasTable(name);
+        return this.client.schema.hasTable(name);
     }
     /**
      * Handle the table files and create the tables in the database.
@@ -64,7 +69,7 @@ export class ORM {
     raw(sql) {
         if (this._ready)
             this.cache.invalidate();
-        return this.database.raw(sql);
+        return this.client.raw(sql);
     }
     cache = {
         raw: (sql, anyDataUpdated) => {

package/dist/app/table.d.ts

@@ -28,7 +28,7 @@ export declare class Table<Type extends object = object> {
     ], unknown>;
     _countCache?: ResponseCache<[where: string | null], Promise<number>>;
     constructor(options: TableOptions<Type>);
-    get db(): Knex<any, any[]>;
+    get db(): Knex<any, unknown[]>;
     get query(): Knex.QueryBuilder<Type, {
         _base: Type;
         _hasSelection: false;
@@ -40,7 +40,7 @@ export declare class Table<Type extends object = object> {
     }[]>;
     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;
+        set: <Return>(cb: (table: Pick<Table<Type>["query"], "update" | "delete" | "insert" | "upsert" | "truncate" | "jsonInsert">) => Return) => Return;
         count: (where?: string) => Promise<number>;
         invalidate: () => void;
     };

package/dist/app/table.js

@@ -1,6 +1,5 @@
-import util from "util";
+import { styled } from "./util.js";
 import { ResponseCache } from "./caching.js";
-import { DEFAULT_LOGGER_DESCRIPTION, DEFAULT_LOGGER_HIGHLIGHT, DEFAULT_LOGGER_RAW_VALUE, } from "./util.js";
 export class Table {
     options;
     orm;
@@ -12,7 +11,7 @@ export class Table {
     get db() {
         if (!this.orm)
             throw new Error("missing ORM");
-        return this.orm.database;
+        return this.orm.client;
     }
     get query() {
         return this.db(this.options.name);
@@ -66,29 +65,26 @@ export class Table {
         this.orm = 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);
+        const tableNameLog = `table ${styled(this.orm, this.options.name, "highlight")}${this.options.description
+            ? ` ${styled(this.orm, this.options.description, "description")}`
+            : ""}`;
         try {
             await this.db.schema.createTable(this.options.name, this.options.setup);
-            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)}`
-                : ""}`);
+            this.orm.config.logger?.log(`created table ${tableNameLog}`);
         }
         catch (error) {
             if (error.toString().includes("syntax error")) {
-                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!`);
+                this.orm.config.logger?.error(`you need to implement the "setup" method in options of your ${styled(this.orm, this.options.name, "highlight")} table!`);
                 throw error;
             }
             else {
-                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)}`
-                    : ""}`);
+                this.orm.config.logger?.log(`loaded table ${tableNameLog}`);
             }
         }
         try {
             const migrated = await this.migrate();
             if (migrated !== false) {
-                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))}`);
+                this.orm.config.logger?.log(`migrated table ${styled(this.orm, this.options.name, "highlight")} to version ${styled(this.orm, migrated, "rawValue")}`);
             }
         }
         catch (error) {

package/dist/app/util.d.ts

@@ -1,4 +1,5 @@
-import util from "util";
+import util from "node:util";
+import type { LoggerStyles, ORM } from "./orm.js";
 export type TextStyle = Parameters<typeof util.styleText>[0];
 export declare const DEFAULT_BACKUP_LOCATION: string;
 export declare const DEFAULT_BACKUP_CHUNK_SIZE: number;
@@ -7,3 +8,4 @@ export declare const DEFAULT_LOGGER_DESCRIPTION = "grey";
 export declare const DEFAULT_LOGGER_RAW_VALUE = "magentaBright";
 declare let isCJS: boolean;
 export { isCJS };
+export declare function styled(orm: ORM, message: string | boolean | number, style: keyof LoggerStyles): string;

package/dist/app/util.js

@@ -1,5 +1,6 @@
-import path from "path";
-import fs from "fs";
+import util from "node:util";
+import path from "node:path";
+import fs from "node: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";
@@ -16,3 +17,11 @@ catch {
         "Please create a package.json file or run the project from another entry point.");
 }
 export { isCJS };
+export function styled(orm, message, style) {
+    return util.styleText(orm.config.loggerStyles?.[style] ??
+        (style === "highlight"
+            ? DEFAULT_LOGGER_HIGHLIGHT
+            : style === "rawValue"
+                ? DEFAULT_LOGGER_RAW_VALUE
+                : DEFAULT_LOGGER_DESCRIPTION), String(message));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghom/orm",
-  "version": "1.8.7",
+  "version": "1.9.0",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "sqlite3": "^5.1.6"
   },
   "dependencies": {
-    "@ghom/handler": "^2.0.0",
+    "@ghom/handler": "^3.1.0",
     "csv-parser": "^3.0.0",
     "json-2-csv": "^5.5.6",
     "knex": "^3.0.1"

package/tests/test.js

@@ -61,7 +61,7 @@ describe("table column types", () => {
   test("increments", async () => {
     expect(
       await orm
-        .database("a")
+        .client("a")
         .columnInfo("id")
         .then((info) => info.type),
     ).toMatch(/^int/)
@@ -70,7 +70,7 @@ describe("table column types", () => {
   test("integer", async () => {
     expect(
       await orm
-        .database("a")
+        .client("a")
         .columnInfo("b_id")
         .then((info) => info.type),
     ).toMatch(/^int/)
@@ -197,9 +197,9 @@ describe("data caching", () => {
 })
 
 afterAll(async () => {
-  await orm.database.schema.dropTable("migration")
-  await orm.database.schema.dropTable("a")
-  await orm.database.schema.dropTable("b")
-  await orm.database.schema.dropTable("c")
-  await orm.database.destroy()
+  await orm.client.schema.dropTable("migration")
+  await orm.client.schema.dropTable("a")
+  await orm.client.schema.dropTable("b")
+  await orm.client.schema.dropTable("c")
+  await orm.client.destroy()
 })