@fragno-dev/db 0.2.2 → 0.3.0

package/src/schema/create.ts

@@ -1,6 +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>>;
 
@@ -95,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,
@@ -123,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
    */
@@ -203,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;
@@ -421,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);
 }
 
@@ -579,6 +626,8 @@ export class FragnoReference {
   }
 }
 
+const validationClasses = { FragnoId, FragnoReference };
+
 type RelationType = "one" | "many";
 
 export class TableBuilder<
@@ -590,7 +639,6 @@ export class TableBuilder<
   #columns: TColumns;
   #relations: TRelations;
   #indexes: TIndexes;
-  #ormName: string = "";
   #columnOrder: string[] = [];
 
   constructor(name: string) {
@@ -626,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>;
 
@@ -634,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>,
@@ -716,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;
@@ -724,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,
@@ -751,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) {
@@ -787,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.
    */
@@ -851,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;
@@ -863,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);
   }
 
   /**
@@ -871,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", ...);
@@ -880,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>;
   }
 
@@ -896,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>,
@@ -907,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[] = [];
@@ -947,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,
       });
     }
@@ -955,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>>
@@ -977,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())
@@ -1030,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`);
     }
@@ -1054,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(
@@ -1098,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")))
@@ -1168,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,
         });
       }
@@ -1188,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)) {
@@ -1208,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,
@@ -1231,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;
@@ -1240,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();
       },
     };
 
@@ -1272,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

@@ -3,7 +3,7 @@ import { schema, idColumn, FragnoId } from "./create";
 import { generateId } from "./generate-id";
 
 describe("generateId", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
     ),
@@ -34,7 +34,7 @@ describe("generateId", () => {
   });
 
   it("should work with multiple tables", () => {
-    const multiTableSchema = schema((s) =>
+    const multiTableSchema = schema("multitable", (s) =>
       s
         .addTable("users", (t) =>
           t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),

package/src/schema/generate-id.ts

@@ -25,12 +25,12 @@ export function generateId<
   const idColumn = tableSchema.getIdColumn();
   const generated = idColumn.generateDefaultValue();
   if (generated === undefined) {
-    throw new Error(`ID column ${idColumn.ormName} on table ${tableName} has no default generator`);
+    throw new Error(`ID column ${idColumn.name} on table ${tableName} has no default generator`);
   }
 
   if (typeof generated !== "string") {
     throw new Error(
-      `ID column ${idColumn.ormName} on table ${tableName} has no default generator that generates a string.`,
+      `ID column ${idColumn.name} on table ${tableName} has no default generator that generates a string.`,
     );
   }
 

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}`);

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

@@ -1,5 +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";
 
 /**
  * SQLite-specific type mapper.
@@ -11,6 +13,13 @@ import { SQLTypeMapper, type SQLiteDatabaseType } from "../type-mapping";
  * - REAL for decimals
  */
 export class SQLiteTypeMapper extends SQLTypeMapper<SQLiteDatabaseType> {
+  private readonly sqliteStorageMode: SQLiteStorageMode;
+
+  constructor(database: "sqlite", sqliteStorageMode?: SQLiteStorageMode) {
+    super(database);
+    this.sqliteStorageMode = sqliteStorageMode ?? sqliteStorageDefault;
+  }
+
   protected getInternalIdType(): SQLiteDatabaseType {
     // SQLite uses INTEGER for auto-increment (INTEGER PRIMARY KEY)
     return "integer";
@@ -25,6 +34,9 @@ export class SQLiteTypeMapper extends SQLTypeMapper<SQLiteDatabaseType> {
     if ("role" in column && column.role === "reference") {
       return "integer";
     }
+    if (this.sqliteStorageMode.bigintStorage === "integer") {
+      return "integer";
+    }
     return "blob";
   }
 
@@ -50,10 +62,16 @@ export class SQLiteTypeMapper extends SQLTypeMapper<SQLiteDatabaseType> {
   }
 
   protected mapTimestamp(): SQLiteDatabaseType {
+    if (this.sqliteStorageMode.timestampStorage === "iso-text") {
+      return "text";
+    }
     return "integer";
   }
 
   protected mapDate(): SQLiteDatabaseType {
+    if (this.sqliteStorageMode.dateStorage === "iso-text") {
+      return "text";
+    }
     return "integer";
   }