@ghom/orm 1.4.0 → 1.5.0

package/dist/cjs/app/orm.js

@@ -71,5 +71,52 @@ class ORM {
             await table.make();
         }
     }
+    /**
+     * Extract the database to a CSV file.
+     */
+    async extract(dir = process.cwd()) {
+        const tables = [...this.handler.elements.values()];
+        for (const table of tables) {
+            await this.database
+                .select()
+                .from(table.options.name)
+                .then((rows) => {
+                const csv = rows.map((row) => Object.values(row).join(",")).join("\n");
+                fs_1.default.writeFileSync(path_1.default.join(dir, `${table.options.name}.csv`), csv, "utf8");
+            });
+        }
+    }
+    /**
+     * Import a CSV file to the database.
+     */
+    async import(dir = process.cwd()) {
+        const tables = [...this.handler.elements.values()].sort((a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0));
+        for (const table of tables) {
+            const columnInfo = await table.getColumns();
+            let csv;
+            try {
+                csv = fs_1.default.readFileSync(path_1.default.join(dir, `${table.options.name}.csv`), "utf8");
+            }
+            catch (error) {
+                continue;
+            }
+            if (csv.trim().length === 0)
+                continue;
+            const rows = csv
+                .split("\n")
+                .map((row) => row.split(","))
+                .map((row) => {
+                const data = {};
+                let index = 0;
+                for (const [name, info] of Object.entries(columnInfo)) {
+                    data[name] =
+                        info.type === "integer" ? Number(row[index]) : row[index];
+                    index++;
+                }
+                return data;
+            });
+            await this.database(table.options.name).insert(rows);
+        }
+    }
 }
 exports.ORM = ORM;

package/dist/cjs/app/table.js

@@ -20,6 +20,12 @@ class Table {
     async hasColumn(name) {
         return this.db.schema.hasColumn(this.options.name, name);
     }
+    async getColumns() {
+        return this.db(this.options.name).columnInfo();
+    }
+    async getColumnNames() {
+        return this.getColumns().then(Object.keys);
+    }
     async isEmpty() {
         return this.query
             .select()

package/dist/esm/app/orm.js

@@ -45,4 +45,51 @@ export class ORM {
             await table.make();
         }
     }
+    /**
+     * Extract the database to a CSV file.
+     */
+    async extract(dir = process.cwd()) {
+        const tables = [...this.handler.elements.values()];
+        for (const table of tables) {
+            await this.database
+                .select()
+                .from(table.options.name)
+                .then((rows) => {
+                const csv = rows.map((row) => Object.values(row).join(",")).join("\n");
+                fs.writeFileSync(path.join(dir, `${table.options.name}.csv`), csv, "utf8");
+            });
+        }
+    }
+    /**
+     * Import a CSV file to the database.
+     */
+    async import(dir = process.cwd()) {
+        const tables = [...this.handler.elements.values()].sort((a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0));
+        for (const table of tables) {
+            const columnInfo = await table.getColumns();
+            let csv;
+            try {
+                csv = fs.readFileSync(path.join(dir, `${table.options.name}.csv`), "utf8");
+            }
+            catch (error) {
+                continue;
+            }
+            if (csv.trim().length === 0)
+                continue;
+            const rows = csv
+                .split("\n")
+                .map((row) => row.split(","))
+                .map((row) => {
+                const data = {};
+                let index = 0;
+                for (const [name, info] of Object.entries(columnInfo)) {
+                    data[name] =
+                        info.type === "integer" ? Number(row[index]) : row[index];
+                    index++;
+                }
+                return data;
+            });
+            await this.database(table.options.name).insert(rows);
+        }
+    }
 }

package/dist/esm/app/table.js

@@ -16,6 +16,12 @@ export class Table {
     async hasColumn(name) {
         return this.db.schema.hasColumn(this.options.name, name);
     }
+    async getColumns() {
+        return this.db(this.options.name).columnInfo();
+    }
+    async getColumnNames() {
+        return this.getColumns().then(Object.keys);
+    }
     async isEmpty() {
         return this.query
             .select()

package/dist/typings/app/orm.d.ts

@@ -4,7 +4,7 @@ import { Table } from "./table.js";
 import { Color } from "chalk";
 export interface ILogger {
     log: (...message: string[]) => void;
-    error: (error: Error | string, ...message: string[]) => void;
+    error: (error: Error | string) => void;
 }
 export interface ORMConfig {
     /**
@@ -34,4 +34,12 @@ export declare class ORM {
     handler: Handler<Table<any>>;
     constructor(config: ORMConfig);
     init(): Promise<void>;
+    /**
+     * Extract the database to a CSV file.
+     */
+    extract(dir?: string): Promise<void>;
+    /**
+     * Import a CSV file to the database.
+     */
+    import(dir?: string): Promise<void>;
 }

package/dist/typings/app/table.d.ts

@@ -28,6 +28,8 @@ export declare class Table<Type extends {}> {
         _unionProps: never;
     }[]>;
     hasColumn(name: keyof Type): Promise<boolean>;
+    getColumns(): Promise<Record<string | number | symbol, Knex.ColumnInfo>>;
+    getColumnNames(): Promise<string[]>;
     isEmpty(): Promise<boolean>;
     make(): Promise<this>;
     private migrate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghom/orm",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "license": "MIT",
   "type": "module",
   "main": "dist/esm/index.js",

package/readme.md

@@ -1 +1,78 @@
 # TypeScript KnexJS ORM & handler
+
+## Install
+
+```bash
+npm install @ghom/orm
+```
+
+## Usage
+
+```typescript
+import { ORM } from "@ghom/orm"
+
+const orm = new ORM({
+  // tables directory
+  lcoation: "./tables",
+  
+  // knex config (sqlite3 by default)
+  database: { ... },
+  
+  // custom logger (console by default)
+  logger: console,
+  loggerColors: { ... }
+})
+```
+
+## Tables
+
+The tables are automatically loaded from the `location` directory.
+
+```typescript
+// tables/user.ts
+
+import { Table } from "@ghom/orm"
+
+export default new Table({
+  name: "user",
+  
+  // the higher the priority, the earlier the table is compiled
+  priority: 0,
+  
+  // the migration are executed in order of version number
+  migrations: {
+    1: (table) => {
+      table.renameColumn("name", "username")
+    }
+  },
+  
+  // the setup is executed only once for table creation
+  setup: (table) => {
+    table.string("name").notNullable()
+    table.string("password").notNullable()
+  },
+  
+  // the then is executed after the table is created and the migrations are runned
+  then: ({ query }) => {
+    query.insert({ username: "admin", password: "admin" })
+  }
+})
+```
+
+## Query
+
+For more information about the query builder, see [knexjs.org](https://knexjs.org/).
+
+## Import/extract
+
+You can transfer the data from one instance of the ORM to another (between two database clients, for example between "pg" and "mysql2").
+
+```typescript
+await orm1.extract()
+```
+
+```typescript
+await orm2.import()
+```
+
+The SQL structure isn't transferred, only the data. You must copy the table files to the other project.

package/src/app/orm.ts

@@ -13,7 +13,7 @@ const isCJS = pack.type === "commonjs" || pack.type == void 0
 
 export interface ILogger {
   log: (...message: string[]) => void
-  error: (error: Error | string, ...message: string[]) => void
+  error: (error: Error | string) => void
 }
 
 export interface ORMConfig {
@@ -92,4 +92,71 @@ export class ORM {
       await table.make()
     }
   }
+
+  /**
+   * Extract the database to a CSV file.
+   */
+  async extract(dir = process.cwd()) {
+    const tables = [...this.handler.elements.values()]
+
+    for (const table of tables) {
+      await this.database
+        .select()
+        .from(table.options.name)
+        .then((rows) => {
+          const csv = rows.map((row) => Object.values(row).join(",")).join("\n")
+
+          fs.writeFileSync(
+            path.join(dir, `${table.options.name}.csv`),
+            csv,
+            "utf8"
+          )
+        })
+    }
+  }
+
+  /**
+   * Import a CSV file to the database.
+   */
+  async import(dir = process.cwd()) {
+    const tables = [...this.handler.elements.values()].sort(
+      (a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0)
+    )
+
+    for (const table of tables) {
+      const columnInfo = await table.getColumns()
+
+      let csv: string
+
+      try {
+        csv = fs.readFileSync(
+          path.join(dir, `${table.options.name}.csv`),
+          "utf8"
+        )
+      } catch (error) {
+        continue
+      }
+
+      if (csv.trim().length === 0) continue
+
+      const rows = csv
+        .split("\n")
+        .map((row) => row.split(","))
+        .map((row) => {
+          const data: any = {}
+
+          let index = 0
+
+          for (const [name, info] of Object.entries(columnInfo)) {
+            data[name] =
+              info.type === "integer" ? Number(row[index]) : row[index]
+            index++
+          }
+
+          return data
+        })
+
+      await this.database(table.options.name).insert(rows)
+    }
+  }
 }

package/src/app/table.ts

@@ -33,6 +33,14 @@ export class Table<Type extends {}> {
     return this.db.schema.hasColumn(this.options.name, name as string)
   }
 
+  async getColumns() {
+    return this.db(this.options.name).columnInfo()
+  }
+
+  async getColumnNames() {
+    return this.getColumns().then(Object.keys)
+  }
+
   async isEmpty(): Promise<boolean> {
     return this.query
       .select()

package/tests/test.js

@@ -1,43 +1,111 @@
-import dotenv from "dotenv"
-import path from "path"
-
-dotenv.config({ path: "./.env" })
-
-import { ORM } from "../"
-
-import a from "./tables/a"
-import b from "./tables/b"
-import c from "./tables/c"
-
-const orm = new ORM({
-  location: path.join("tests","tables")
-})
-
-beforeAll(async () => {
-  await orm.init()
-})
-
-test("tables created", async () => {
-  expect(await orm.database.schema.hasTable("migration")).toBeTruthy()
-  expect(await orm.database.schema.hasTable("a")).toBeTruthy()
-  expect(await orm.database.schema.hasTable("b")).toBeTruthy()
-  expect(await orm.database.schema.hasTable("c")).toBeTruthy()
-})
-
-test("migrations ran", async () => {
-  expect(await orm.database.schema.hasColumn("b", "c_id")).toBeTruthy()
-})
-
-test("then ran", async () => {
-  const rows = await orm.database("a").select()
-  expect(rows.length).toBe(1)
-})
-
-test("cascade delete", async () => {
-  await c.query.del()
-  expect(await a.isEmpty()).toBeTruthy()
-})
-
-afterAll(async () => {
-  await orm.database.destroy()
-})
+import dotenv from "dotenv"
+import path from "path"
+import fs from "fs"
+
+dotenv.config({ path: "./.env" })
+
+import { ORM } from "../"
+
+import a from "./tables/a"
+import b from "./tables/b"
+import c from "./tables/c"
+
+const orm = new ORM({
+  location: path.join("tests", "tables"),
+})
+
+beforeAll(async () => {
+  await orm.init()
+})
+
+describe("table management", () => {
+  test("tables created", async () => {
+    expect(await orm.database.schema.hasTable("migration")).toBeTruthy()
+    expect(await orm.database.schema.hasTable("a")).toBeTruthy()
+    expect(await orm.database.schema.hasTable("b")).toBeTruthy()
+    expect(await orm.database.schema.hasTable("c")).toBeTruthy()
+  })
+
+  test("migrations ran", async () => {
+    expect(await orm.database.schema.hasColumn("b", "c_id")).toBeTruthy()
+  })
+
+  test("then ran", async () => {
+    const rows = await orm.database("a").select()
+
+    expect(rows.length).toBe(1)
+  })
+
+  test("cascade delete", async () => {
+    await c.query.del()
+
+    expect(await a.isEmpty()).toBeTruthy()
+  })
+})
+
+describe("table column types", () => {
+  test("increments", async () => {
+    expect(
+      await orm
+        .database("a")
+        .columnInfo("id")
+        .then((info) => info.type)
+    ).toBe("integer")
+  })
+
+  test("integer", async () => {
+    expect(
+      await orm
+        .database("a")
+        .columnInfo("b_id")
+        .then((info) => info.type)
+    ).toBe("integer")
+  })
+})
+
+describe("database migration", () => {
+  beforeAll(async () => {
+    await c.query.insert({ id: 0 })
+    await b.query.insert({
+      id: 0,
+      c_id: 0,
+    })
+    await a.query.insert({
+      id: 0,
+      b_id: 0,
+    })
+  })
+
+  test("extract CSV", async () => {
+    await orm.extract()
+
+    expect(fs.existsSync("a.csv")).toBeTruthy()
+    expect(fs.existsSync("b.csv")).toBeTruthy()
+    expect(fs.existsSync("c.csv")).toBeTruthy()
+  })
+
+  test("empty tables", async () => {
+    await a.query.del()
+    await b.query.del()
+    await c.query.del()
+
+    expect(await a.isEmpty()).toBeTruthy()
+    expect(await b.isEmpty()).toBeTruthy()
+    expect(await c.isEmpty()).toBeTruthy()
+  })
+
+  test("import CSV", async () => {
+    await orm.import()
+
+    expect(await a.isEmpty()).toBeFalsy()
+    expect(await b.isEmpty()).toBeFalsy()
+    expect(await c.isEmpty()).toBeFalsy()
+  })
+})
+
+afterAll(async () => {
+  await orm.database.destroy()
+  fs.unlinkSync("a.csv")
+  fs.unlinkSync("b.csv")
+  fs.unlinkSync("c.csv")
+})