@ghom/orm 1.8.0 → 1.8.2

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

@@ -0,0 +1,76 @@
+import { Handler } from "@ghom/handler";
+import { Knex } from "knex";
+import { TextStyle } from "./util.js";
+import { Table } from "./table.js";
+import { ResponseCache } from "./caching";
+export interface ILogger {
+    log: (message: string) => void;
+    error: (error: string | Error) => void;
+    warn: (warning: string) => void;
+}
+export interface ORMConfig {
+    /**
+     * path to the directory that contains js files of tables
+     */
+    tableLocation: string;
+    /**
+     * database configuration
+     */
+    database?: Knex.Config;
+    /**
+     * Logger used to log the table files loaded or created.
+     */
+    logger?: ILogger;
+    /**
+     * 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;
+    };
+    /**
+     * 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[];
+    hasCachedTable(name: string): boolean;
+    hasTable(name: string): Promise<boolean>;
+    /**
+     * Handle the table files and create the tables in the database.
+     */
+    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/table.d.ts

@@ -0,0 +1,55 @@
+import { Knex } from "knex";
+import { ORM } from "./orm.js";
+import { ResponseCache } from "./caching.js";
+export interface MigrationData {
+    table: string;
+    version: number;
+}
+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 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, {
+        _base: Type;
+        _hasSelection: false;
+        _keys: never;
+        _aliases: {};
+        _single: false;
+        _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>;
+    getColumns(): Promise<Record<keyof Type & string, Knex.ColumnInfo>>;
+    getColumnNames(): Promise<Array<keyof Type & string>>;
+    isEmpty(): Promise<boolean>;
+    make(): Promise<this>;
+    private migrate;
+}

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghom/orm",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -10,10 +10,6 @@
   "prettier": {
     "semi": false
   },
-  "exports": {
-    "import": "./dist/esm/index.js",
-    "require": "./dist/cjs/index.js"
-  },
   "scripts": {
     "format": "prettier --write src tsconfig.json tests",
     "build": "rimraf dist && tsc",

package/tsconfig.json

@@ -8,6 +8,7 @@
     "lib": ["es2020", "dom"],
     "moduleResolution": "Node",
     "esModuleInterop": true,
+    "declaration": true,
     "typeRoots": ["./node_modules/@types", "./dist/typings"]
   },
   "include": ["src/**/*", "dist/typings/**/*"]

package/src/app/backup.ts

@@ -1,211 +0,0 @@
-import fs from "fs"
-import path from "path"
-import util from "util"
-import csv from "json-2-csv"
-import csvParser from "csv-parser"
-import { ORM } from "./orm.js"
-import { Table } from "./table.js"
-import {
-  DEFAULT_BACKUP_CHUNK_SIZE,
-  DEFAULT_BACKUP_LOCATION,
-  DEFAULT_LOGGER_HIGHLIGHT,
-  DEFAULT_LOGGER_RAW_VALUE,
-} from "./util.js"
-
-export async function backupTable(table: Table, dirname?: string) {
-  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: fs.WriteStream | null = 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: Table, dirname?: string) {
-  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: any[] = []
-
-      await new Promise<void>((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: ORM) {
-  const result = await Promise.allSettled([
-    orm.raw("SET session_replication_role = replica;"), // for pg
-    orm.raw("PRAGMA foreign_keys = OFF;"), // for sqlite3
-    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: ORM) {
-  const result = await Promise.allSettled([
-    orm.raw("SET session_replication_role = DEFAULT;"), // for pg
-    orm.raw("PRAGMA foreign_keys = ON;"), // for sqlite3
-    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/src/app/caching.ts

@@ -1,51 +0,0 @@
-export interface ResponseCacheData<Value> {
-  value: Value
-  expires: number
-  outdated?: boolean
-}
-
-/**
- * Advanced cache for async queries
- */
-export class ResponseCache<Params extends any[], Value> {
-  private _cache = new Map<string, ResponseCacheData<Value>>()
-
-  constructor(
-    private _request: (...params: Params) => Value,
-    private _timeout: number,
-  ) {}
-
-  get(id: string, ...params: Params): Value {
-    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: string, ...params: Params): Value {
-    this._cache.set(id, {
-      value: this._request(...params),
-      expires: Date.now() + this._timeout,
-    })
-
-    return this._cache.get(id)!.value
-  }
-
-  invalidate(): void
-  invalidate(id: string): void
-  invalidate(id?: string): void {
-    if (!id) {
-      this._cache.clear()
-
-      return
-    }
-
-    this._cache.delete(id)
-  }
-}

package/src/app/orm.ts

@@ -1,191 +0,0 @@
-import url from "url"
-import { Handler } from "@ghom/handler"
-import { Knex, default as knex } from "knex"
-import { isCJS, TextStyle } from "./util.js"
-import { MigrationData, Table } from "./table.js"
-import {
-  backupTable,
-  restoreBackup,
-  disableForeignKeys,
-  enableForeignKeys,
-} from "./backup.js"
-import { ResponseCache } from "./caching"
-
-export interface ILogger {
-  log: (message: string) => void
-  error: (error: string | Error) => void
-  warn: (warning: string) => void
-}
-
-export interface ORMConfig {
-  /**
-   * path to the directory that contains js files of tables
-   */
-  tableLocation: string
-
-  /**
-   * database configuration
-   */
-  database?: Knex.Config
-
-  /**
-   * Logger used to log the table files loaded or created.
-   */
-  logger?: ILogger
-
-  /**
-   * 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
-  }
-
-  /**
-   * Configuration for the database backups.
-   */
-  backups?: {
-    location?: string
-    chunkSize?: number
-  }
-
-  /**
-   * The cache time in milliseconds. <br>
-   * Default is `Infinity`.
-   */
-  caching?: number
-}
-
-export class ORM {
-  private _ready = false
-
-  public database: Knex
-  public handler: Handler<Table<any>>
-
-  public _rawCache: ResponseCache<[sql: string], Knex.Raw>
-
-  constructor(public config: ORMConfig) {
-    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: string) => 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: string) {
-    return this.cachedTables.some((table) => table.options.name === name)
-  }
-
-  async hasTable(name: string): Promise<boolean> {
-    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<MigrationData>({
-        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: Knex.Value): Knex.Raw {
-    if (this._ready) this.cache.invalidate()
-    return this.database.raw(sql)
-  }
-
-  cache = {
-    raw: (sql: string, anyDataUpdated?: boolean): Knex.Raw => {
-      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?: string) {
-    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?: string) {
-    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/src/app/table.ts

@@ -1,252 +0,0 @@
-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
-  version: number
-}
-
-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> {
-  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>) {}
-
-  get db() {
-    if (!this.orm) throw new Error("missing ORM")
-    return this.orm.database
-  }
-
-  get query() {
-    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"))
-      .whereRaw(where ?? "1=1")
-      .then((rows) => (rows[0] as unknown as { total: number }).total)
-  }
-
-  async hasColumn(name: keyof Type & string): Promise<boolean> {
-    return this.db.schema.hasColumn(this.options.name, name as string)
-  }
-
-  async getColumn(name: keyof Type & string): Promise<Knex.ColumnInfo> {
-    return this.db(this.options.name).columnInfo(name)
-  }
-
-  async getColumns(): Promise<Record<keyof Type & string, Knex.ColumnInfo>> {
-    return this.db(this.options.name).columnInfo()
-  }
-
-  async getColumnNames(): Promise<Array<keyof Type & string>> {
-    return this.getColumns().then(Object.keys) as Promise<
-      Array<keyof Type & string>
-    >
-  }
-
-  async isEmpty(): Promise<boolean> {
-    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 ${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: any) {
-      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!`,
-        )
-
-        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,
-                )}`
-              : ""
-          }`,
-        )
-      }
-    }
-
-    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),
-          )}`,
-        )
-      }
-    } catch (error: any) {
-      this.orm.config.logger?.error(error)
-
-      throw error
-    }
-
-    if ((await this.count()) === 0) await this.options.then?.bind(this)(this)
-
-    return this
-  }
-
-  private async migrate(): Promise<false | number> {
-    if (!this.options.migrations) return false
-
-    const migrations = new Map<
-      number,
-      (table: Knex.CreateTableBuilder) => void
-    >(
-      Object.entries(this.options.migrations)
-        .sort((a, b) => Number(a[0]) - Number(b[0]))
-        .map((entry) => [Number(entry[0]), entry[1]]),
-    )
-
-    const fromDatabase = await this.db<MigrationData>("migration")
-      .where("table", this.options.name)
-      .first()
-
-    const data = fromDatabase || {
-      table: this.options.name,
-      version: -Infinity,
-    }
-
-    const baseVersion = data.version
-
-    await this.db.schema.alterTable(this.options.name, (builder) => {
-      migrations.forEach((migration, version) => {
-        if (version <= data.version) return
-        migration(builder)
-        data.version = version
-      })
-    })
-
-    await this.db<MigrationData>("migration")
-      .insert(data)
-      .onConflict("table")
-      .merge()
-
-    return baseVersion === data.version ? false : data.version
-  }
-}

package/src/app/util.ts

@@ -1,30 +0,0 @@
-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,5 +0,0 @@
-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"