@ghom/orm 1.0.0

package/dist/app/orm.d.ts

@@ -0,0 +1,20 @@
+import { Handler } from "@ghom/handler";
+import { Knex } from "knex";
+/**
+ * @property tablePath - path to directory that contains js files of tables
+ * @property verbose - show console logs or not
+ */
+export interface ORMConfig {
+    verbose?: boolean;
+    tablePath: string;
+}
+export declare class ORM extends Handler {
+    db: Knex;
+    ormConfig: ORMConfig;
+    /**
+     * @param ormConfig configuration for table handler or just tablePath (path to directory that contains js files of tables)
+     * @param knexConfig configuration for connect to database
+     */
+    constructor(ormConfig: ORMConfig | string, knexConfig?: Knex.Config);
+    init(): Promise<void>;
+}

package/dist/app/orm.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORM = void 0;
+const handler_1 = require("@ghom/handler");
+const knex_1 = __importDefault(require("knex"));
+const table_1 = require("./table");
+class ORM extends handler_1.Handler {
+    /**
+     * @param ormConfig configuration for table handler or just tablePath (path to directory that contains js files of tables)
+     * @param knexConfig configuration for connect to database
+     */
+    constructor(ormConfig, knexConfig = {
+        client: "sqlite3",
+        useNullAsDefault: true,
+        connection: {
+            filename: ":memory:",
+        },
+    }) {
+        super(typeof ormConfig === "string" ? ormConfig : ormConfig.tablePath);
+        this.ormConfig =
+            typeof ormConfig === "string" ? { tablePath: ormConfig } : ormConfig;
+        this.db = (0, knex_1.default)(knexConfig);
+    }
+    async init() {
+        this.once("finish", async (pathList) => {
+            const tables = await Promise.all(pathList.map(async (filepath) => {
+                return Promise.resolve().then(() => __importStar(require(filepath))).then((file) => file.default);
+            }));
+            tables.unshift(new table_1.Table({
+                name: "migration",
+                priority: Infinity,
+                setup: (table) => {
+                    table.string("table").unique().notNullable();
+                    table.integer("version").notNullable();
+                },
+            }));
+            tables.forEach((table) => (table.orm = this));
+            return Promise.all(tables
+                .sort((a, b) => {
+                return (b.options.priority ?? 0) - (a.options.priority ?? 0);
+            })
+                .map((table) => table.make()));
+        });
+        await this.load();
+    }
+}
+exports.ORM = ORM;

package/dist/app/table.d.ts

@@ -0,0 +1,32 @@
+import { Knex } from "knex";
+import { ORM } from "./orm.js";
+export interface MigrationData {
+    table: string;
+    version: number;
+}
+export interface TableOptions<Type> {
+    name: string;
+    priority?: number;
+    migrations?: {
+        [version: number]: (table: Knex.CreateTableBuilder) => void;
+    };
+    setup: (table: Knex.CreateTableBuilder) => void;
+}
+export declare class Table<Type> {
+    readonly options: TableOptions<Type>;
+    orm?: ORM;
+    constructor(options: TableOptions<Type>);
+    private get verbose();
+    get db(): Knex<any, Record<string, any>[]>;
+    get query(): Knex.QueryBuilder<Type, {
+        _base: Type;
+        _hasSelection: false;
+        _keys: never;
+        _aliases: {};
+        _single: false;
+        _intersectProps: {};
+        _unionProps: never;
+    }[]>;
+    make(): Promise<this>;
+    private migrate;
+}

package/dist/app/table.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+class Table {
+    constructor(options) {
+        this.options = options;
+    }
+    get verbose() {
+        if (!this.orm)
+            throw new Error("missing ORM");
+        return this.orm.ormConfig.verbose;
+    }
+    get db() {
+        if (!this.orm)
+            throw new Error("missing ORM");
+        return this.orm.db;
+    }
+    get query() {
+        return this.db(this.options.name);
+    }
+    async make() {
+        try {
+            await this.db.schema.createTable(this.options.name, this.options.setup);
+            if (this.verbose)
+                console.log(`created table ${this.options.name}`);
+        }
+        catch (error) {
+            if (error.toString().includes("syntax error")) {
+                if (this.verbose)
+                    console.error(`you need to implement the "setup" method in options of your ${this.options.name} table!`);
+                throw error;
+            }
+            else {
+                if (this.verbose)
+                    console.log(`loaded table ${this.options.name}`);
+            }
+        }
+        try {
+            const migrated = await this.migrate();
+            if (migrated !== false) {
+                if (this.verbose)
+                    console.log(`migrated table ${this.options.name} to version ${migrated}`);
+            }
+        }
+        catch (error) {
+            if (this.verbose)
+                console.error(error);
+        }
+        return this;
+    }
+    async migrate() {
+        if (!this.options.migrations)
+            return false;
+        const migrations = new Map(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("migration")
+            .where("table", this.options.name)
+            .first();
+        const data = fromDatabase || {
+            table: this.options.name,
+            version: -1,
+        };
+        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("migration")
+            .insert(data)
+            .onConflict("table")
+            .merge();
+        return baseVersion === data.version ? false : data.version;
+    }
+}
+exports.Table = Table;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./app/orm";
+export * from "./app/table";

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app/orm"), exports);
+__exportStar(require("./app/table"), exports);

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@ghom/orm",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "description": "TypeScript KnexJS ORM & handler",
+  "prettier": {
+    "semi": false
+  },
+  "scripts": {
+    "format": "prettier --write src tsconfig.*",
+    "build": "tsc",
+    "test": "npm run build && jest tests/test.js --detectOpenHandles",
+    "prepublishOnly": "npm run format && npm test"
+  },
+  "devDependencies": {
+    "@vscode/sqlite3": "^5.0.7",
+    "better-sqlite3": "^7.5.0",
+    "jest": "^27.5.1",
+    "prettier": "^2.5.1",
+    "typescript": "^4.5.5"
+  },
+  "dependencies": {
+    "@ghom/handler": "^1.1.0",
+    "knex": "^1.0.3"
+  }
+}

package/readme.md

@@ -0,0 +1 @@
+# TypeScript KnexJS ORM & handler

package/src/app/orm.ts

@@ -0,0 +1,70 @@
+import { Handler } from "@ghom/handler"
+import { Knex, default as knex } from "knex"
+import { MigrationData, Table } from "./table"
+
+/**
+ * @property tablePath - path to directory that contains js files of tables
+ * @property verbose - show console logs or not
+ */
+export interface ORMConfig {
+  verbose?: boolean
+  tablePath: string
+}
+
+export class ORM extends Handler {
+  db: Knex
+  ormConfig: ORMConfig
+
+  /**
+   * @param ormConfig configuration for table handler or just tablePath (path to directory that contains js files of tables)
+   * @param knexConfig configuration for connect to database
+   */
+  constructor(
+    ormConfig: ORMConfig | string,
+    knexConfig: Knex.Config = {
+      client: "sqlite3",
+      useNullAsDefault: true,
+      connection: {
+        filename: ":memory:",
+      },
+    }
+  ) {
+    super(typeof ormConfig === "string" ? ormConfig : ormConfig.tablePath)
+    this.ormConfig =
+      typeof ormConfig === "string" ? { tablePath: ormConfig } : ormConfig
+    this.db = knex(knexConfig)
+  }
+
+  async init() {
+    this.once("finish", async (pathList) => {
+      const tables: Table<any>[] = await Promise.all(
+        pathList.map(async (filepath) => {
+          return import(filepath).then((file) => file.default)
+        })
+      )
+
+      tables.unshift(
+        new Table<MigrationData>({
+          name: "migration",
+          priority: Infinity,
+          setup: (table) => {
+            table.string("table").unique().notNullable()
+            table.integer("version").notNullable()
+          },
+        })
+      )
+
+      tables.forEach((table) => (table.orm = this))
+
+      return Promise.all(
+        tables
+          .sort((a, b) => {
+            return (b.options.priority ?? 0) - (a.options.priority ?? 0)
+          })
+          .map((table) => table.make())
+      )
+    })
+
+    await this.load()
+  }
+}

package/src/app/table.ts

@@ -0,0 +1,106 @@
+import { Knex } from "knex"
+import { ORM } from "./orm.js"
+
+export interface MigrationData {
+  table: string
+  version: number
+}
+
+export interface TableOptions<Type> {
+  name: string
+  priority?: number
+  migrations?: { [version: number]: (table: Knex.CreateTableBuilder) => void }
+  setup: (table: Knex.CreateTableBuilder) => void
+}
+
+export class Table<Type> {
+  orm?: ORM
+
+  constructor(public readonly options: TableOptions<Type>) {}
+
+  private get verbose() {
+    if (!this.orm) throw new Error("missing ORM")
+    return this.orm.ormConfig.verbose
+  }
+
+  get db() {
+    if (!this.orm) throw new Error("missing ORM")
+    return this.orm.db
+  }
+
+  get query() {
+    return this.db<Type>(this.options.name)
+  }
+
+  async make(): Promise<this> {
+    try {
+      await this.db.schema.createTable(this.options.name, this.options.setup)
+      if (this.verbose) console.log(`created table ${this.options.name}`)
+    } catch (error: any) {
+      if (error.toString().includes("syntax error")) {
+        if (this.verbose)
+          console.error(
+            `you need to implement the "setup" method in options of your ${this.options.name} table!`
+          )
+
+        throw error
+      } else {
+        if (this.verbose) console.log(`loaded table ${this.options.name}`)
+      }
+    }
+
+    try {
+      const migrated = await this.migrate()
+
+      if (migrated !== false) {
+        if (this.verbose)
+          console.log(
+            `migrated table ${this.options.name} to version ${migrated}`
+          )
+      }
+    } catch (error: any) {
+      if (this.verbose) console.error(error)
+    }
+
+    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: -1,
+    }
+
+    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/index.ts

@@ -0,0 +1,2 @@
+export * from "./app/orm"
+export * from "./app/table"

package/tests/tables/a.js

@@ -0,0 +1,10 @@
+const { Table } = require("../../dist/index")
+
+module.exports = new Table({
+  name: "a",
+  priority: 0,
+  setup: (table) => {
+    table.increments("id").primary()
+    table.integer("b_id").references("id").inTable("b").notNullable()
+  },
+})

package/tests/tables/b.js

@@ -0,0 +1,13 @@
+const { Table } = require("../../dist/index")
+
+module.exports = new Table({
+  name: "b",
+  migrations: {
+    0: (table) =>
+      table.integer("c_id").references("id").inTable("c").notNullable(),
+  },
+  priority: 1,
+  setup: (table) => {
+    table.increments("id").primary()
+  },
+})

package/tests/tables/c.js

@@ -0,0 +1,9 @@
+const { Table } = require("../../dist/index")
+
+module.exports = new Table({
+  name: "c",
+  priority: 2,
+  setup: (table) => {
+    table.increments("id").primary()
+  },
+})

package/tests/test.js

@@ -0,0 +1,26 @@
+const path = require("path")
+const { ORM } = require("../dist/index")
+
+const orm = new ORM({
+  tablePath: path.join(__dirname, "tables"),
+  verbose: false,
+})
+
+beforeAll(async () => {
+  await orm.init()
+})
+
+test("tables created", async () => {
+  expect(await orm.db.schema.hasTable("migration")).toBeTruthy()
+  expect(await orm.db.schema.hasTable("a")).toBeTruthy()
+  expect(await orm.db.schema.hasTable("b")).toBeTruthy()
+  expect(await orm.db.schema.hasTable("c")).toBeTruthy()
+})
+
+test("migrations ran", async () => {
+  expect(await orm.db.schema.hasColumn("b", "c_id")).toBeTruthy()
+})
+
+afterAll(async () => {
+  await orm.db.destroy()
+})

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "CommonJS",
+    "target": "es2020",
+    "lib": ["es2020", "dom"],
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "declaration": true
+  }
+}