@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,9 +1,10 @@
 import { describe, it, expect } from "vitest";
+
 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 +35,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

@@ -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") {
@@ -131,7 +132,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 +273,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,6 +1,7 @@
 import type { SupportedDatabase } from "../../adapters/generic-sql/driver-config";
-import { PostgreSQLTypeMapper } from "./dialect/postgres";
+import type { SQLiteStorageMode } from "../../adapters/generic-sql/sqlite-storage";
 import { MySQLTypeMapper } from "./dialect/mysql";
+import { PostgreSQLTypeMapper } from "./dialect/postgres";
 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,3 +1,5 @@
+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";
 
@@ -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";
   }
 

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

@@ -1,5 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { column } from "../create";
+
+import { sqliteStoragePrisma } from "../../adapters/generic-sql/sqlite-storage";
+import { column, referenceColumn } from "../create";
 import { createSQLTypeMapper } from "./create-sql-type-mapper";
 
 describe("SQLTypeMapper", () => {
@@ -81,6 +83,29 @@ describe("SQLTypeMapper", () => {
     });
   });
 
+  describe("sqlite prisma storage", () => {
+    const mapper = createSQLTypeMapper("sqlite", sqliteStoragePrisma);
+
+    it("should convert timestamp to text", () => {
+      expect(mapper.getDatabaseType(column("timestamp"))).toBe("text");
+    });
+
+    it("should convert date to text", () => {
+      expect(mapper.getDatabaseType(column("date"))).toBe("text");
+    });
+
+    it("should convert bigint to integer", () => {
+      expect(mapper.getDatabaseType(column("bigint"))).toBe("integer");
+    });
+
+    it("should keep reference bigint as integer", () => {
+      const userReferenceColumn = referenceColumn();
+      userReferenceColumn.name = "userId";
+
+      expect(mapper.getDatabaseType(userReferenceColumn)).toBe("integer");
+    });
+  });
+
   describe("postgresql", () => {
     const mapper = createSQLTypeMapper("postgresql");
 

package/src/schema/validator.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from "vitest";
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+import {
+  FragnoDbValidationError,
+  FragnoId,
+  FragnoReference,
+  column,
+  idColumn,
+  referenceColumn,
+  schema,
+} from "./create";
+
+const testSchema = schema("validation", (s) => {
+  return s
+    .addTable("users", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("age", column("integer").nullable())
+        .addColumn("status", column("string").defaultTo("active"));
+    })
+    .addTable("posts", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("userId", referenceColumn())
+        .addColumn("title", column("varchar(10)"));
+    })
+    .addTable("all_types", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("nickname", column("varchar(5)"))
+        .addColumn("age", column("integer"))
+        .addColumn("score", column("decimal"))
+        .addColumn("active", column("bool"))
+        .addColumn("bytes", column("binary"))
+        .addColumn("createdAt", column("timestamp"))
+        .addColumn("birthday", column("date"))
+        .addColumn("data", column("json"))
+        .addColumn("bigValue", column("bigint"))
+        .addColumn("ref", referenceColumn())
+        .addColumn("optionalWithDefault", column("string").defaultTo("x"))
+        .addColumn("optionalNullable", column("string").nullable());
+    });
+});
+
+const getIssues = async <Output>(
+  result: StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>,
+) => {
+  const resolved = await result;
+  if (!("issues" in resolved) || !resolved.issues) {
+    throw new Error("Expected validation issues");
+  }
+
+  return resolved.issues;
+};
+
+const validAllTypes = () => ({
+  id: "id-1",
+  name: "Ada",
+  nickname: "Ada",
+  age: 30,
+  score: 12.5,
+  active: true,
+  bytes: new Uint8Array([1, 2, 3]),
+  createdAt: new Date(),
+  birthday: new Date("2000-01-01"),
+  data: { ok: true },
+  bigValue: 10n,
+  ref: "user-1",
+});
+
+describe("table validation", () => {
+  it("strips unknown keys by default", () => {
+    const users = testSchema.tables.users;
+    const result = users.validate({ id: "user-1", name: "Ada", extra: "nope" } as never);
+    expect(result).toEqual({ id: "user-1", name: "Ada" });
+  });
+
+  it("supports strict unknown keys via Standard Schema options", async () => {
+    const users = testSchema.tables.users;
+    const result = users["~standard"].validate(
+      { id: "user-1", name: "Ada", extra: "nope" },
+      { libraryOptions: { unknownKeys: "strict" } },
+    );
+
+    const issues = await getIssues(result);
+    expect(issues.length).toBeGreaterThan(0);
+  });
+
+  it("treats defaults as optional", () => {
+    const users = testSchema.tables.users;
+    expect(() => users.validate({ id: "user-1", name: "Ada" })).not.toThrow();
+  });
+
+  it("allows null for nullable columns", () => {
+    const users = testSchema.tables.users;
+    expect(() => users.validate({ id: "user-1", name: "Ada", age: null })).not.toThrow();
+  });
+
+  it("throws on missing required fields", () => {
+    const users = testSchema.tables.users;
+    expect(() => users.validate({} as never)).toThrow(FragnoDbValidationError);
+  });
+
+  it("accepts all supported column types", () => {
+    const allTypes = testSchema.tables.all_types;
+    const payload = validAllTypes();
+    const result = allTypes.validate(payload);
+    expect(result).toEqual(payload);
+  });
+
+  it("rejects non-object input", async () => {
+    const allTypes = testSchema.tables.all_types;
+    const result = allTypes["~standard"].validate("nope");
+    const issues = await getIssues(result);
+    expect(issues.length).toBeGreaterThan(0);
+  });
+
+  it("validates string and varchar length", async () => {
+    const users = testSchema.tables.users;
+    const posts = testSchema.tables.posts;
+
+    const longId = "a".repeat(129);
+    const longTitleResult = posts["~standard"].validate({
+      id: "post-1",
+      userId: "user-1",
+      title: "this is too long",
+    });
+    expect((await getIssues(longTitleResult)).length).toBeGreaterThan(0);
+
+    const longIdResult = users["~standard"].validate({ id: longId, name: "Ada" });
+    expect((await getIssues(longIdResult)).length).toBeGreaterThan(0);
+
+    const longIdFragno = new FragnoId({ externalId: longId, version: 1 });
+    const longFragnoResult = users["~standard"].validate({ id: longIdFragno, name: "Ada" });
+    expect((await getIssues(longFragnoResult)).length).toBeGreaterThan(0);
+  });
+
+  it("accepts and rejects reference values", async () => {
+    const posts = testSchema.tables.posts;
+
+    const ref = FragnoReference.fromInternal(1n);
+    const post = posts.validate({ id: "post-1", userId: ref, title: "hello" });
+    expect(post.userId).toBe(ref);
+
+    const fragnoId = FragnoId.fromExternal("user-1", 1);
+    expect(() => posts.validate({ id: "post-1", userId: fragnoId, title: "hello" })).not.toThrow();
+    expect(() => posts.validate({ id: "post-1", userId: 1n, title: "hello" })).not.toThrow();
+
+    const invalidRefResult = posts["~standard"].validate({
+      id: "post-1",
+      userId: { id: 1 },
+      title: "hello",
+    });
+    expect((await getIssues(invalidRefResult)).length).toBeGreaterThan(0);
+  });
+
+  it("accepts FragnoId values for id columns", () => {
+    const users = testSchema.tables.users;
+    const userId = FragnoId.fromExternal("user-1", 1);
+    const user = users.validate({ id: userId, name: "Ada" });
+    expect(user.id).toBe(userId);
+  });
+
+  it("validates integer, decimal, bool, bigint, binary, date, and timestamp", async () => {
+    const allTypes = testSchema.tables.all_types;
+
+    const invalidCases = [
+      { key: "name", value: 123 },
+      { key: "nickname", value: "toolong" },
+      { key: "age", value: 1.2 },
+      { key: "score", value: Number.NaN },
+      { key: "active", value: "true" },
+      { key: "bigValue", value: 1 },
+      { key: "bytes", value: "nope" },
+      { key: "createdAt", value: new Date("invalid") },
+      { key: "birthday", value: new Date("invalid") },
+    ] as const;
+
+    for (const testCase of invalidCases) {
+      const value = { ...validAllTypes(), [testCase.key]: testCase.value } as never;
+      const result = allTypes["~standard"].validate(value);
+      expect((await getIssues(result)).length).toBeGreaterThan(0);
+    }
+  });
+
+  it("rejects null for non-nullable fields", async () => {
+    const allTypes = testSchema.tables.all_types;
+    const result = allTypes["~standard"].validate({
+      ...validAllTypes(),
+      name: null,
+    });
+
+    expect((await getIssues(result)).length).toBeGreaterThan(0);
+  });
+});

package/src/schema/validator.ts

@@ -0,0 +1,232 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+import type {
+  AnyColumn,
+  Table,
+  TableInsertValues,
+  TableUnknownKeysMode,
+  TableValidationOptions,
+} from "./create";
+
+export class FragnoDbValidationError extends Error {
+  readonly issues: readonly StandardSchemaV1.Issue[];
+
+  constructor(message: string, issues: readonly StandardSchemaV1.Issue[]) {
+    super(message);
+    this.name = "FragnoDbValidationError";
+    this.issues = issues;
+  }
+}
+
+type FragnoIdCtor = typeof import("./create").FragnoId;
+type FragnoReferenceCtor = typeof import("./create").FragnoReference;
+
+type ValidationClasses = {
+  FragnoId: FragnoIdCtor;
+  FragnoReference: FragnoReferenceCtor;
+};
+
+const defaultUnknownKeysMode: TableUnknownKeysMode = "strip";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const parseVarcharLength = (type: string): number | undefined => {
+  if (!type.startsWith("varchar(") || !type.endsWith(")")) {
+    return;
+  }
+
+  const rawLength = type.slice("varchar(".length, -1);
+  const length = Number(rawLength);
+  if (!Number.isFinite(length)) {
+    return;
+  }
+
+  return length;
+};
+
+const getUnknownKeysMode = (options?: StandardSchemaV1.Options): TableUnknownKeysMode => {
+  const libraryOptions = options?.libraryOptions as TableValidationOptions | undefined;
+  return libraryOptions?.unknownKeys ?? defaultUnknownKeysMode;
+};
+
+const validateColumnValue = (
+  col: AnyColumn,
+  value: unknown,
+  classes: ValidationClasses,
+): string | undefined => {
+  if (col.role === "external-id") {
+    if (value instanceof classes.FragnoId) {
+      const maxLength = parseVarcharLength(col.type);
+      if (maxLength !== undefined && value.externalId.length > maxLength) {
+        return `String must have at most ${maxLength} characters`;
+      }
+      return;
+    }
+
+    if (typeof value === "string") {
+      const maxLength = parseVarcharLength(col.type);
+      if (maxLength !== undefined && value.length > maxLength) {
+        return `String must have at most ${maxLength} characters`;
+      }
+      return;
+    }
+
+    return "Expected string or FragnoId";
+  }
+
+  if (col.role === "reference") {
+    if (
+      value instanceof classes.FragnoReference ||
+      value instanceof classes.FragnoId ||
+      typeof value === "string" ||
+      typeof value === "bigint"
+    ) {
+      return;
+    }
+
+    return "Expected reference (string, bigint, FragnoId, or FragnoReference)";
+  }
+
+  if (col.type === "string" || col.type.startsWith("varchar(")) {
+    if (typeof value !== "string") {
+      return "Expected string";
+    }
+
+    const maxLength = parseVarcharLength(col.type);
+    if (maxLength !== undefined && value.length > maxLength) {
+      return `String must have at most ${maxLength} characters`;
+    }
+
+    return;
+  }
+
+  if (col.type === "bigint") {
+    return typeof value === "bigint" ? undefined : "Expected bigint";
+  }
+
+  if (col.type === "integer") {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      return "Expected integer";
+    }
+    return;
+  }
+
+  if (col.type === "decimal") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return "Expected number";
+    }
+    return;
+  }
+
+  if (col.type === "bool") {
+    return typeof value === "boolean" ? undefined : "Expected boolean";
+  }
+
+  if (col.type === "binary") {
+    return value instanceof Uint8Array ? undefined : "Expected Uint8Array";
+  }
+
+  if (col.type === "date" || col.type === "timestamp") {
+    if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+      return "Expected valid Date";
+    }
+    return;
+  }
+
+  if (col.type === "json") {
+    return;
+  }
+
+  return;
+};
+
+const validateTableInsertValues = <TTable extends Table>(
+  table: TTable,
+  value: unknown,
+  options: StandardSchemaV1.Options | undefined,
+  classes: ValidationClasses,
+): StandardSchemaV1.Result<TableInsertValues<TTable>> => {
+  const issues: StandardSchemaV1.Issue[] = [];
+
+  if (!isRecord(value)) {
+    return { issues: [{ message: "Expected object" }] };
+  }
+
+  const input = value as Record<string, unknown>;
+  const entries = Object.entries(table.columns).filter(([, col]) => !col.isHidden);
+  const allowedKeys = new Set(entries.map(([key]) => key));
+  const unknownKeysMode = getUnknownKeysMode(options);
+
+  if (unknownKeysMode === "strict") {
+    for (const key of Object.keys(input)) {
+      if (!allowedKeys.has(key)) {
+        issues.push({ message: `Unknown key "${key}"`, path: [key] });
+      }
+    }
+  }
+
+  const output: Record<string, unknown> = {};
+
+  for (const [key, col] of entries) {
+    const hasKey = Object.prototype.hasOwnProperty.call(input, key);
+    const colValue = hasKey ? input[key] : undefined;
+    const allowsUndefined = col.isNullable || col.default !== undefined;
+    const allowsNull = col.isNullable;
+
+    if (colValue === undefined) {
+      if (!allowsUndefined) {
+        issues.push({ message: "Required", path: [key] });
+      }
+      continue;
+    }
+
+    if (colValue === null) {
+      if (!allowsNull) {
+        issues.push({ message: "Required", path: [key] });
+      } else {
+        output[key] = null;
+      }
+      continue;
+    }
+
+    const issue = validateColumnValue(col, colValue, classes);
+    if (issue) {
+      issues.push({ message: issue, path: [key] });
+      continue;
+    }
+
+    output[key] = colValue;
+  }
+
+  if (issues.length > 0) {
+    return { issues };
+  }
+
+  return { value: output as TableInsertValues<TTable> };
+};
+
+export const createTableStandardSchemaProps = <TTable extends Table>(
+  table: TTable,
+  classes: ValidationClasses,
+): StandardSchemaV1.Props<TableInsertValues<TTable>, TableInsertValues<TTable>> => ({
+  version: 1,
+  vendor: "fragno-db",
+  validate: (value: unknown, options?: StandardSchemaV1.Options) =>
+    validateTableInsertValues(table, value, options, classes),
+});
+
+export const createTableValidator = <TTable extends Table>(
+  table: TTable,
+  classes: ValidationClasses,
+) => {
+  return (value: unknown, options?: TableValidationOptions) => {
+    const result = validateTableInsertValues(table, value, { libraryOptions: options }, classes);
+
+    if (result.issues) {
+      throw new FragnoDbValidationError("Validation failed", result.issues);
+    }
+
+    return result.value as TableInsertValues<TTable>;
+  };
+};