@ghom/orm 1.9.2 → 2.0.0

package/tests/orm.test.ts

@@ -0,0 +1,288 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import fs from "fs"
+import path from "path"
+import { rimraf } from "rimraf"
+
+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", () => {
+    const unconnectedOrm = new ORM(false)
+
+    expect(unconnectedOrm).toBeInstanceOf(ORM)
+    expect(unconnectedOrm.isConnected).toBe(false)
+    expect(unconnectedOrm.config).toBe(false)
+    expect(unconnectedOrm.handler).toBeUndefined()
+    expect(unconnectedOrm.cachedTables).toEqual([])
+    expect(unconnectedOrm.cachedTableNames).toEqual([])
+  })
+
+  test("throws when calling methods requiring client", async () => {
+    const unconnectedOrm = new ORM(false)
+
+    expect(() => unconnectedOrm.client).toThrow()
+    expect(unconnectedOrm.init()).rejects.toThrow()
+    expect(unconnectedOrm.hasTable("test")).rejects.toThrow()
+    expect(() => unconnectedOrm.raw("SELECT 1")).toThrow()
+    expect(unconnectedOrm.createBackup()).rejects.toThrow()
+    expect(unconnectedOrm.restoreBackup()).rejects.toThrow()
+  })
+})
+
+const orm = new ORM({
+  tableLocation: path.join(process.cwd(), "tests", "tables"),
+  backups: {
+    location: path.join(process.cwd(), "backups"),
+  },
+})
+
+beforeAll(async () => {
+  await orm.init()
+})
+
+describe("table management", () => {
+  test("tables created", async () => {
+    expect(await orm.hasTable("migration")).toBeTruthy()
+    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", () => {
+    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 () => {
+    expect(await b.hasColumn("c_id")).toBeTruthy()
+  })
+
+  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 () => {
+    const info = await orm.client!("a").columnInfo("id")
+    expect(info.type).toMatch(/^int/)
+  })
+
+  test("integer", async () => {
+    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)
+  })
+})
+
+describe("database extraction", () => {
+  test("create backup", async () => {
+    await orm.createBackup()
+
+    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()
+  })
+
+  test("restore backup", async () => {
+    await orm.restoreBackup()
+
+    expect(await a.isEmpty()).toBeFalsy()
+    expect(await b.isEmpty()).toBeFalsy()
+    expect(await c.isEmpty()).toBeFalsy()
+    expect(await d.isEmpty()).toBeFalsy()
+  })
+
+  afterAll(async () => {
+    const config = orm.config as ORMConfig
+    await rimraf(config.backups!.location!)
+  })
+})
+
+describe("table getters", () => {
+  test("table info", async () => {
+    expect(await a.getColumnNames()).toContain("id")
+    expect(await a.getColumnNames()).toContain("b_id")
+
+    expect(await b.getColumnNames()).toContain("id")
+    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", () => {
+    expect(orm.cachedTableNames).toContain("a")
+    expect(orm.cachedTableNames).toContain("b")
+    expect(orm.cachedTableNames).toContain("c")
+    expect(orm.cachedTableNames).toContain("d")
+  })
+})
+
+describe("data caching", () => {
+  beforeAll(async () => {
+    await c.query.del()
+    await c.query.insert([{ id: 1 }, { id: 2 }, { id: 3 }])
+    await b.query.insert([
+      { id: 1, c_id: 1 },
+      { id: 2, c_id: 2 },
+      { id: 3, c_id: 3 },
+    ])
+    await a.query.insert([
+      { id: 1, b_id: 1 },
+      { id: 2, b_id: 2 },
+      { id: 3, b_id: 3 },
+    ])
+  })
+
+  test("select with caching", async () => {
+    const rows = await a.cache.get("all a", (query) => {
+      return query.select("*")
+    })
+
+    expect(rows.length).toBe(3)
+  })
+
+  test("insert with caching", async () => {
+    await a.cache.set((query) => {
+      return query.insert({ id: 4, b_id: 1 })
+    })
+
+    expect(await a.cache.count()).toBe(4)
+  })
+
+  test("update with caching", async () => {
+    await a.cache.set((query) => {
+      return query.update({ b_id: 3 }).where({ id: 1 })
+    })
+
+    const row = await a.cache.get("a 1", (query) => {
+      return query.select("b_id").where({ id: 1 }).first()
+    })
+
+    expect(row!.b_id).toBe(3)
+  })
+
+  test("delete with caching", async () => {
+    await a.cache.set((query) => {
+      return query.delete().where({ id: 1 })
+    })
+
+    expect(await a.cache.count()).toBe(3)
+  })
+
+  test("cache invalidation", async () => {
+    expect(await a.cache.count()).toBe(3)
+
+    await a.query.insert({ id: 5, b_id: 1 })
+
+    expect(await a.cache.count()).toBe(3)
+
+    orm.cache.invalidate()
+
+    expect(await a.cache.count()).toBe(4)
+  })
+})
+
+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!.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,
-    })
-  },
-})

package/tests/test.js

@@ -1,205 +0,0 @@
-import dotenv from "dotenv"
-import { rimraf } from "rimraf"
-import path from "path"
-import fs from "fs"
-
-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 a from "./tables/a"
-import b from "./tables/b"
-import c from "./tables/c"
-
-const orm = new ORM({
-  tableLocation: path.join(process.cwd(), "tests", "tables"),
-  backups: {
-    location: path.join(process.cwd(), "backups"),
-  },
-  database: process.env.DB_CLIENT && {
-    client: process.env.DB_CLIENT,
-    connection: process.env.DB_CONNECTION,
-  },
-})
-
-beforeAll(async () => {
-  await orm.init()
-})
-
-describe("table management", () => {
-  test("tables created", async () => {
-    expect(await orm.hasTable("migration")).toBeTruthy()
-    expect(await orm.hasTable("a")).toBeTruthy()
-    expect(await orm.hasTable("b")).toBeTruthy()
-    expect(await orm.hasTable("c")).toBeTruthy()
-  })
-
-  test("table cached", async () => {
-    expect(orm.hasCachedTable("migration")).toBeTruthy()
-    expect(orm.hasCachedTable("a")).toBeTruthy()
-    expect(orm.hasCachedTable("b")).toBeTruthy()
-    expect(orm.hasCachedTable("c")).toBeTruthy()
-  })
-
-  test("table migrations ran", async () => {
-    expect(await b.hasColumn("c_id")).toBeTruthy()
-  })
-
-  test("table then ran", async () => {
-    const rows = await a.query.select()
-
-    expect(rows.length).toBe(1)
-  })
-})
-
-describe("table column types", () => {
-  test("increments", async () => {
-    expect(
-      await orm
-        .client("a")
-        .columnInfo("id")
-        .then((info) => info.type),
-    ).toMatch(/^int/)
-  })
-
-  test("integer", async () => {
-    expect(
-      await orm
-        .client("a")
-        .columnInfo("b_id")
-        .then((info) => info.type),
-    ).toMatch(/^int/)
-  })
-})
-
-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()
-  })
-
-  test("cascade delete", async () => {
-    expect(await a.isEmpty()).toBeFalsy()
-
-    await c.query.del()
-
-    expect(await a.isEmpty()).toBeTruthy()
-  })
-
-  test("restore backup", async () => {
-    await orm.restoreBackup()
-
-    expect(await a.isEmpty()).toBeFalsy()
-    expect(await b.isEmpty()).toBeFalsy()
-    expect(await c.isEmpty()).toBeFalsy()
-  }, 10_000)
-
-  afterAll(async () => {
-    await rimraf(orm.config.backups.location)
-  })
-})
-
-describe("table getters", () => {
-  test("table info", async () => {
-    expect(await a.getColumnNames()).toContain("id")
-    expect(await a.getColumnNames()).toContain("b_id")
-
-    expect(await b.getColumnNames()).toContain("id")
-    expect(await b.getColumnNames()).toContain("c_id")
-
-    expect(await c.getColumnNames()).toContain("id")
-  })
-
-  test("table names", async () => {
-    expect(orm.cachedTableNames).toContain("a")
-    expect(orm.cachedTableNames).toContain("b")
-    expect(orm.cachedTableNames).toContain("c")
-  })
-})
-
-describe("data caching", () => {
-  beforeAll(async () => {
-    await c.query.del()
-    await c.query.insert([{ id: 1 }, { id: 2 }, { id: 3 }])
-    await b.query.insert([
-      { id: 1, c_id: 1 },
-      { id: 2, c_id: 2 },
-      { id: 3, c_id: 3 },
-    ])
-    await a.query.insert([
-      { id: 1, b_id: 1 },
-      { id: 2, b_id: 2 },
-      { id: 3, b_id: 3 },
-    ])
-  })
-
-  test("select with caching", async () => {
-    const rows = await a.cache.get("all a", (query) => {
-      return query.select("*")
-    })
-
-    expect(rows.length).toBe(3)
-  })
-
-  test("insert with caching", async () => {
-    await a.cache.set((query) => {
-      return query.insert({ id: 4, b_id: 1 })
-    })
-
-    expect(await a.cache.count()).toBe(4)
-  })
-
-  test("update with caching", async () => {
-    await a.cache.set((query) => {
-      return query.update({ b_id: 3 }).where({ id: 1 })
-    })
-
-    const row = await a.cache.get("a 1", (query) => {
-      return query.select("b_id").where({ id: 1 }).first()
-    })
-
-    expect(row.b_id).toBe(3)
-  })
-
-  test("delete with caching", async () => {
-    await a.cache.set((query) => {
-      return query.delete().where({ id: 1 })
-    })
-
-    expect(await a.cache.count()).toBe(3)
-  })
-
-  test("cache invalidation", async () => {
-    expect(await a.cache.count()).toBe(3)
-
-    await a.query.insert({ id: 5, b_id: 1 })
-
-    expect(await a.cache.count()).toBe(3)
-
-    orm.cache.invalidate()
-
-    expect(await a.cache.count()).toBe(4)
-  })
-})
-
-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()
-})