@ghom/orm 2.0.0 → 2.1.1

package/tests/orm.test.ts

@@ -3,7 +3,7 @@ import fs from "fs"
 import path from "path"
 import { rimraf } from "rimraf"
 
-import { col, ORM, type ORMConfig, Table } from "../src"
+import { col, migrate, ORM, type ORMConfig, Table } from "../src"
 
 import a from "./tables/a"
 import b from "./tables/b"
@@ -57,6 +57,258 @@ describe("typed columns", () => {
   })
 })
 
+describe("typed migrations", () => {
+  test("migrate.addColumn creates TypedMigration", () => {
+    const migration = migrate.addColumn("email", col.string())
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+    expect("_from" in migration).toBe(true)
+    expect("_to" in migration).toBe(true)
+  })
+
+  test("migrate.dropColumn creates TypedMigration", () => {
+    const migration = migrate.dropColumn("oldField")
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("migrate.renameColumn creates TypedMigration", () => {
+    const migration = migrate.renameColumn("name", "username")
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("migrate.alterColumn creates TypedMigration", () => {
+    const migration = migrate.alterColumn("age", col.integer().nullable())
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("migrate.addIndex creates TypedMigration", () => {
+    const migration = migrate.addIndex(["email"], "idx_email")
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("migrate.addUnique creates TypedMigration", () => {
+    const migration = migrate.addUnique(["email"], "uniq_email")
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("migrate.raw creates TypedMigration", () => {
+    const migration = migrate.raw((builder) => {
+      builder.dropColumn("temp")
+    })
+
+    expect(migration).toBeDefined()
+    expect(migration.apply).toBeInstanceOf(Function)
+  })
+
+  test("Table with typed migrations has correct options", () => {
+    const userTable = new Table({
+      name: "test_typed_migrations",
+      columns: (col) => ({
+        id: col.increments(),
+        name: col.string(),
+      }),
+      migrations: {
+        "001_add_email": migrate.addColumn("email", col.string()),
+        "002_add_age": migrate.addColumn("age", col.integer().nullable()),
+        "003_rename_name": migrate.renameColumn("name", "username"),
+      },
+    })
+
+    expect(userTable).toBeInstanceOf(Table)
+    expect(userTable.options.migrations).toBeDefined()
+    expect(Object.keys(userTable.options.migrations!).length).toBe(3)
+
+    // Type inference check - final type includes base columns + migrations
+    // "name" is removed by renameColumn, "username" is added
+    type ExpectedType = typeof userTable.$type
+    const _typeCheck: ExpectedType = {
+      id: 1,
+      username: "test", // renamed from "name"
+      // @ts-expect-error - name is removed by renameColumn
+      name: "test",
+      email: "test@example.com",
+      age: null,
+    }
+  })
+
+  test("Table accepts migrate.sequence for multiple typed migrations", () => {
+    const userTable = new Table({
+      name: "test_sequence_migrations",
+      columns: (col) => ({
+        id: col.increments(),
+        name: col.string(),
+      }),
+      migrations: {
+        "001_multiple_changes": migrate.sequence(
+          migrate.addColumn("phone", col.string()),
+          migrate.addColumn("address", col.string().nullable()),
+          migrate.addIndex(["phone"], "idx_phone"),
+          migrate.renameColumn("name", "username"),
+          migrate.renameColumn("username", "fullname"),
+        ),
+      },
+    })
+
+    expect(userTable).toBeInstanceOf(Table)
+    expect(userTable.options.migrations).toBeDefined()
+    expect(Object.keys(userTable.options.migrations!).length).toBe(1)
+
+    // Type inference check - sequence migrations should infer types correctly
+    type ExpectedType = typeof userTable.$type
+    const _typeCheck: ExpectedType = {
+      id: 1,
+      // @ts-expect-error - name is removed by renameColumn
+      name: "test",
+      // @ts-expect-error - username is removed by renameColumn
+      username: "test",
+      fullname: "test",
+      phone: "123456789",
+      address: null,
+    }
+  })
+
+  test("Table accepts mixed single and sequence migrations", () => {
+    const userTable = new Table({
+      name: "test_mixed_migrations",
+      columns: (col) => ({
+        id: col.increments(),
+        name: col.string(),
+      }),
+      migrations: {
+        "001_add_email": migrate.addColumn("email", col.string()),
+        "002_multiple_changes": migrate.sequence(
+          migrate.addColumn("phone", col.string()),
+          migrate.addColumn("age", col.integer().nullable()),
+        ),
+        "003_add_active": migrate.addColumn("isActive", col.boolean().defaultTo(true)),
+      },
+    })
+
+    expect(userTable).toBeInstanceOf(Table)
+    expect(userTable.options.migrations).toBeDefined()
+    expect(Object.keys(userTable.options.migrations!).length).toBe(3)
+
+    // Type inference check - mixed migrations should infer all types
+    type ExpectedType = typeof userTable.$type
+    const _typeCheck: ExpectedType = {
+      id: 1,
+      name: "test",
+      email: "test@example.com",
+      phone: "123456789",
+      age: null,
+      isActive: true,
+    }
+  })
+
+  test("Table accepts migrate.sequence with raw migrations", () => {
+    const table = new Table({
+      name: "test_sequence_raw_migrations",
+      columns: (col) => ({
+        id: col.increments(),
+      }),
+      migrations: {
+        "001_multiple_raw": migrate.sequence(
+          migrate.raw((builder) => builder.string("field1")),
+          migrate.raw((builder) => builder.integer("field2")),
+        ),
+      },
+    })
+
+    expect(table).toBeInstanceOf(Table)
+    expect(table.options.migrations).toBeDefined()
+    expect(table.options.migrations!["001_multiple_raw"]).toBeDefined()
+  })
+})
+
+describe("migration key patterns", () => {
+  test("Table accepts pure numeric keys", () => {
+    const table = new Table({
+      name: "test_numeric_keys",
+      columns: (col) => ({
+        id: col.increments(),
+      }),
+      migrations: {
+        1: migrate.raw(() => {}),
+        2: migrate.raw(() => {}),
+        10: migrate.raw(() => {}),
+      },
+    })
+
+    expect(table.options.migrations).toBeDefined()
+    expect(Object.keys(table.options.migrations!)).toEqual(["1", "2", "10"])
+  })
+
+  test("Table accepts numeric-prefixed keys", () => {
+    const table = new Table({
+      name: "test_prefixed_keys",
+      columns: (col) => ({
+        id: col.increments(),
+      }),
+      migrations: {
+        "001_init": migrate.raw(() => {}),
+        "002_add_column": migrate.raw(() => {}),
+        "010_fix": migrate.raw(() => {}),
+      },
+    })
+
+    expect(table.options.migrations).toBeDefined()
+    expect(Object.keys(table.options.migrations!)).toEqual([
+      "001_init",
+      "002_add_column",
+      "010_fix",
+    ])
+  })
+
+  test("Table accepts pure string keys", () => {
+    const table = new Table({
+      name: "test_string_keys",
+      columns: (col) => ({
+        id: col.increments(),
+      }),
+      migrations: {
+        init: migrate.raw(() => {}),
+        add_column: migrate.raw(() => {}),
+        fix: migrate.raw(() => {}),
+      },
+    })
+
+    expect(table.options.migrations).toBeDefined()
+    expect(Object.keys(table.options.migrations!)).toEqual(["init", "add_column", "fix"])
+  })
+
+  test("Table rejects mixed key patterns at migration time", () => {
+    const table = new Table({
+      name: "test_mixed_keys",
+      columns: (col) => ({
+        id: col.increments(),
+      }),
+      migrations: {
+        1: migrate.raw(() => {}),
+        "001_init": migrate.raw(() => {}),
+        init: migrate.raw(() => {}),
+      },
+    })
+
+    // The error is thrown when getMigrationKeys() is called during migration
+    // This happens during make(), not during construction
+    expect(() => {
+      // Access private method to test key validation
+      ;(table as any).getMigrationKeys()
+    }).toThrow(/Migration keys use mixed patterns/)
+  })
+})
+
 describe("unconnected ORM", () => {
   test("can be initialized with false", () => {
     const unconnectedOrm = new ORM(false)

package/tests/tables/d.ts

@@ -1,9 +1,5 @@
 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,

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["tests/**/*"]
+}

package/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "compilerOptions": {
     "strict": true,
-    "rootDir": "src",
     "outDir": "dist",
     "module": "NodeNext",
     "target": "ESNext",
@@ -12,5 +11,6 @@
     "skipLibCheck": true,
     "typeRoots": ["./node_modules/@types", "./dist/typings"]
   },
-  "include": ["src/**/*", "dist/typings/**/*"]
+  "include": ["src/**/*", "dist/typings/**/*"],
+  "exclude": ["tests/**/*"]
 }