@ghom/orm 2.1.0 → 2.1.2

package/dist/app/migration.d.ts

@@ -17,31 +17,98 @@ export interface TypedMigration<From = {}, To = {}> {
      */
     apply: (builder: Knex.AlterTableBuilder) => void;
 }
+/**
+ * Represents a sequence of typed migrations.
+ * Used internally by migrate.sequence() to preserve individual migration types.
+ *
+ * @template Migrations - Tuple of migrations in the sequence
+ */
+export interface TypedMigrationSequence<Migrations extends TypedMigration<any, any>[]> {
+    /** @internal The individual migrations in the sequence */
+    readonly __migrations__: Migrations;
+    /** @internal Type marker for columns being removed (computed from sequence) */
+    readonly _from: SequenceFromType<Migrations>;
+    /** @internal Type marker for columns being added (computed from sequence) */
+    readonly _to: SequenceToType<Migrations>;
+    /**
+     * Apply all migrations in sequence to the table builder.
+     */
+    apply: (builder: Knex.AlterTableBuilder) => void;
+}
+/**
+ * Unwrap a migration array to get the individual migration types.
+ * If M is an array, extracts the element type; otherwise returns M as-is.
+ */
+type UnwrapMigrationArray<M> = M extends readonly (infer U)[] ? U : M;
+/**
+ * Extract "From" keys from a single TypedMigration or TypedMigrationSequence.
+ * For sequences, excludes intermediate columns (those that are also in _to).
+ */
+type ExtractFromKeysSingle<M> = M extends {
+    __migrations__: infer Migrations;
+} ? Migrations extends TypedMigration<any, any>[] ? Exclude<keyof UnionToIntersection<Migrations[number]["_from"]>, keyof UnionToIntersection<Migrations[number]["_to"]>> : never : M extends TypedMigration<infer From, any> ? keyof From : never;
 /**
  * Extract all "From" keys from a union of TypedMigration.
  * These are the columns that will be removed/renamed.
+ * Handles both single migrations and arrays of migrations.
+ * Uses distributive conditional types to handle unions correctly.
  */
-type ExtractFromKeys<M> = M extends TypedMigration<infer From, any> ? keyof From : never;
+type ExtractFromKeys<M> = M extends any ? UnwrapMigrationArray<M> extends infer U ? U extends any ? ExtractFromKeysSingle<U> : never : never : never;
+/**
+ * Extract "To" type from a single TypedMigration or TypedMigrationSequence.
+ * For sequences, excludes intermediate columns (those that are also in _from).
+ */
+type ExtractToTypesSingle<M> = M extends {
+    __migrations__: infer Migrations;
+} ? Migrations extends TypedMigration<any, any>[] ? Omit<UnionToIntersection<Migrations[number]["_to"]>, keyof UnionToIntersection<Migrations[number]["_from"]>> : never : M extends TypedMigration<any, infer To> ? To : never;
 /**
  * Extract all "To" types from a union of TypedMigration and intersect them.
  * These are the columns that will be added.
+ * Handles both single migrations and arrays of migrations.
+ * Uses distributive conditional types to handle unions correctly.
  */
-type ExtractToTypes<M> = M extends TypedMigration<any, infer To> ? To : never;
+type ExtractToTypes<M> = M extends any ? UnwrapMigrationArray<M> extends infer U ? U extends any ? ExtractToTypesSingle<U> : never : never : never;
 /**
  * Convert a union to an intersection.
  * Used to combine all "To" types from migrations.
  */
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Force TypeScript to evaluate a type (expands type aliases).
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Combine all "from" types from a tuple of migrations.
+ */
+type CombineFromTypes<T extends TypedMigration<any, any>[]> = UnionToIntersection<T[number]["_from"]>;
+/**
+ * Combine all "to" types from a tuple of migrations.
+ */
+type CombineToTypes<T extends TypedMigration<any, any>[]> = UnionToIntersection<T[number]["_to"]>;
+/**
+ * Compute the final "from" type for a sequence of migrations.
+ * Excludes columns that are also added (intermediate renames).
+ */
+type SequenceFromType<T extends TypedMigration<any, any>[]> = Simplify<Omit<CombineFromTypes<T>, keyof CombineToTypes<T>>>;
+/**
+ * Compute the final "to" type for a sequence of migrations.
+ * Excludes columns that are also removed (intermediate renames).
+ */
+type SequenceToType<T extends TypedMigration<any, any>[]> = Simplify<Omit<CombineToTypes<T>, keyof CombineFromTypes<T>>>;
 /**
  * Apply all migrations to compute the final type.
  * 1. Remove all columns specified in migration "From" types
  * 2. Add all columns specified in migration "To" types
+ * Handles both single migrations and arrays of migrations.
  */
-export type ApplyMigrations<Base, Migrations extends Record<string, TypedMigration<any, any>>> = Migrations[keyof Migrations] extends infer M ? Omit<Base, ExtractFromKeys<M>> & UnionToIntersection<ExtractToTypes<M>> : Base;
+export type ApplyMigrations<Base, Migrations extends Record<string, any>> = Migrations[keyof Migrations] extends infer M ? Omit<Base, ExtractFromKeys<M>> & UnionToIntersection<ExtractToTypes<M>> : Base;
 /**
  * Compute the final table type from base columns and migrations.
+ * Supports both single migrations and arrays of migrations.
  */
-export type FinalTableType<Columns extends Record<string, ColumnDef<any, any>>, Migrations extends Record<string, TypedMigration<any, any>> = {}> = ApplyMigrations<InferColumns<Columns>, Migrations>;
+export type FinalTableType<Columns extends Record<string, ColumnDef<any, any>>, Migrations extends Record<string, any> = {}> = ApplyMigrations<InferColumns<Columns>, Migrations>;
 /**
  * Migration helpers for creating typed migrations.
  * Each helper returns a TypedMigration with appropriate type transformations.
@@ -167,5 +234,25 @@ export declare const migrate: {
      * })
      */
     raw<From = {}, To = {}>(fn: (builder: Knex.AlterTableBuilder) => void): TypedMigration<From, To>;
+    /**
+     * Combine multiple migrations into a single migration.
+     * All migrations are applied sequentially within the same alter table call.
+     * Type information from all migrations is preserved and combined.
+     *
+     * Intermediate columns (added then removed in the sequence) are excluded from the final type.
+     * For example: renameColumn("a", "b") + renameColumn("b", "c") results in only "c" being added.
+     *
+     * @param migrations - The migrations to combine
+     * @returns A typed migration sequence combining all type transformations
+     *
+     * @example
+     * migrate.sequence(
+     *   migrate.addColumn("phone", col.string()),
+     *   migrate.addColumn("address", col.string().nullable()),
+     *   migrate.addIndex(["phone"]),
+     * )
+     * // Combines: removes nothing, adds { phone: string; address: string | null }
+     */
+    sequence<T extends TypedMigration<any, any>[]>(...migrations: T): TypedMigrationSequence<T>;
 };
 export {};

package/dist/app/migration.js

@@ -195,4 +195,35 @@ export const migrate = {
             apply: fn,
         };
     },
+    /**
+     * Combine multiple migrations into a single migration.
+     * All migrations are applied sequentially within the same alter table call.
+     * Type information from all migrations is preserved and combined.
+     *
+     * Intermediate columns (added then removed in the sequence) are excluded from the final type.
+     * For example: renameColumn("a", "b") + renameColumn("b", "c") results in only "c" being added.
+     *
+     * @param migrations - The migrations to combine
+     * @returns A typed migration sequence combining all type transformations
+     *
+     * @example
+     * migrate.sequence(
+     *   migrate.addColumn("phone", col.string()),
+     *   migrate.addColumn("address", col.string().nullable()),
+     *   migrate.addIndex(["phone"]),
+     * )
+     * // Combines: removes nothing, adds { phone: string; address: string | null }
+     */
+    sequence(...migrations) {
+        return {
+            __migrations__: migrations,
+            _from: {},
+            _to: {},
+            apply: (builder) => {
+                for (const migration of migrations) {
+                    migration.apply(builder);
+                }
+            },
+        };
+    },
 };

package/dist/app/table.d.ts

@@ -1,12 +1,13 @@
 import { CachedQuery } from "@ghom/query";
 import type { Knex } from "knex";
 import { type ColumnDef, type InferColumns } from "./column.js";
-import type { FinalTableType, TypedMigration } from "./migration.js";
+import type { FinalTableType, TypedMigration, TypedMigrationSequence } from "./migration.js";
 import type { ORM } from "./orm.js";
 /**
- * A migration can be either a callback function or a TypedMigration object.
+ * A migration value is a TypedMigration or TypedMigrationSequence.
+ * Use migrate.sequence() to combine multiple migrations.
  */
-export type MigrationValue = ((builder: Knex.CreateTableBuilder) => void) | TypedMigration<any, any>;
+export type MigrationValue = TypedMigration<any, any> | TypedMigrationSequence<any>;
 export interface MigrationData {
     table: string;
     version: string;
@@ -28,25 +29,32 @@ export interface TableOptions<Columns extends Record<string, ColumnDef<any, any>
      */
     caching?: number;
     /**
-     * Database migrations to apply.
+     * Database migrations to apply using typed migrations.
      *
      * Supports three key patterns:
      * - **Numeric keys** (`"1"`, `"2"`): Sorted numerically
      * - **Numeric-prefixed keys** (`"001_init"`, `"002_add"`): Sorted by prefix
      * - **Pure string keys** (`"init"`, `"add"`): Uses insertion order
      *
-     * Can use either callback functions or TypedMigration objects.
+     * @example
+     * // Single migration
+     * migrations: {
+     *   "001_add_email": migrate.addColumn("email", col.string()),
+     * }
      *
      * @example
-     * // Using callbacks
+     * // Multiple migrations in sequence
      * migrations: {
-     *   "1": (builder) => builder.dropColumn("oldField"),
+     *   "002_add_fields": migrate.sequence(
+     *     migrate.addColumn("phone", col.string()),
+     *     migrate.addColumn("address", col.string().nullable()),
+     *   ),
      * }
      *
      * @example
-     * // Using typed migrations
+     * // Raw migration for advanced use cases
      * migrations: {
-     *   "001_add_email": migrate.addColumn("email", col.string()),
+     *   "003_custom": migrate.raw((builder) => builder.dropColumn("oldField")),
      * }
      */
     migrations?: Migrations;
@@ -104,8 +112,9 @@ export declare class Table<Columns extends Record<string, ColumnDef<any, any>> =
     /**
      * The inferred TypeScript type for rows of this table.
      * Includes base columns and all migration type transforms.
+     * Supports both single migrations and arrays of migrations.
      */
-    readonly $type: Migrations extends Record<string, TypedMigration<any, any>> ? FinalTableType<Columns, Migrations> : InferColumns<Columns>;
+    readonly $type: FinalTableType<Columns, Migrations>;
     private requireOrm;
     get client(): Knex;
     get query(): Knex.QueryBuilder<InferColumns<Columns>, {

package/dist/app/table.js

@@ -151,8 +151,26 @@ export class Table {
         const allPureString = keys.every((k) => !/^\d/.test(k));
         // Validate: no mixing allowed
         if (!allPureNumeric && !allNumericPrefix && !allPureString) {
-            throw new Error(`Table "${this.options.name}": Cannot mix migration key patterns. ` +
-                `Use one of: pure numbers (1, 2), prefixed strings ("001_x", "002_y"), or pure strings ("add_x").`);
+            // Categorize keys for helpful error message
+            const numericKeys = keys.filter((k) => /^\d+$/.test(k));
+            const prefixedKeys = keys.filter((k) => /^\d+[_\-a-zA-Z]/.test(k));
+            const stringKeys = keys.filter((k) => !/^\d/.test(k));
+            const parts = [];
+            if (numericKeys.length > 0) {
+                parts.push(`numeric keys: ${numericKeys.map((k) => `"${k}"`).join(", ")}`);
+            }
+            if (prefixedKeys.length > 0) {
+                parts.push(`prefixed keys: ${prefixedKeys.map((k) => `"${k}"`).join(", ")}`);
+            }
+            if (stringKeys.length > 0) {
+                parts.push(`string keys: ${stringKeys.map((k) => `"${k}"`).join(", ")}`);
+            }
+            throw new Error(`Table "${this.options.name}": Migration keys use mixed patterns which prevents reliable ordering.\n\n` +
+                `Found: ${parts.join(" AND ")}\n\n` +
+                `Choose ONE pattern for all keys:\n` +
+                `  - Pure numbers: "1", "2", "10" (sorted numerically)\n` +
+                `  - Prefixed strings: "001_init", "002_add" (sorted by prefix)\n` +
+                `  - Pure strings: "init", "add_email" (insertion order)`);
         }
         if (allPureNumeric) {
             // Sort purely numeric keys numerically: 1, 2, 10, 20
@@ -217,14 +235,7 @@ export class Table {
             }
             const migration = migrations[key];
             await this.client.schema.alterTable(this.options.name, (builder) => {
-                if (typeof migration === "function") {
-                    // Callback function migration
-                    migration(builder);
-                }
-                else if (migration && typeof migration === "object" && "apply" in migration) {
-                    // TypedMigration object
-                    migration.apply(builder);
-                }
+                migration.apply(builder);
             });
             data.version = key;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghom/orm",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -9,8 +9,8 @@
   "homepage": "https://github.com/GhomKrosmonaute/orm",
   "scripts": {
     "format": "biome format --write .",
-    "check": "biome check --write .",
-    "build": "rimraf dist && tsc",
+    "check": "biome check --write . && tsc --noEmit",
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
     "test": "bun test",
     "prepublishOnly": "npm run check && npm run build && npm test"
   },

package/readme.md

@@ -21,12 +21,12 @@ const orm = new ORM({
   // tables directory
   tableLocation: "./tables",
   
-  // knex config (sqlite3 by default)
-  database: { ... },
+  // knex config (sqlite3 in-memory by default)
+  database: { client: "sqlite3", connection: { filename: ":memory:" } },
   
-  // custom logger (console by default)
+  // optional custom logger (must have log, error, warn methods)
   logger: console,
-  loggerColors: { ... },
+  loggerStyles: { highlight: "cyan", rawValue: "yellow", description: "dim" },
   
   // caching options for all tables and rawCache queries (default to Infinity)
   caching: 10 * 60 * 1000,
@@ -34,6 +34,12 @@ const orm = new ORM({
   // configuration for the database backups
   backups: {
     location: "./backups",
+    chunkSize: 1000, // rows per backup file chunk
+  },
+
+  // migration behavior configuration
+  migrations: {
+    alphabeticalOrder: false // default
   }
 })
 
@@ -67,11 +73,14 @@ The tables are automatically loaded from the `tableLocation` directory. Types ar
 ```typescript
 // tables/user.ts
 
-import { Table, col } from "@ghom/orm"
+import { Table, col, migrate } from "@ghom/orm"
 
 export default new Table({
   name: "user",
   
+  // optional description for logging
+  description: "User accounts",
+  
   // the higher the priority, the earlier the table is compiled
   priority: 0,
   
@@ -81,32 +90,108 @@ export default new Table({
     username: col.string().unique(),
     password: col.string(),
     age: col.integer().nullable(),
-    role: col.enum(["admin", "user"]).defaultTo("user"),
+    role: col.enum(["admin", "user"] as const).defaultTo("user"),
   }),
   
   // migrations are executed in order based on key pattern (see Migration Keys section)
   migrations: {
-    "1": (table) => {
-      table.renameColumn("name", "username")
-    }
+    "001_add_email": migrate.addColumn("email", col.string()),
   },
   
   // then is executed after the table is created and the migrations are run (only if table is empty)
-  then: ({ query }) => {
-    query.insert({ username: "admin", password: "admin", role: "admin" })
+  then: (table) => {
+    table.query.insert({ username: "admin", password: "admin", role: "admin", email: "admin@admin.com" })
   },
   
   caching: 10 * 60 * 1000 // The table cache. Default to the ORM cache or Infinity
 })
+```
+
+The type is automatically inferred from columns + migrations:
+
+```typescript
+// { id: number; username: string; password: string; age: number | null; role: "admin" | "user"; email: string }
+```
+
+You can export and use the type from another file:
+
+```typescript
+// somewhere else in your code
+import userTable from "./tables/user"
 
-// Type is automatically inferred:
-// { id: number; username: string; password: string; age: number | null; role: "admin" | "user" }
 type User = typeof userTable.$type
 ```
 
-### Typed Migrations
+## Column Types
+
+All available column types with their TypeScript types:
+
+```typescript
+import { col } from "@ghom/orm"
+
+// Numeric types
+col.increments()       // number - auto-incrementing primary key
+col.bigIncrements()    // bigint - big auto-incrementing primary key
+col.integer()          // number
+col.bigInteger()       // bigint
+col.tinyint()          // number (0-255)
+col.smallint()         // number
+col.mediumint()        // number
+col.float(precision?, scale?)    // number
+col.double(precision?, scale?)   // number
+col.decimal(precision?, scale?)  // number
+
+// String types
+col.string(length?)    // string (default: 255)
+col.text(textType?)    // string - "text" | "mediumtext" | "longtext"
+col.uuid()             // string
+
+// Boolean
+col.boolean()          // boolean
+
+// Date/Time types
+col.date()             // Date
+col.datetime(options?) // Date - { useTz?: boolean; precision?: number }
+col.timestamp(options?) // Date - { useTz?: boolean; precision?: number }
+col.time()             // string
+
+// Other types
+col.binary(length?)    // Buffer
+col.enum(values)       // union of values - col.enum(["a", "b"] as const) => "a" | "b"
+col.json<T>()          // T (default: unknown)
+col.jsonb<T>()         // T (PostgreSQL)
+col.specificType<T>(type) // T - database-specific type
+```
+
+### Column Modifiers
+
+```typescript
+col.string()
+  .nullable()           // allows null values
+  .defaultTo(value)     // sets default value
+  .unique()             // adds unique constraint
+  .primary()            // sets as primary key
+  .index(indexName?)    // adds an index
+  .comment(comment)     // adds a column comment
+  .collate(collation)   // sets collation
+
+col.integer()
+  .unsigned()           // only positive values (numeric columns only)
+```
+
+### Foreign Key References
+
+```typescript
+col.integer()
+  .references("id")           // column name in referenced table
+  .inTable("users")           // referenced table name
+  .onDelete("CASCADE")        // CASCADE | SET NULL | RESTRICT | NO ACTION
+  .onUpdate("CASCADE")        // CASCADE | SET NULL | RESTRICT | NO ACTION
+```
+
+## Typed Migrations
 
-You can also use typed migrations that automatically update the TypeScript type:
+Use typed migrations that automatically update the TypeScript type:
 
 ```typescript
 import { Table, col, migrate } from "@ghom/orm"
@@ -127,7 +212,8 @@ export default new Table({
 // Final type: { id: number; username: string; email: string; age: number | null }
 ```
 
-Available migration helpers:
+### Migration Helpers
+
 - `migrate.addColumn(name, columnDef)` - Add a new column
 - `migrate.dropColumn(name)` - Remove a column
 - `migrate.renameColumn(oldName, newName)` - Rename a column
@@ -136,7 +222,25 @@ Available migration helpers:
 - `migrate.dropIndex(name)` - Remove an index
 - `migrate.addUnique(columns, name?)` - Add a unique constraint
 - `migrate.dropUnique(name)` - Remove a unique constraint
-- `migrate.raw(callback)` - Custom migration callback
+- `migrate.raw<From, To>(callback)` - Custom migration callback
+- `migrate.sequence(...migrations)` - Combine multiple migrations
+
+### Migration Sequences
+
+Use `migrate.sequence()` to combine multiple migrations in a single migration key:
+
+```typescript
+migrations: {
+  "001_user_updates": migrate.sequence(
+    migrate.addColumn("phone", col.string()),
+    migrate.addColumn("address", col.string().nullable()),
+    migrate.addIndex(["phone"], "idx_phone"),
+    migrate.renameColumn("name", "username"),
+  ),
+}
+```
+
+Intermediate columns (added then removed in the sequence) are excluded from the final type automatically.
 
 ## Migration Keys
 
@@ -176,21 +280,44 @@ The ORM performs a runtime check on initialization and will throw an error if th
 ## Launch a query
 
 For more information about the query builder, see [knexjs.org](https://knexjs.org/).  
-You can launch a SQL query on a table like that
+You can launch a SQL query on a table like this:
 
 ```typescript
-import user from "./tables/user"
+import userTable from "./tables/user"
 
-export async function compareHash(username, hash): Promise<boolean> {
-  const user = await user.query
+export async function compareHash(username: string, hash: string): Promise<boolean> {
+  const user = await userTable.query
     .select()
     .where("username", username)
     .first()
 
-  return user && user.password === hash
+  return user !== undefined && user.password === hash
 }
 ```
 
+### Table Utilities
+
+```typescript
+// Check if a column exists
+await table.hasColumn("email") // boolean
+
+// Get column info
+await table.getColumn("email") // Knex.ColumnInfo
+
+// Get all columns info
+await table.getColumns() // Record<string, Knex.ColumnInfo>
+
+// Get column names
+await table.getColumnNames() // string[]
+
+// Check if table is empty
+await table.isEmpty() // boolean
+
+// Count rows
+await table.count() // number
+await table.count("status = 'active'") // number with where clause
+```
+
 ## Backup
 
 You can backup the database by calling the `createBackup` and `restoreBackup` methods on the ORM instance. The backup is stored in the `config.backups.location` directory.
@@ -210,33 +337,38 @@ The cache is automatically managed by the ORM. When a table is requested from th
 ```typescript
 // get the number of rows in the table with caching
 await table.cache.count() // => 10
+await table.cache.count("status = 'active'") // with where clause
 
-// add a row with caching
+// add a row with caching (automatically invalidates cache)
 await table.cache.set((query) => {
   return query.insert({ name: "test" })
 })
 
 await table.cache.count() // => 11
 
-// Get the row with caching.
-// After the first call, the row is cached until
-// the cache is invalidate by a "cache.set" or "cache.invalidate" call
-await table.cache.get("named test", (query) => {
-  return query.where("name", "test").first()
-}) // => { name: "test" }
+// Get data with caching.
+// After the first call, the result is cached until
+// the cache is invalidated by a "cache.set" or "cache.invalidate" call
+await table.cache.get("all users", (query) => {
+  return query.select("*")
+}) // => [{ name: "test" }, ...]
 
 // delete the row without caching
 await table.query.delete().where("name", "test")
 
-await table.cache.count() // => 11 (unchanged)
+await table.cache.count() // => 11 (unchanged - cache not invalidated)
 
-// indicate that the cache is invalidate
-// and force the cache to be updated
+// manually invalidate cache
 table.cache.invalidate()
 
 await table.cache.count() // => 10
 await table.cache.count() // => 10 (no more query to the database)
 
+// update with caching (automatically invalidates cache)
+await table.cache.set((query) => {
+  return query.update({ status: "inactive" }).where("id", 1)
+})
+
 // remove all rows from a table with caching
 await table.cache.set((query) => {
   return query.truncate()
@@ -249,15 +381,21 @@ await table.cache.count() // => 0
 
 ### Raw cache
 
-You can also cache raw queries with the `<ORM>.cache.raw` property. The raw cache is useful when you have a complex query that you want to cache.
+You can also cache raw queries with the `<ORM>.cache.raw` method. The raw cache is useful when you have a complex query that you want to cache.
 
 ```typescript
 const fooUser = await orm.cache.raw("select * from user where name = 'foo'") // query the database
 const barUser = await orm.cache.raw("select * from user where name = 'bar'") // query the database
-const fooUserCached = await orm.cache.raw("select * from user where name = 'foo'") // no query to the database
+const fooUserCached = await orm.cache.raw("select * from user where name = 'foo'") // cached - no query
+
+// To invalidate the cache when you know data has changed externally:
+const result = await orm.cache.raw("select * from user", true) // anyDataUpdated = true
 ```
 
-The cache of the `<ORM>.cache.raw` method is automatically invalidated when the database is updated.
+The raw cache is invalidated when:
+- You call `orm.cache.invalidate()`
+- You use `table.cache.set()` to modify data
+- You pass `true` as the second argument to `orm.cache.raw()`
 
 ## Future features
 

package/tests/orm.test.ts

@@ -141,6 +141,94 @@ describe("typed migrations", () => {
       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", () => {
@@ -151,9 +239,9 @@ describe("migration key patterns", () => {
         id: col.increments(),
       }),
       migrations: {
-        "1": (_builder) => {},
-        "2": (_builder) => {},
-        "10": (_builder) => {},
+        1: migrate.raw(() => {}),
+        2: migrate.raw(() => {}),
+        10: migrate.raw(() => {}),
       },
     })
 
@@ -168,9 +256,9 @@ describe("migration key patterns", () => {
         id: col.increments(),
       }),
       migrations: {
-        "001_init": (_builder) => {},
-        "002_add_column": (_builder) => {},
-        "010_fix": (_builder) => {},
+        "001_init": migrate.raw(() => {}),
+        "002_add_column": migrate.raw(() => {}),
+        "010_fix": migrate.raw(() => {}),
       },
     })
 
@@ -189,15 +277,36 @@ describe("migration key patterns", () => {
         id: col.increments(),
       }),
       migrations: {
-        init: (_builder) => {},
-        add_column: (_builder) => {},
-        fix: (_builder) => {},
+        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", () => {

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/**/*"]
 }