@fragno-dev/db 0.2.1 → 0.3.0

package/src/schema/create.ts

@@ -1,4 +1,11 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { createId } from "../id";
+import type { DbNow } from "../query/db-now";
+import type { Prettify } from "../util/types";
+import { createTableStandardSchemaProps, createTableValidator } from "./validator";
+
+export { generateId } from "./generate-id";
+export { FragnoDbValidationError } from "./validator";
 
 export type AnySchema = Schema<Record<string, AnyTable>>;
 
@@ -93,13 +100,13 @@ export class ExplicitRelationInit<
   TTables extends Record<string, AnyTable>,
   TTableName extends keyof TTables,
 > extends RelationInit<TRelationType, TTables, TTableName> {
-  init(ormName: string): Relation<TRelationType, TTables[TTableName]> {
-    const id = `${this.referencer.ormName}_${this.referencedTable.ormName}`;
+  init(name: string): Relation<TRelationType, TTables[TTableName]> {
+    const id = `${this.referencer.name}_${this.referencedTable.name}`;
 
     return {
       id,
       on: this.on,
-      name: ormName,
+      name,
       referencer: this.referencer,
       table: this.referencedTable,
       type: this.type,
@@ -121,18 +128,57 @@ export interface Relation<
   on: [string, string][];
 }
 
+type PickNullable<T> = {
+  [P in keyof T as null extends T[P] ? P : never]: T[P];
+};
+
+type PickNotNullable<T> = {
+  [P in keyof T as null extends T[P] ? never : P]: T[P];
+};
+
+type RawInsertValuesFromColumns<TColumns extends Record<string, AnyColumn>> = {
+  [K in keyof TColumns as string extends K ? never : K]: TColumns[K]["$in"];
+};
+
+type TableInsertValuesFromColumns<TColumns extends Record<string, AnyColumn>> = Prettify<
+  Partial<PickNullable<RawInsertValuesFromColumns<TColumns>>> &
+    PickNotNullable<RawInsertValuesFromColumns<TColumns>>
+>;
+
+export type TableInsertValues<T extends AnyTable> = TableInsertValuesFromColumns<T["columns"]>;
+
+export type TableUnknownKeysMode = "strip" | "strict";
+
+export type TableValidationOptions = {
+  unknownKeys?: TableUnknownKeysMode;
+};
+
 export interface Table<
   TColumns extends Record<string, AnyColumn> = Record<string, AnyColumn>,
   TRelations extends Record<string, AnyRelation> = Record<string, AnyRelation>,
   TIndexes extends Record<string, Index> = Record<string, Index>,
 > {
+  /**
+   * Standard Schema-compatible validator for insert values.
+   */
+  "~standard": StandardSchemaV1.Props<
+    TableInsertValuesFromColumns<TColumns>,
+    TableInsertValuesFromColumns<TColumns>
+  >;
   name: string;
-  ormName: string;
 
   columns: TColumns;
   relations: TRelations;
   indexes: TIndexes;
 
+  /**
+   * Validate insert values at runtime.
+   */
+  validate: (
+    value: unknown,
+    options?: TableValidationOptions,
+  ) => TableInsertValuesFromColumns<TColumns>;
+
   /**
    * Get column by name
    */
@@ -201,7 +247,6 @@ export type TypeMap = {
 export class Column<TType extends keyof TypeMap, TIn = unknown, TOut = unknown> {
   type: TType;
   name: string = "";
-  ormName: string = "";
   isNullable: boolean = false;
   role: "external-id" | "internal-id" | "version" | "reference" | "regular" = "regular";
   isHidden: boolean = false;
@@ -419,9 +464,13 @@ export class VersionColumn<TIn = unknown, TOut = unknown> extends Column<"intege
   }
 }
 
+type ColumnInput<TType extends keyof TypeMap> =
+  | TypeMap[TType]
+  | (TType extends "timestamp" | "date" ? DbNow : never);
+
 export function column<TType extends keyof TypeMap>(
   type: TType,
-): Column<TType, TypeMap[TType], TypeMap[TType]> {
+): Column<TType, ColumnInput<TType>, TypeMap[TType]> {
   return new Column(type);
 }
 
@@ -577,6 +626,8 @@ export class FragnoReference {
   }
 }
 
+const validationClasses = { FragnoId, FragnoReference };
+
 type RelationType = "one" | "many";
 
 export class TableBuilder<
@@ -588,7 +639,6 @@ export class TableBuilder<
   #columns: TColumns;
   #relations: TRelations;
   #indexes: TIndexes;
-  #ormName: string = "";
   #columnOrder: string[] = [];
 
   constructor(name: string) {
@@ -624,7 +674,7 @@ export class TableBuilder<
    * Add a column to the table.
    */
   addColumn<TColumnName extends string, TColumn extends AnyColumn>(
-    ormName: TColumnName,
+    name: TColumnName,
     col: TColumn,
   ): TableBuilder<TColumns & Record<TColumnName, TColumn>, TRelations, TIndexes>;
 
@@ -632,28 +682,27 @@ export class TableBuilder<
    * Add a column to the table with simplified syntax.
    */
   addColumn<TColumnName extends string, TType extends keyof TypeMap>(
-    ormName: TColumnName,
+    name: TColumnName,
     type: TType,
   ): TableBuilder<
-    TColumns & Record<TColumnName, Column<TType, TypeMap[TType], TypeMap[TType]>>,
+    TColumns & Record<TColumnName, Column<TType, ColumnInput<TType>, TypeMap[TType]>>,
     TRelations,
     TIndexes
   >;
 
   addColumn<TColumnName extends string, TColumn extends AnyColumn, TType extends keyof TypeMap>(
-    ormName: TColumnName,
+    name: TColumnName,
     colOrType: TColumn | TType,
   ): TableBuilder<TColumns & Record<TColumnName, TColumn>, TRelations, TIndexes> {
     // Create the column if a type string was provided
     const col = typeof colOrType === "string" ? column(colOrType) : colOrType;
 
     // Set column metadata
-    col.ormName = ormName;
-    col.name = ormName;
+    col.name = name;
 
     // Add column directly to this builder
-    this.#columns[ormName] = col as unknown as TColumns[TColumnName];
-    this.#columnOrder.push(ormName);
+    this.#columns[name] = col as unknown as TColumns[TColumnName];
+    this.#columnOrder.push(name);
 
     return this as unknown as TableBuilder<
       TColumns & Record<TColumnName, TColumn>,
@@ -714,7 +763,6 @@ export class TableBuilder<
     // Auto-add _internalId and _version columns if not already present
     if (!this.#columns["_internalId"]) {
       const col = internalIdColumn();
-      col.ormName = "_internalId";
       col.name = "_internalId";
       // Safe: we're adding system columns to the internal columns object
       (this.#columns as Record<string, AnyColumn>)["_internalId"] = col;
@@ -722,18 +770,13 @@ export class TableBuilder<
 
     if (!this.#columns["_version"]) {
       const col = versionColumn();
-      col.ormName = "_version";
       col.name = "_version";
       // Safe: we're adding system columns to the internal columns object
       (this.#columns as Record<string, AnyColumn>)["_version"] = col;
     }
 
-    // Use name as ormName if ormName is not set
-    const ormName = this.#ormName || this.#name;
-
-    const table: Table<TColumns, TRelations, TIndexes> = {
+    const table = {
       name: this.#name,
-      ormName,
       columns: this.#columns,
       relations: this.#relations,
       indexes: this.#indexes,
@@ -749,7 +792,10 @@ export class TableBuilder<
       getVersionColumn: () => {
         return versionCol!;
       },
-    };
+    } as Table<TColumns, TRelations, TIndexes>;
+
+    table["~standard"] = createTableStandardSchemaProps(table, validationClasses);
+    table.validate = createTableValidator(table, validationClasses);
 
     // Set table reference and find special columns
     for (const k in this.#columns) {
@@ -785,6 +831,10 @@ export class TableBuilder<
 }
 
 export interface Schema<TTables extends Record<string, AnyTable> = Record<string, AnyTable>> {
+  /**
+   * @description The name of the schema (required).
+   */
+  name: string;
   /**
    * @description The version of the schema, automatically incremented on each change.
    */
@@ -849,11 +899,15 @@ type ColumnsToTuple<
 } & AnyColumn[];
 
 export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
+  #name: string;
   #tables: TTables;
   #version: number = 0;
   #operations: SchemaOperation[] = [];
+  #tableNames: Set<string> = new Set();
+  #indexNames: Set<string> = new Set();
 
-  constructor(existingSchema?: Schema<TTables>) {
+  constructor(name: string, existingSchema?: Schema<TTables>) {
+    this.#name = name;
     if (existingSchema) {
       this.#tables = existingSchema.tables;
       this.#version = existingSchema.version;
@@ -861,6 +915,29 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     } else {
       this.#tables = {} as TTables;
     }
+
+    for (const table of Object.values(this.#tables)) {
+      this.#registerTableName(table.name);
+      for (const index of Object.values(table.indexes)) {
+        this.#registerIndexName(index.name, table.name);
+      }
+    }
+  }
+
+  #registerTableName(name: string): void {
+    if (this.#tableNames.has(name)) {
+      throw new Error(`Duplicate table name "${name}" in schema "${this.#name}".`);
+    }
+    this.#tableNames.add(name);
+  }
+
+  #registerIndexName(name: string, tableName: string): void {
+    if (this.#indexNames.has(name)) {
+      throw new Error(
+        `Duplicate index name "${name}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${tableName}").`,
+      );
+    }
+    this.#indexNames.add(name);
   }
 
   /**
@@ -869,7 +946,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
    *
    * @example
    * ```ts
-   * const builder = new SchemaBuilder()
+   * const builder = new SchemaBuilder("combined")
    *   .add(userSchema)
    *   .add(postSchema)
    *   .addTable("comments", ...);
@@ -878,10 +955,32 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
   mergeWithExistingSchema<TNewTables extends Record<string, AnyTable>>(
     schema: Schema<TNewTables>,
   ): SchemaBuilder<TTables & TNewTables> {
+    for (const table of Object.values(schema.tables)) {
+      if (this.#tableNames.has(table.name)) {
+        throw new Error(
+          `Duplicate table name "${table.name}" in schema "${this.#name}" when merging.`,
+        );
+      }
+      for (const index of Object.values(table.indexes)) {
+        if (this.#indexNames.has(index.name)) {
+          throw new Error(
+            `Duplicate index name "${index.name}" in schema "${this.#name}" when merging (conflict on "${table.name}").`,
+          );
+        }
+      }
+    }
+
     this.#tables = { ...this.#tables, ...schema.tables } as TTables & TNewTables;
     this.#operations = [...this.#operations, ...schema.operations];
     this.#version += schema.version;
 
+    for (const table of Object.values(schema.tables)) {
+      this.#tableNames.add(table.name);
+      for (const index of Object.values(table.indexes)) {
+        this.#indexNames.add(index.name);
+      }
+    }
+
     return this as unknown as SchemaBuilder<TTables & TNewTables>;
   }
 
@@ -894,7 +993,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     TRelations extends Record<string, AnyRelation>,
     TIndexes extends Record<string, Index> = Record<string, Index>,
   >(
-    ormName: TTableName,
+    name: TTableName,
     callback: (
       builder: TableBuilder<
         Record<string, AnyColumn>,
@@ -905,10 +1004,22 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
   ): SchemaBuilder<TTables & Record<TTableName, Table<TColumns, TRelations, TIndexes>>> {
     this.#version++;
 
-    const tableBuilder = new TableBuilder(ormName);
+    if (this.#tableNames.has(name)) {
+      throw new Error(`Duplicate table name "${name}" in schema "${this.#name}".`);
+    }
+
+    const tableBuilder = new TableBuilder(name);
     const result = callback(tableBuilder);
     const builtTable = result.build();
-    builtTable.ormName = ormName;
+    const indexNames = result.getIndexes().map((idx) => idx.name);
+
+    for (const indexName of indexNames) {
+      if (this.#indexNames.has(indexName)) {
+        throw new Error(
+          `Duplicate index name "${indexName}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${name}").`,
+        );
+      }
+    }
 
     // Collect sub-operations in order
     const subOperations: TableSubOperation[] = [];
@@ -945,7 +1056,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       subOperations.push({
         type: "add-index",
         name: idx.name,
-        columns: idx.columns.map((c) => c.ormName),
+        columns: idx.columns.map((c) => c.name),
         unique: idx.unique,
       });
     }
@@ -953,13 +1064,17 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     // Add the add-table operation
     this.#operations.push({
       type: "add-table",
-      tableName: ormName,
+      tableName: name,
       operations: subOperations,
     });
 
     // Update tables map
-    this.#tables = { ...this.#tables, [ormName]: builtTable } as TTables &
+    this.#tables = { ...this.#tables, [name]: builtTable } as TTables &
       Record<TTableName, Table<TColumns, TRelations, TIndexes>>;
+    this.#tableNames.add(name);
+    for (const indexName of indexNames) {
+      this.#indexNames.add(indexName);
+    }
 
     return this as unknown as SchemaBuilder<
       TTables & Record<TTableName, Table<TColumns, TRelations, TIndexes>>
@@ -975,7 +1090,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
    * @example
    * ```ts
    * // One-to-one or many-to-one: post -> user
-   * schema(s => s
+   * schema("blog", s => s
    *   .addTable("users", t => t.addColumn("id", idColumn()))
    *   .addTable("posts", t => t
    *     .addColumn("id", idColumn())
@@ -1028,6 +1143,10 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     const table = this.#tables[config.from.table];
     const referencedTable = this.#tables[config.to.table];
 
+    if (!referenceName || referenceName.trim().length === 0) {
+      throw new Error(`referenceName is required for addReference on ${config.from.table}`);
+    }
+
     if (!table) {
       throw new Error(`Table ${config.from.table} not found in schema`);
     }
@@ -1052,6 +1171,10 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
       throw new Error(`Column ${actualTargetColumnName} not found in table ${config.to.table}`);
     }
 
+    if (table.relations[referenceName]) {
+      throw new Error(`Reference ${referenceName} already exists on table ${config.from.table}`);
+    }
+
     // Verify that reference columns are bigint (matching internal ID type)
     if (column.role === "reference" && column.type !== "bigint") {
       throw new Error(
@@ -1096,7 +1219,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
    * @example
    * ```ts
    * // Add a new column to an existing table
-   * schema(s => s
+   * schema("blog", s => s
    *   .addTable("users", t => t
    *     .addColumn("id", idColumn())
    *     .addColumn("name", column("string")))
@@ -1166,10 +1289,15 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     // Add only new indexes
     for (const idx of resultBuilder.getIndexes()) {
       if (!existingIndexes.has(idx.name)) {
+        if (this.#indexNames.has(idx.name)) {
+          throw new Error(
+            `Duplicate index name "${idx.name}" in schema "${this.#name}". Index names must be unique across tables (conflict on "${tableName}").`,
+          );
+        }
         subOperations.push({
           type: "add-index",
           name: idx.name,
-          columns: idx.columns.map((c) => c.ormName),
+          columns: idx.columns.map((c) => c.name),
           unique: idx.unique,
         });
       }
@@ -1186,6 +1314,11 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
 
     // Update table reference in schema
     this.#tables[tableName] = newTable as unknown as TTables[TTableName];
+    for (const idx of resultBuilder.getIndexes()) {
+      if (!existingIndexes.has(idx.name)) {
+        this.#indexNames.add(idx.name);
+      }
+    }
 
     // Set table name for all columns
     for (const col of Object.values(newTable.columns)) {
@@ -1206,6 +1339,7 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
     const tables = this.#tables;
 
     const schema: Schema<TTables> = {
+      name: this.#name,
       version,
       tables,
       operations,
@@ -1229,7 +1363,6 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
             }
 
             clonedCol.name = col.name;
-            clonedCol.ormName = col.ormName;
             clonedCol.isNullable = col.isNullable;
             clonedCol.role = col.role;
             clonedCol.isHidden = col.isHidden;
@@ -1238,20 +1371,28 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
             clonedColumns[colName] = clonedCol;
           }
 
-          cloneTables[k] = {
+          const clonedTable = {
             ...v,
             columns: clonedColumns,
-          };
+          } as AnyTable;
+
+          clonedTable["~standard"] = createTableStandardSchemaProps(clonedTable, validationClasses);
+          clonedTable.validate = createTableValidator(clonedTable, validationClasses);
+
+          cloneTables[k] = clonedTable;
         }
 
-        return new SchemaBuilder<TTables>({
+        const clonedSchema: Schema<TTables> = {
+          name: this.#name,
           version,
           tables: cloneTables as TTables,
           operations: [...operations],
           clone: () => {
             throw new Error("Cannot clone during clone");
           },
-        }).build();
+        };
+
+        return new SchemaBuilder<TTables>(this.#name, clonedSchema).build();
       },
     };
 
@@ -1270,19 +1411,18 @@ export class SchemaBuilder<TTables extends Record<string, AnyTable> = {}> {
  * Create a new schema with callback pattern.
  */
 export function schema<const TTables extends Record<string, AnyTable> = {}>(
+  name: string,
   callback: (builder: SchemaBuilder<{}>) => SchemaBuilder<TTables>,
 ): Schema<TTables> {
-  return callback(new SchemaBuilder()).build();
+  return callback(new SchemaBuilder(name)).build();
 }
 
-export function compileForeignKey(key: ForeignKey, nameType: "sql" | "orm" = "orm") {
+export function compileForeignKey(key: ForeignKey) {
   return {
     name: key.name,
-    table: nameType === "sql" ? key.table.name : key.table.ormName,
-    referencedTable: nameType === "sql" ? key.referencedTable.name : key.referencedTable.ormName,
-    referencedColumns: key.referencedColumns.map((col) =>
-      nameType === "sql" ? col.name : col.ormName,
-    ),
-    columns: key.columns.map((col) => (nameType === "sql" ? col.name : col.ormName)),
+    table: key.table.name,
+    referencedTable: key.referencedTable.name,
+    referencedColumns: key.referencedColumns.map((col) => col.name),
+    columns: key.columns.map((col) => col.name),
   };
 }

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

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { schema, idColumn, FragnoId } from "./create";
+import { generateId } from "./generate-id";
+
+describe("generateId", () => {
+  const testSchema = schema("test", (s) =>
+    s.addTable("users", (t) =>
+      t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+    ),
+  );
+
+  it("should generate a new FragnoId", () => {
+    const id = generateId(testSchema, "users");
+
+    expect(id).toBeInstanceOf(FragnoId);
+    expect(id.externalId).toBeDefined();
+    expect(typeof id.externalId).toBe("string");
+    expect(id.externalId.length).toBeGreaterThan(0);
+    expect(id.version).toBe(0);
+  });
+
+  it("should generate unique IDs on each call", () => {
+    const id1 = generateId(testSchema, "users");
+    const id2 = generateId(testSchema, "users");
+
+    expect(id1.externalId).not.toBe(id2.externalId);
+  });
+
+  it("should throw for non-existent table", () => {
+    expect(() => {
+      // @ts-expect-error - testing runtime error for non-existent table
+      generateId(testSchema, "nonexistent");
+    }).toThrow("Table nonexistent not found in schema");
+  });
+
+  it("should work with multiple tables", () => {
+    const multiTableSchema = schema("multitable", (s) =>
+      s
+        .addTable("users", (t) =>
+          t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+        )
+        .addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", "string")
+            .addColumn("authorId", "string"),
+        ),
+    );
+
+    const userId = generateId(multiTableSchema, "users");
+    const postId = generateId(multiTableSchema, "posts");
+
+    expect(userId).toBeInstanceOf(FragnoId);
+    expect(postId).toBeInstanceOf(FragnoId);
+    expect(userId.externalId).not.toBe(postId.externalId);
+  });
+});

package/src/schema/generate-id.ts

@@ -0,0 +1,38 @@
+import type { AnySchema } from "./create";
+import { FragnoId } from "./create";
+
+/**
+ * Generate a new ID for a table without creating a record.
+ * This is useful when you need to reference an ID before actually creating the record,
+ * or when you need to pass the ID to external services.
+ *
+ * @example
+ * ```ts
+ * const userId = generateId(mySchema, "users");
+ * // Use userId in related records or pass to external services
+ * uow.create("users", { id: userId, name: "John" });
+ * ```
+ */
+export function generateId<
+  TSchema extends AnySchema,
+  TableName extends keyof TSchema["tables"] & string,
+>(schema: TSchema, tableName: TableName): FragnoId {
+  const tableSchema = schema.tables[tableName];
+  if (!tableSchema) {
+    throw new Error(`Table ${tableName} not found in schema`);
+  }
+
+  const idColumn = tableSchema.getIdColumn();
+  const generated = idColumn.generateDefaultValue();
+  if (generated === undefined) {
+    throw new Error(`ID column ${idColumn.name} on table ${tableName} has no default generator`);
+  }
+
+  if (typeof generated !== "string") {
+    throw new Error(
+      `ID column ${idColumn.name} on table ${tableName} has no default generator that generates a string.`,
+    );
+  }
+
+  return FragnoId.fromExternal(generated, 0);
+}

package/src/schema/serialize.test.ts

@@ -131,7 +131,17 @@ describe("serialize", () => {
       it("should convert string timestamps to Date", () => {
         const timestampCol = column("timestamp");
         const time = "2024-01-01 12:30:45.123";
-        expect(deserialize(time, timestampCol, "postgresql")).toEqual(new Date(time));
+        const result = deserialize(time, timestampCol, "postgresql");
+        assert.instanceOf(result, Date);
+        expect(result.toISOString()).toBe("2024-01-01T12:30:45.123Z");
+      });
+
+      it("should treat timezone-less ISO timestamps as UTC", () => {
+        const timestampCol = column("timestamp");
+        const time = "2024-01-01T12:30:45.123";
+        const result = deserialize(time, timestampCol, "postgresql");
+        assert.instanceOf(result, Date);
+        expect(result.toISOString()).toBe("2024-01-01T12:30:45.123Z");
       });
 
       it("should convert ISO string timestamps to Date", () => {
@@ -262,7 +272,9 @@ describe("serialize", () => {
       it("should convert string timestamps to Date", () => {
         const timestampCol = column("timestamp");
         const time = "2024-01-01 12:30:45.123";
-        expect(deserialize(time, timestampCol, "cockroachdb")).toEqual(new Date(time));
+        const result = deserialize(time, timestampCol, "cockroachdb");
+        assert.instanceOf(result, Date);
+        expect(result.toISOString()).toBe("2024-01-01T12:30:45.123Z");
       });
 
       it("should convert date strings to Date", () => {

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

@@ -1,4 +1,5 @@
 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 { SQLiteTypeMapper } from "./dialect/sqlite";
@@ -10,16 +11,20 @@ import { SQLiteTypeMapper } from "./dialect/sqlite";
  * (PostgreSQL, MySQL, or SQLite).
  *
  * @param database - The database type (sqlite, postgresql, or mysql)
+ * @param sqliteStorageMode - Optional SQLite storage mode override
  * @returns Dialect-specific SQLTypeMapper instance
  */
-export function createSQLTypeMapper(database: SupportedDatabase) {
+export function createSQLTypeMapper(
+  database: SupportedDatabase,
+  sqliteStorageMode?: SQLiteStorageMode,
+) {
   switch (database) {
     case "postgresql":
       return new PostgreSQLTypeMapper(database);
     case "mysql":
       return new MySQLTypeMapper(database);
     case "sqlite":
-      return new SQLiteTypeMapper(database);
+      return new SQLiteTypeMapper(database, sqliteStorageMode);
     default: {
       const exhaustiveCheck: never = database;
       throw new Error(`Unsupported database type: ${exhaustiveCheck}`);