@ghom/orm 1.10.0 → 2.0.0

package/tests/{test.js → orm.test.ts}

@@ -1,20 +1,61 @@
-import dotenv from "dotenv"
-import { rimraf } from "rimraf"
-import path from "path"
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
 import fs from "fs"
+import path from "path"
+import { rimraf } from "rimraf"
 
-dotenv.config({
-  // path: path.join(process.cwd(), "tests", ".pg.env"),
-  // path: path.join(process.cwd(), "tests", ".mysql2.env"),
-})
-
-process.env.DEBUG = "knex*"
-
-import { ORM } from "../"
+import { col, ORM, type ORMConfig, Table } from "../src"
 
 import a from "./tables/a"
 import b from "./tables/b"
 import c from "./tables/c"
+import d from "./tables/d"
+
+describe("typed columns", () => {
+  test("new Table() infers types correctly", () => {
+    const userTable = new Table({
+      name: "test_user",
+      columns: (col) => ({
+        id: col.increments(),
+        username: col.string().unique(),
+        age: col.integer().nullable(),
+        role: col.enum(["admin", "user"] as const),
+        isActive: col.boolean().defaultTo(true),
+      }),
+    })
+
+    expect(userTable).toBeInstanceOf(Table)
+    expect(userTable.options.name).toBe("test_user")
+    expect("columns" in userTable.options).toBe(true)
+
+    // Type inference check - this line would fail at compile time if types weren't inferred
+    type ExpectedType = typeof userTable.$type
+    const _typeCheck: ExpectedType = {
+      id: 1,
+      username: "test",
+      age: null,
+      role: "admin",
+      isActive: true,
+    }
+  })
+
+  test("col factory creates column definitions", () => {
+    const idCol = col.increments()
+    const stringCol = col.string()
+    const nullableInt = col.integer().nullable()
+    const enumCol = col.enum(["a", "b", "c"] as const)
+
+    expect(idCol).toBeDefined()
+    expect(stringCol).toBeDefined()
+    expect(nullableInt._isNullable).toBe(true)
+    expect(enumCol).toBeDefined()
+  })
+
+  test("typed table d has correct options", () => {
+    expect(d).toBeInstanceOf(Table)
+    expect(d.options.name).toBe("d")
+    expect("columns" in d.options).toBe(true)
+  })
+})
 
 describe("unconnected ORM", () => {
   test("can be initialized with false", () => {
@@ -23,7 +64,6 @@ describe("unconnected ORM", () => {
     expect(unconnectedOrm).toBeInstanceOf(ORM)
     expect(unconnectedOrm.isConnected).toBe(false)
     expect(unconnectedOrm.config).toBe(false)
-    expect(unconnectedOrm.client).toBeUndefined()
     expect(unconnectedOrm.handler).toBeUndefined()
     expect(unconnectedOrm.cachedTables).toEqual([])
     expect(unconnectedOrm.cachedTableNames).toEqual([])
@@ -32,11 +72,12 @@ describe("unconnected ORM", () => {
   test("throws when calling methods requiring client", async () => {
     const unconnectedOrm = new ORM(false)
 
-    await expect(unconnectedOrm.init()).rejects.toThrow()
-    await expect(unconnectedOrm.hasTable("test")).rejects.toThrow()
+    expect(() => unconnectedOrm.client).toThrow()
+    expect(unconnectedOrm.init()).rejects.toThrow()
+    expect(unconnectedOrm.hasTable("test")).rejects.toThrow()
     expect(() => unconnectedOrm.raw("SELECT 1")).toThrow()
-    await expect(unconnectedOrm.createBackup()).rejects.toThrow()
-    await expect(unconnectedOrm.restoreBackup()).rejects.toThrow()
+    expect(unconnectedOrm.createBackup()).rejects.toThrow()
+    expect(unconnectedOrm.restoreBackup()).rejects.toThrow()
   })
 })
 
@@ -45,10 +86,6 @@ const orm = new ORM({
   backups: {
     location: path.join(process.cwd(), "backups"),
   },
-  database: process.env.DB_CLIENT && {
-    client: process.env.DB_CLIENT,
-    connection: process.env.DB_CONNECTION,
-  },
 })
 
 beforeAll(async () => {
@@ -61,13 +98,15 @@ describe("table management", () => {
     expect(await orm.hasTable("a")).toBeTruthy()
     expect(await orm.hasTable("b")).toBeTruthy()
     expect(await orm.hasTable("c")).toBeTruthy()
+    expect(await orm.hasTable("d")).toBeTruthy()
   })
 
-  test("table cached", async () => {
+  test("table cached", () => {
     expect(orm.hasCachedTable("migration")).toBeTruthy()
     expect(orm.hasCachedTable("a")).toBeTruthy()
     expect(orm.hasCachedTable("b")).toBeTruthy()
     expect(orm.hasCachedTable("c")).toBeTruthy()
+    expect(orm.hasCachedTable("d")).toBeTruthy()
   })
 
   test("table migrations ran", async () => {
@@ -76,28 +115,46 @@ describe("table management", () => {
 
   test("table then ran", async () => {
     const rows = await a.query.select()
+    expect(rows.length).toBe(1)
+  })
+
+  test("typed table d was created with correct columns", async () => {
+    expect(await d.hasColumn("id")).toBeTruthy()
+    expect(await d.hasColumn("name")).toBeTruthy()
+    expect(await d.hasColumn("email")).toBeTruthy()
+    expect(await d.hasColumn("age")).toBeTruthy()
+    expect(await d.hasColumn("role")).toBeTruthy()
+    expect(await d.hasColumn("isActive")).toBeTruthy()
+    expect(await d.hasColumn("metadata")).toBeTruthy()
+    expect(await d.hasColumn("createdAt")).toBeTruthy()
+  })
 
+  test("typed table d then ran", async () => {
+    const rows = await d.query.select()
     expect(rows.length).toBe(1)
+    expect(rows[0].name).toBe("Test User")
+    expect(rows[0].role).toBe("admin")
   })
 })
 
 describe("table column types", () => {
   test("increments", async () => {
-    expect(
-      await orm
-        .client("a")
-        .columnInfo("id")
-        .then((info) => info.type),
-    ).toMatch(/^int/)
+    const info = await orm.client!("a").columnInfo("id")
+    expect(info.type).toMatch(/^int/)
   })
 
   test("integer", async () => {
-    expect(
-      await orm
-        .client("a")
-        .columnInfo("b_id")
-        .then((info) => info.type),
-    ).toMatch(/^int/)
+    const info = await orm.client!("a").columnInfo("b_id")
+    expect(info.type).toMatch(/^int/)
+  })
+
+  test("typed table d column types", async () => {
+    const nameInfo = await orm.client!("d").columnInfo("name")
+    expect(nameInfo.type).toMatch(/varchar|text|character/i)
+
+    const ageInfo = await orm.client!("d").columnInfo("age")
+    expect(ageInfo.type).toMatch(/^int/)
+    expect(ageInfo.nullable).toBe(true)
   })
 })
 
@@ -105,22 +162,16 @@ describe("database extraction", () => {
   test("create backup", async () => {
     await orm.createBackup()
 
-    expect(
-      fs.existsSync(path.join(orm.config.backups.location, "a_chunk_0.csv")),
-    ).toBeTruthy()
-    expect(
-      fs.existsSync(path.join(orm.config.backups.location, "b_chunk_0.csv")),
-    ).toBeTruthy()
-    expect(
-      fs.existsSync(path.join(orm.config.backups.location, "c_chunk_0.csv")),
-    ).toBeTruthy()
+    const config = orm.config as ORMConfig
+    expect(fs.existsSync(path.join(config.backups!.location!, "a_chunk_0.csv"))).toBeTruthy()
+    expect(fs.existsSync(path.join(config.backups!.location!, "b_chunk_0.csv"))).toBeTruthy()
+    expect(fs.existsSync(path.join(config.backups!.location!, "c_chunk_0.csv"))).toBeTruthy()
+    expect(fs.existsSync(path.join(config.backups!.location!, "d_chunk_0.csv"))).toBeTruthy()
   })
 
   test("cascade delete", async () => {
     expect(await a.isEmpty()).toBeFalsy()
-
     await c.query.del()
-
     expect(await a.isEmpty()).toBeTruthy()
   })
 
@@ -130,10 +181,12 @@ describe("database extraction", () => {
     expect(await a.isEmpty()).toBeFalsy()
     expect(await b.isEmpty()).toBeFalsy()
     expect(await c.isEmpty()).toBeFalsy()
-  }, 10_000)
+    expect(await d.isEmpty()).toBeFalsy()
+  })
 
   afterAll(async () => {
-    await rimraf(orm.config.backups.location)
+    const config = orm.config as ORMConfig
+    await rimraf(config.backups!.location!)
   })
 })
 
@@ -146,12 +199,17 @@ describe("table getters", () => {
     expect(await b.getColumnNames()).toContain("c_id")
 
     expect(await c.getColumnNames()).toContain("id")
+
+    expect(await d.getColumnNames()).toContain("id")
+    expect(await d.getColumnNames()).toContain("name")
+    expect(await d.getColumnNames()).toContain("role")
   })
 
-  test("table names", async () => {
+  test("table names", () => {
     expect(orm.cachedTableNames).toContain("a")
     expect(orm.cachedTableNames).toContain("b")
     expect(orm.cachedTableNames).toContain("c")
+    expect(orm.cachedTableNames).toContain("d")
   })
 })
 
@@ -196,7 +254,7 @@ describe("data caching", () => {
       return query.select("b_id").where({ id: 1 }).first()
     })
 
-    expect(row.b_id).toBe(3)
+    expect(row!.b_id).toBe(3)
   })
 
   test("delete with caching", async () => {
@@ -221,9 +279,10 @@ describe("data caching", () => {
 })
 
 afterAll(async () => {
-  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()
+  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!.schema.dropTable("d")
+  await orm.client!.destroy()
 })

package/tests/tables/a.ts

@@ -0,0 +1,16 @@
+import { Table } from "../../src"
+
+export default new Table({
+  name: "a",
+  priority: 0,
+  columns: (col) => ({
+    id: col.increments(),
+    b_id: col.integer().unsigned().references("id").inTable("b").onDelete("CASCADE"),
+  }),
+  async then({ query }) {
+    await query.insert({
+      id: 1,
+      b_id: 1,
+    })
+  },
+})

package/tests/tables/b.ts

@@ -0,0 +1,16 @@
+import { Table } from "../../src"
+
+export default new Table({
+  name: "b",
+  priority: 1,
+  columns: (col) => ({
+    id: col.increments(),
+    c_id: col.integer().unsigned().references("id").inTable("c").onDelete("CASCADE"),
+  }),
+  async then({ query }) {
+    await query.insert({
+      id: 1,
+      c_id: 1,
+    })
+  },
+})

package/tests/tables/c.ts

@@ -0,0 +1,14 @@
+import { Table } from "../../src"
+
+export default new Table({
+  name: "c",
+  priority: 2,
+  columns: (col) => ({
+    id: col.increments(),
+  }),
+  async then({ query }) {
+    await query.insert({
+      id: 1,
+    })
+  },
+})

package/tests/tables/d.ts

@@ -0,0 +1,32 @@
+import { Table } from "../../src"
+
+/**
+ * Table using the new typed columns system.
+ * Type is automatically inferred from the column definitions.
+ */
+export default new Table({
+  name: "d",
+  priority: 0,
+  columns: (col) => ({
+    id: col.increments(),
+    name: col.string(100).unique(),
+    email: col.string(255),
+    age: col.integer().nullable().unsigned(),
+    role: col.enum(["admin", "user", "guest"] as const).defaultTo("user"),
+    isActive: col.boolean().defaultTo(true),
+    metadata: col.json<{ tags: string[]; score: number }>().nullable(),
+    createdAt: col.timestamp().nullable(),
+  }),
+  async then({ query }) {
+    await query.insert({
+      id: 1,
+      name: "Test User",
+      email: "test@example.com",
+      age: 25,
+      role: "admin",
+      isActive: true,
+      metadata: { tags: ["test"], score: 100 },
+      createdAt: new Date(),
+    })
+  },
+})

package/tsconfig.json

@@ -9,6 +9,7 @@
     "moduleResolution": "NodeNext",
     "esModuleInterop": true,
     "declaration": true,
+    "skipLibCheck": true,
     "typeRoots": ["./node_modules/@types", "./dist/typings"]
   },
   "include": ["src/**/*", "dist/typings/**/*"]

package/tests/tables/a.js

@@ -1,25 +0,0 @@
-import { Table } from "../.."
-
-/**
- * @type {Table<{ id: number; b_id: number }>}
- */
-export default new Table({
-  name: "a",
-  priority: 0,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-    table
-      .integer("b_id")
-      .unsigned()
-      .references("id")
-      .inTable("b")
-      .onDelete("cascade")
-      .notNullable()
-  },
-  async then({ query }) {
-    await query.insert({
-      id: 1,
-      b_id: 1,
-    })
-  },
-})

package/tests/tables/b.js

@@ -1,30 +0,0 @@
-import { Table } from "../.."
-
-/**
- * @type {Table<{ id: number; c_id: number }>}
- */
-export default new Table({
-  name: "b",
-  migrations: {
-    0: (table) => table.string("c_id"),
-    1: (table) => table.dropColumn("c_id"),
-    2: (table) =>
-      table
-        .integer("c_id")
-        .unsigned()
-        .references("id")
-        .inTable("c")
-        .onDelete("cascade")
-        .notNullable(),
-  },
-  priority: 1,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-  },
-  async then({ query }) {
-    await query.insert({
-      id: 1,
-      c_id: 1,
-    })
-  },
-})

package/tests/tables/c.js

@@ -1,17 +0,0 @@
-import { Table } from "../.."
-
-/**
- * @type {Table<{ id: number }>}
- */
-export default new Table({
-  name: "c",
-  priority: 2,
-  setup(table) {
-    table.increments("id").primary().notNullable()
-  },
-  async then({ query }) {
-    await query.insert({
-      id: 1,
-    })
-  },
-})