@fragno-dev/db 0.3.0 → 0.4.1

package/src/schema/create.test.ts

@@ -1,4 +1,11 @@
 import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type {
+  RawColumnValues,
+  TableToColumnValues,
+  TableToInsertValues,
+  TableToUpdateValues,
+} from "../query/simple-query-interface";
 import {
   column,
   FragnoId,
@@ -8,11 +15,6 @@ import {
   schema,
   SchemaBuilder,
 } from "./create";
-import type {
-  RawColumnValues,
-  TableToColumnValues,
-  TableToInsertValues,
-} from "../query/simple-query-interface";
 
 describe("create", () => {
   it("should create a table with columns using callback pattern", () => {
@@ -296,6 +298,135 @@ describe("create", () => {
     expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "_internalId" });
   });
 
+  it("should coerce external-id target columns to _internalId in addReference operations", () => {
+    const catalogSchema = schema("catalog", (s) => {
+      return s
+        .addTable("products", (t) => {
+          return t.addColumn("productId", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("orders", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("productRef", referenceColumn());
+        })
+        .addReference("product", {
+          type: "one",
+          from: { table: "orders", column: "productRef" },
+          to: { table: "products", column: "productId" },
+        });
+    });
+
+    const addReferenceOps = catalogSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "products", column: "_internalId" });
+  });
+
+  it("should support join-only references with foreignKey:false", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_users_email", ["email"]);
+        })
+        .addTable("invitations", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_inv_email", ["email"]);
+        })
+        .addReference("invitedUser", {
+          type: "one",
+          from: { table: "invitations", column: "email" },
+          to: { table: "users", column: "email" },
+          foreignKey: false,
+        });
+    });
+
+    const invitationsTable = userSchema.tables.invitations;
+    const invitedRelation = invitationsTable.relations["invitedUser"];
+    expect(invitedRelation).toBeDefined();
+    expect(invitedRelation.foreignKey).toBe(false);
+    expect(invitedRelation.on).toEqual([["email", "email"]]);
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "email" });
+    expect(addReferenceOps[0].config.foreignKey).toBe(false);
+  });
+
+  it("should coerce id to _internalId for join-only references", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("sessions", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("userId", referenceColumn())
+            .createIndex("idx_sessions_user", ["userId"]);
+        })
+        .addReference("sessionUser", {
+          type: "one",
+          from: { table: "sessions", column: "userId" },
+          to: { table: "users", column: "id" },
+          foreignKey: false,
+        });
+    });
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "_internalId" });
+  });
+
+  it("should coerce left-side id to _internalId for join-only references", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("memberships", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("userId", referenceColumn())
+            .createIndex("idx_memberships_user", ["userId"]);
+        })
+        .addReference("memberships", {
+          type: "many",
+          from: { table: "users", column: "id" },
+          to: { table: "memberships", column: "userId" },
+          foreignKey: false,
+        });
+    });
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.from).toEqual({ table: "users", column: "_internalId" });
+
+    const userRelation = userSchema.tables.users.relations["memberships"];
+    expect(userRelation.on).toEqual([["_internalId", "userId"]]);
+  });
+
+  it("should require indexes for join-only references", () => {
+    expect(() =>
+      schema("user", (s) => {
+        return s
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+          })
+          .addTable("invitations", (t) => {
+            return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+          })
+          .addReference("invitedUser", {
+            type: "one",
+            from: { table: "invitations", column: "email" },
+            to: { table: "users", column: "email" },
+            foreignKey: false,
+          });
+      }),
+    ).toThrow(/indexed join columns/);
+  });
+
   it("should support multiple references by calling addReference multiple times", () => {
     const userSchema = schema("user", (s) => {
       return s
@@ -489,6 +620,34 @@ describe("create", () => {
     expect(userSchema.version).toBe(3);
   });
 
+  it("should preserve user-defined columns after alterTable type updates", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .addColumn("passwordHash", column("string"));
+        })
+        .alterTable("users", (t) => {
+          expectTypeOf(t.alterColumn).parameter(0).toEqualTypeOf<"email" | "passwordHash">();
+          return t.alterColumn("passwordHash").nullable();
+        });
+    });
+
+    type UserColumns = typeof userSchema.tables.users.columns;
+    type UserColumnKeys = keyof UserColumns;
+
+    expectTypeOf<UserColumnKeys>().not.toEqualTypeOf<string>();
+    expectTypeOf<UserColumnKeys>().toEqualTypeOf<"id" | "email" | "passwordHash">();
+
+    type UpdateValues = TableToUpdateValues<typeof userSchema.tables.users>;
+    expectTypeOf<UpdateValues>().toMatchObjectType<{
+      email?: string;
+      passwordHash?: string | null;
+    }>();
+  });
+
   it("should preserve indexes when altering a table", () => {
     const userSchema = schema("user", (s) => {
       return s

package/src/schema/create.ts

@@ -1,4 +1,5 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import { createId } from "../id";
 import type { DbNow } from "../query/db-now";
 import type { Prettify } from "../util/types";
@@ -25,6 +26,16 @@ export type AnyColumn =
 export type TableSubOperation =
   | { type: "add-column"; columnName: string; column: AnyColumn }
   | { type: "add-index"; name: string; columns: string[]; unique: boolean }
+  | { type: "rename-column"; from: string; to: string }
+  | { type: "drop-column"; name: string }
+  | {
+      type: "update-column";
+      columnName: string;
+      column: AnyColumn;
+      updateNullable: boolean;
+      updateDefault: boolean;
+      updateDataType: boolean;
+    }
   | {
       type: "add-foreign-key";
       name: string;
@@ -56,6 +67,7 @@ export type SchemaOperation =
         type: "one" | "many";
         from: { table: string; column: string };
         to: { table: string; column: string };
+        foreignKey?: boolean;
       };
     };
 
@@ -77,11 +89,18 @@ class RelationInit<
   referencedTable: TTables[TTableName];
   referencer: AnyTable;
   on: [string, string][] = [];
+  foreignKey: boolean;
 
-  constructor(type: TRelationType, referencedTable: TTables[TTableName], referencer: AnyTable) {
+  constructor(
+    type: TRelationType,
+    referencedTable: TTables[TTableName],
+    referencer: AnyTable,
+    options?: { foreignKey?: boolean },
+  ) {
     this.type = type;
     this.referencedTable = referencedTable;
     this.referencer = referencer;
+    this.foreignKey = options?.foreignKey ?? true;
   }
 }
 
@@ -110,6 +129,7 @@ export class ExplicitRelationInit<
       referencer: this.referencer,
       table: this.referencedTable,
       type: this.type,
+      foreignKey: this.foreignKey,
     };
   }
 }
@@ -121,6 +141,7 @@ export interface Relation<
   id: string;
   name: string;
   type: TRelationType;
+  foreignKey?: boolean;
 
   table: TTable;
   referencer: AnyTable;
@@ -464,6 +485,29 @@ export class VersionColumn<TIn = unknown, TOut = unknown> extends Column<"intege
   }
 }
 
+function cloneColumn<TColumn extends AnyColumn>(col: TColumn): TColumn {
+  let clonedCol: AnyColumn;
+
+  if (col instanceof InternalIdColumn) {
+    clonedCol = new InternalIdColumn();
+  } else if (col instanceof VersionColumn) {
+    clonedCol = new VersionColumn();
+  } else if (col instanceof IdColumn) {
+    clonedCol = new IdColumn(col.type);
+  } else {
+    clonedCol = new Column(col.type);
+  }
+
+  clonedCol.name = col.name;
+  clonedCol.isNullable = col.isNullable;
+  clonedCol.role = col.role;
+  clonedCol.isHidden = col.isHidden;
+  clonedCol.default = col.default;
+  clonedCol.tableName = col.tableName;
+
+  return clonedCol as TColumn;
+}
+
 type ColumnInput<TType extends keyof TypeMap> =
   | TypeMap[TType]
   | (TType extends "timestamp" | "date" ? DbNow : never);
@@ -496,8 +540,8 @@ export function referenceColumn(): Column<
  * This is a CUID string that can be auto-generated or user-provided.
  * Input accepts string | FragnoId | null, output returns FragnoId.
  */
-export function idColumn(): IdColumn<"varchar(30)", string | FragnoId | null, FragnoId> {
-  const col = new IdColumn<"varchar(30)", string | FragnoId | null, FragnoId>("varchar(30)");
+export function idColumn(): IdColumn<"varchar(128)", string | FragnoId | null, FragnoId> {
+  const col = new IdColumn<"varchar(128)", string | FragnoId | null, FragnoId>("varchar(128)");
   col.role = "external-id";
   col.defaultTo$((b) => b.cuid());
   return col;
@@ -711,6 +755,32 @@ export class TableBuilder<
     >;
   }
 
+  /**
+   * Alter an existing column.
+   */
+  alterColumn<TColumnName extends NonIdColumnName<TColumns>>(
+    name: TColumnName,
+  ): ColumnAlterer<TColumns, TRelations, TIndexes, TColumnName> {
+    return {
+      nullable: <TNullable extends boolean = true>(nullable?: TNullable) => {
+        const column = this.#columns[name];
+        if (!column) {
+          throw new Error(`Unknown column name ${String(name)}`);
+        }
+
+        const cloned = cloneColumn(column) as Column<keyof TypeMap>;
+        const updated = cloned.nullable(nullable ?? true);
+        this.#columns[name] = updated as unknown as TColumns[TColumnName];
+
+        return this as unknown as TableBuilder<
+          UpdateColumn<TColumns, TColumnName, NullableColumn<TColumns[TColumnName], TNullable>>,
+          TRelations,
+          TIndexes
+        >;
+      },
+    };
+  }
+
   /**
    * Create an index on the specified columns.
    */
@@ -898,6 +968,45 @@ type ColumnsToTuple<
     : never;
 } & AnyColumn[];
 
+type UpdateColumn<
+  TColumns extends Record<string, AnyColumn>,
+  TColumnName extends keyof TColumns,
+  TUpdatedColumn extends AnyColumn,
+> = Prettify<Omit<TColumns, TColumnName> & Record<TColumnName, TUpdatedColumn>>;
+
+type NonIdColumnName<TColumns extends Record<string, AnyColumn>> = {
+  [K in keyof TColumns]: TColumns[K] extends
+    | IdColumn<IdColumnType, unknown, unknown>
+    | InternalIdColumn<unknown, unknown>
+    | VersionColumn<unknown, unknown>
+    ? never
+    : K;
+}[keyof TColumns];
+
+type NullableColumn<TColumn extends AnyColumn, TNullable extends boolean> =
+  TColumn extends Column<infer TType, infer TIn, infer TOut>
+    ? Column<
+        TType,
+        TNullable extends true ? TIn | null : Exclude<TIn, null>,
+        TNullable extends true ? TOut | null : Exclude<TOut, null>
+      >
+    : TColumn;
+
+type ColumnAlterer<
+  TColumns extends Record<string, AnyColumn>,
+  TRelations extends Record<string, AnyRelation>,
+  TIndexes extends Record<string, Index>,
+  TColumnName extends keyof TColumns,
+> = {
+  nullable<TNullable extends boolean = true>(
+    nullable?: TNullable,
+  ): TableBuilder<
+    UpdateColumn<TColumns, TColumnName, NullableColumn<TColumns[TColumnName], TNullable>>,
+    TRelations,
+    TIndexes
+  >;
+};
+
 export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
   #name: string;
   #tables: TTables;
@@ -940,6 +1049,31 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     this.#indexNames.add(name);
   }
 
+  #rebindRelations(tableName: string, newTable: AnyTable): void {
+    for (const table of Object.values(this.#tables)) {
+      for (const relation of Object.values(table.relations)) {
+        if (relation.table.name === tableName) {
+          relation.table = newTable;
+        }
+        if (relation.referencer.name === tableName) {
+          relation.referencer = newTable;
+        }
+      }
+    }
+  }
+
+  #isJoinColumnIndexed(table: AnyTable, columnName: string): boolean {
+    const idColumnName = table.getIdColumn().name;
+    const internalIdColumnName = table.getInternalIdColumn().name;
+    if (columnName === idColumnName || columnName === internalIdColumnName) {
+      return true;
+    }
+
+    return Object.values(table.indexes).some((index) =>
+      index.columnNames.some((name) => name === columnName),
+    );
+  }
+
   /**
    * Add an existing schema to this builder.
    * Merges tables and operations from the provided schema.
@@ -995,11 +1129,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
   >(
     name: TTableName,
     callback: (
-      builder: TableBuilder<
-        Record<string, AnyColumn>,
-        Record<string, AnyRelation>,
-        Record<string, Index>
-      >,
+      builder: TableBuilder<{}, Record<string, AnyRelation>, Record<string, Index>>,
     ) => TableBuilder<TColumns, TRelations, TIndexes>,
   ): SchemaBuilder<TTables & Record<TTableName, Table<TColumns, TRelations, TIndexes>>> {
     this.#version++;
@@ -1008,7 +1138,9 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       throw new Error(`Duplicate table name "${name}" in schema "${this.#name}".`);
     }
 
-    const tableBuilder = new TableBuilder(name);
+    const tableBuilder = new TableBuilder<{}, Record<string, AnyRelation>, Record<string, Index>>(
+      name,
+    );
     const result = callback(tableBuilder);
     const builtTable = result.build();
     const indexNames = result.getIndexes().map((idx) => idx.name);
@@ -1031,7 +1163,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       subOperations.push({
         type: "add-column",
         columnName: colName,
-        column: col,
+        column: cloneColumn(col),
       });
     }
 
@@ -1040,14 +1172,14 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       subOperations.push({
         type: "add-column",
         columnName: "_internalId",
-        column: builtTable.columns["_internalId"],
+        column: cloneColumn(builtTable.columns["_internalId"]),
       });
     }
     if (builtTable.columns["_version"]) {
       subOperations.push({
         type: "add-column",
         columnName: "_version",
-        column: builtTable.columns["_version"],
+        column: cloneColumn(builtTable.columns["_version"]),
       });
     }
 
@@ -1115,6 +1247,14 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
    *   from: { table: "users", column: "invitedBy" },
    *   to: { table: "users", column: "id" },
    * })
+   *
+   * // Join-only relation (no foreign key)
+   * .addReference("invitedUser", {
+   *   type: "one",
+   *   from: { table: "invitations", column: "email" },
+   *   to: { table: "users", column: "email" },
+   *   foreignKey: false,
+   * })
    * ```
    */
   addReference<
@@ -1134,6 +1274,12 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
         table: TToTableName;
         column: keyof TTables[TToTableName]["columns"];
       };
+      /**
+       * When false, defines a join-only relation without foreign key migrations.
+       * References to external-id columns still coerce to `_internalId`
+       * (including left-side external IDs for join-only).
+       */
+      foreignKey?: boolean;
     },
   ): SchemaBuilder<
     UpdateTableRelations<TTables, TFromTableName, TReferenceName, TToTableName, TRelationType>
@@ -1156,17 +1302,25 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
 
     const columnName = config.from.column as string;
     const targetColumnName = config.to.column as string;
-
-    // Foreign keys always reference internal IDs, not external IDs
-    // If user specifies "id", translate to "_internalId" for the actual FK
-    const actualTargetColumnName = targetColumnName === "id" ? "_internalId" : targetColumnName;
+    const foreignKey = config.foreignKey !== false;
 
     const column = table.columns[columnName];
-    const referencedColumn = referencedTable.columns[actualTargetColumnName];
+    const targetColumn = referencedTable.columns[targetColumnName];
 
     if (!column) {
       throw new Error(`Column ${columnName} not found in table ${config.from.table}`);
     }
+    if (!targetColumn) {
+      throw new Error(`Column ${targetColumnName} not found in table ${config.to.table}`);
+    }
+
+    // External-id columns always target the internal ID column.
+    const actualTargetColumnName =
+      targetColumn.role === "external-id"
+        ? referencedTable.getInternalIdColumn().name
+        : targetColumnName;
+
+    const referencedColumn = referencedTable.columns[actualTargetColumnName];
     if (!referencedColumn) {
       throw new Error(`Column ${actualTargetColumnName} not found in table ${config.to.table}`);
     }
@@ -1182,9 +1336,28 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       );
     }
 
-    // Create the relation (use the user-facing column name for the relation)
-    const init = new ExplicitRelationInit(config.type, referencedTable, table);
-    init.on.push([columnName, targetColumnName]);
+    if (!foreignKey) {
+      const missingIndexes: string[] = [];
+      if (!this.#isJoinColumnIndexed(table, columnName)) {
+        missingIndexes.push(`${table.name}.${columnName}`);
+      }
+      if (!this.#isJoinColumnIndexed(referencedTable, actualTargetColumnName)) {
+        missingIndexes.push(`${referencedTable.name}.${actualTargetColumnName}`);
+      }
+      if (missingIndexes.length > 0) {
+        throw new Error(
+          `Join-only relation "${referenceName}" requires indexed join columns: ${missingIndexes.join(", ")}.`,
+        );
+      }
+    }
+
+    // Join-only relations treat external IDs as internal IDs on the left side.
+    const actualFromColumnName =
+      !foreignKey && column.role === "external-id" ? table.getInternalIdColumn().name : columnName;
+
+    // Create the relation (use user-facing right-side column name)
+    const init = new ExplicitRelationInit(config.type, referencedTable, table, { foreignKey });
+    init.on.push([actualFromColumnName, targetColumnName]);
     const relation = init.init(referenceName);
 
     // Add relation to the table
@@ -1197,8 +1370,9 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       referenceName,
       config: {
         type: config.type,
-        from: { table: config.from.table, column: columnName },
+        from: { table: config.from.table, column: actualFromColumnName },
         to: { table: config.to.table, column: actualTargetColumnName },
+        foreignKey,
       },
     });
 
@@ -1210,8 +1384,8 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
   }
 
   /**
-   * Alter an existing table by adding columns or indexes.
-   * This is used for append-only schema modifications.
+   * Alter an existing table by adding columns, altering columns, or adding indexes.
+   * This is used for forward-only schema modifications.
    *
    * @param tableName - The name of the table to modify
    * @param callback - A callback that receives a table builder for adding columns/indexes
@@ -1224,6 +1398,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
    *     .addColumn("id", idColumn())
    *     .addColumn("name", column("string")))
    *   .alterTable("users", t => t
+   *     .alterColumn("name").nullable()
    *     .addColumn("email", column("string"))
    *     .addColumn("age", column("integer").nullable())
    *     .createIndex("idx_email", ["email"]))
@@ -1260,6 +1435,10 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     // Track existing columns and indexes
     const existingColumns = new Set(Object.keys(table.columns));
     const existingIndexes = new Set(Object.keys(table.indexes));
+    const existingColumnState = new Map<string, { isNullable: boolean }>();
+    for (const [colName, col] of Object.entries(table.columns)) {
+      existingColumnState.set(colName, { isNullable: col.isNullable });
+    }
 
     // Apply modifications
     const resultBuilder = callback(
@@ -1281,7 +1460,25 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
         subOperations.push({
           type: "add-column",
           columnName: colName,
-          column: newTable.columns[colName],
+          column: cloneColumn(newTable.columns[colName]),
+        });
+      }
+    }
+
+    // Track updates to existing columns
+    for (const [colName, previousState] of existingColumnState.entries()) {
+      const updatedColumn = newTable.columns[colName];
+      if (!updatedColumn) {
+        continue;
+      }
+      if (previousState.isNullable !== updatedColumn.isNullable) {
+        subOperations.push({
+          type: "update-column",
+          columnName: colName,
+          column: cloneColumn(updatedColumn),
+          updateNullable: true,
+          updateDefault: false,
+          updateDataType: false,
         });
       }
     }
@@ -1314,6 +1511,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
 
     // Update table reference in schema
     this.#tables[tableName] = newTable as unknown as TTables[TTableName];
+    this.#rebindRelations(tableName, newTable as unknown as AnyTable);
     for (const idx of resultBuilder.getIndexes()) {
       if (!existingIndexes.has(idx.name)) {
         this.#indexNames.add(idx.name);

package/src/schema/generate-id.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from "vitest";
+
 import { schema, idColumn, FragnoId } from "./create";
 import { generateId } from "./generate-id";
 

package/src/schema/serialize.test.ts

@@ -1,13 +1,14 @@
 import { assert, describe, expect, it } from "vitest";
-import { column, referenceColumn, internalIdColumn } from "./create";
-import { createSQLSerializer } from "../query/serialize/create-sql-serializer";
-import type { AnyColumn } from "./create";
+
 import type { DriverConfig } from "../adapters/generic-sql/driver-config";
 import {
   BetterSQLite3DriverConfig,
   NodePostgresDriverConfig,
   MySQL2DriverConfig,
 } from "../adapters/generic-sql/driver-config";
+import { createSQLSerializer } from "../query/serialize/create-sql-serializer";
+import { column, referenceColumn, internalIdColumn } from "./create";
+import type { AnyColumn } from "./create";
 
 function createMockDriverConfig(provider: string): DriverConfig {
   if (provider === "postgresql" || provider === "cockroachdb") {

package/src/schema/type-conversion/create-sql-type-mapper.ts

@@ -1,7 +1,7 @@
 import type { SupportedDatabase } from "../../adapters/generic-sql/driver-config";
 import type { SQLiteStorageMode } from "../../adapters/generic-sql/sqlite-storage";
-import { PostgreSQLTypeMapper } from "./dialect/postgres";
 import { MySQLTypeMapper } from "./dialect/mysql";
+import { PostgreSQLTypeMapper } from "./dialect/postgres";
 import { SQLiteTypeMapper } from "./dialect/sqlite";
 
 /**

package/src/schema/type-conversion/dialect/sqlite.ts

@@ -1,7 +1,7 @@
-import type { AnyColumn } from "../../create";
-import { SQLTypeMapper, type SQLiteDatabaseType } from "../type-mapping";
 import type { SQLiteStorageMode } from "../../../adapters/generic-sql/sqlite-storage";
 import { sqliteStorageDefault } from "../../../adapters/generic-sql/sqlite-storage";
+import type { AnyColumn } from "../../create";
+import { SQLTypeMapper, type SQLiteDatabaseType } from "../type-mapping";
 
 /**
  * SQLite-specific type mapper.

package/src/schema/type-conversion/type-mapping.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from "vitest";
+
+import { sqliteStoragePrisma } from "../../adapters/generic-sql/sqlite-storage";
 import { column, referenceColumn } from "../create";
 import { createSQLTypeMapper } from "./create-sql-type-mapper";
-import { sqliteStoragePrisma } from "../../adapters/generic-sql/sqlite-storage";
 
 describe("SQLTypeMapper", () => {
   describe("error handling", () => {