@fragno-dev/db 0.1.1 → 0.1.2

package/src/schema/create.ts

@@ -151,15 +151,35 @@ export interface Table<
   getVersionColumn: () => AnyColumn;
 }
 
-type DefaultFunctionMap = {
-  date: "now";
-  timestamp: "now";
-  string: "auto";
-} & Record<`varchar(${number})`, "auto">;
+type DBSpecial = { tag: "special"; value: "now" };
+type RuntimeSpecial = { tag: "special"; value: "cuid" | "now" };
 
-type DefaultFunction<TType extends keyof TypeMap> =
-  | (TType extends keyof DefaultFunctionMap ? DefaultFunctionMap[TType] : never)
-  | (() => TypeMap[TType]);
+/**
+ * Builder for database-level default values.
+ */
+export interface DefaultBuilder {
+  /** Database-generated timestamp (DEFAULT NOW()) */
+  now(): DBSpecial;
+}
+
+/**
+ * Builder for runtime-generated default values.
+ */
+export interface RuntimeDefaultBuilder {
+  /** Generate CUID identifier */
+  cuid(): RuntimeSpecial;
+  /** Generate current timestamp */
+  now(): RuntimeSpecial;
+}
+
+const defaultBuilder: DefaultBuilder = {
+  now: () => ({ tag: "special", value: "now" }),
+};
+
+const runtimeDefaultBuilder: RuntimeDefaultBuilder = {
+  cuid: () => ({ tag: "special", value: "cuid" }),
+  now: () => ({ tag: "special", value: "now" }),
+};
 
 type IdColumnType = `varchar(${number})`;
 
@@ -188,9 +208,8 @@ export class Column<TType extends keyof TypeMap, TIn = unknown, TOut = unknown>
 
   default?:
     | { value: TypeMap[TType] }
-    | {
-        runtime: DefaultFunction<TType>;
-      };
+    | { dbSpecial: "now" }
+    | { runtime: "cuid" | "now" | (() => TypeMap[TType]) };
 
   tableName: string = "";
 
@@ -214,25 +233,99 @@ export class Column<TType extends keyof TypeMap, TIn = unknown, TOut = unknown>
   }
 
   /**
-   * Generate default value on runtime
+   * Generate default value at runtime in application code (not in the database).
+   *
+   * Use this when you need values generated in your application code, either because:
+   * - Your database doesn't support the operation (e.g., generating CUIDs)
+   * - You want consistent behavior across all databases
+   * - You need custom generation logic
+   *
+   * @param value - Either a literal value or builder callback:
+   *   - Literal: Any static value of the column type
+   *   - `(b) => b.cuid()` - Generate a CUID identifier
+   *   - `(b) => b.now()` - Generate current timestamp
+   *   - `(b) => ...` - Custom function that returns the default value
+   *
+   * @example
+   * ```ts
+   * column("string").defaultTo$((b) => b.cuid())           // Generate CUID at runtime
+   * column("timestamp").defaultTo$((b) => b.now())         // Generate timestamp at runtime
+   * column("integer").defaultTo$(42)                       // Static literal
+   * column("integer").defaultTo$((b) => Math.floor(Math.random() * 100))  // Custom function
+   * ```
    */
-  defaultTo$(fn: DefaultFunction<TType>): Column<TType, TIn | null, TOut> {
-    this.default = { runtime: fn };
+  defaultTo$(
+    value: TypeMap[TType] | ((builder: RuntimeDefaultBuilder) => RuntimeSpecial | TypeMap[TType]),
+  ): Column<TType, TIn | null, TOut> {
+    if (typeof value === "function") {
+      const fn = value as (builder: RuntimeDefaultBuilder) => RuntimeSpecial | TypeMap[TType];
+      const result = fn(runtimeDefaultBuilder);
+      if (
+        typeof result === "object" &&
+        result !== null &&
+        "tag" in result &&
+        result.tag === "special"
+      ) {
+        this.default = { runtime: result.value };
+      } else {
+        // Custom function - we need to wrap the callback to call it again later
+        this.default = { runtime: () => fn(runtimeDefaultBuilder) as TypeMap[TType] };
+      }
+    } else {
+      // Direct literal value - wrap it in a function for runtime generation
+      this.default = { runtime: () => value };
+    }
     return this;
   }
 
   /**
-   * Set a database-level default value
+   * Set a database-level default value (generated by the database, not application code).
+   *
+   * The database will generate the default value when inserting rows. If the database
+   * doesn't support the operation, Fragno will fall back to generating the value in
+   * application code.
+   *
+   * @param value - Either a literal value or builder callback:
+   *   - Literal: Any static value of the column type
+   *   - `(b) => b.now()` - Database-generated timestamp
    *
-   * For schemaless database, it's still generated on runtime
+   * @example
+   * ```ts
+   * // Static defaults
+   * column("string").defaultTo("active")
+   * column("integer").defaultTo(0)
+   * column("boolean").defaultTo(true)
+   *
+   * // Database-generated timestamp (with fallback)
+   * column("timestamp").defaultTo((b) => b.now())
+   * ```
    */
-  defaultTo(value: TypeMap[TType]): Column<TType, TIn | null, TOut> {
-    this.default = { value };
+  defaultTo(
+    value: TypeMap[TType] | ((builder: DefaultBuilder) => DBSpecial | TypeMap[TType]),
+  ): Column<TType, TIn | null, TOut> {
+    if (typeof value === "function") {
+      const fn = value as (builder: DefaultBuilder) => DBSpecial | TypeMap[TType];
+      const result = fn(defaultBuilder);
+      if (
+        typeof result === "object" &&
+        result !== null &&
+        "tag" in result &&
+        result.tag === "special"
+      ) {
+        this.default = { dbSpecial: result.value };
+      } else {
+        this.default = { value: result as TypeMap[TType] };
+      }
+    } else {
+      this.default = { value };
+    }
     return this;
   }
 
   /**
-   * Generate default value for the column on runtime.
+   * Generate default value for the column at runtime.
+   * Used for both runtime defaults (defaultTo$) and fallback generation for
+   * database defaults (defaultTo) when the database doesn't support them.
    */
   generateDefaultValue(): TypeMap[TType] | undefined {
     if (!this.default) {
@@ -242,13 +335,24 @@ export class Column<TType extends keyof TypeMap, TIn = unknown, TOut = unknown>
     if ("value" in this.default) {
       return this.default.value;
     }
-    if (this.default.runtime === "auto") {
+
+    if ("dbSpecial" in this.default) {
+      // Fallback generation for database-level special functions
+      if (this.default.dbSpecial === "now") {
+        return new Date(Date.now()) as TypeMap[TType];
+      }
+      return;
+    }
+
+    // Runtime defaults (defaultTo$)
+    if (this.default.runtime === "cuid") {
       return createId() as TypeMap[TType];
     }
     if (this.default.runtime === "now") {
       return new Date(Date.now()) as TypeMap[TType];
     }
 
+    // Custom function
     return this.default.runtime();
   }
 
@@ -276,11 +380,15 @@ export class IdColumn<
 > extends Column<TType, TIn, TOut> {
   id = true;
 
-  override defaultTo$(fn: DefaultFunction<TType>) {
-    return super.defaultTo$(fn) as IdColumn<TType, TIn | null, TOut>;
+  override defaultTo$(
+    value: TypeMap[TType] | ((builder: RuntimeDefaultBuilder) => RuntimeSpecial | TypeMap[TType]),
+  ) {
+    return super.defaultTo$(value) as IdColumn<TType, TIn | null, TOut>;
   }
 
-  override defaultTo(value: TypeMap[TType]) {
+  override defaultTo(
+    value: TypeMap[TType] | ((builder: DefaultBuilder) => DBSpecial | TypeMap[TType]),
+  ) {
     return super.defaultTo(value) as IdColumn<TType, TIn | null, TOut>;
   }
 }
@@ -342,7 +450,7 @@ export function referenceColumn(): Column<
 export function idColumn(): IdColumn<"varchar(30)", string | FragnoId | null, FragnoId> {
   const col = new IdColumn<"varchar(30)", string | FragnoId | null, FragnoId>("varchar(30)");
   col.role = "external-id";
-  col.defaultTo$("auto");
+  col.defaultTo$((b) => b.cuid());
   return col;
 }
 

package/src/schema/serialize.ts

@@ -205,7 +205,9 @@ export function schemaToDBType(
         return "real";
       default:
         // sqlite doesn't support varchar
-        if (type.startsWith("varchar")) return "text";
+        if (type.startsWith("varchar")) {
+          return "text";
+        }
     }
   }
 
@@ -225,7 +227,9 @@ export function schemaToDBType(
       case "json":
         return "varchar(max)";
       default:
-        if (type.startsWith("varchar")) return type as `varchar(${number})`;
+        if (type.startsWith("varchar")) {
+          return type as `varchar(${number})`;
+        }
         return type;
     }
   }
@@ -241,7 +245,9 @@ export function schemaToDBType(
       case "binary":
         return "bytea";
       default:
-        if (type.startsWith("varchar")) return type as `varchar(${number})`;
+        if (type.startsWith("varchar")) {
+          return type as `varchar(${number})`;
+        }
         return type;
     }
   }
@@ -255,7 +261,9 @@ export function schemaToDBType(
       case "binary":
         return "longblob";
       default:
-        if (type.startsWith("varchar")) return type as `varchar(${number})`;
+        if (type.startsWith("varchar")) {
+          return type as `varchar(${number})`;
+        }
         return type;
     }
   }
@@ -269,7 +277,9 @@ const supportJson: SQLProvider[] = ["postgresql", "cockroachdb", "mysql"];
  * Parse from driver value
  */
 export function deserialize(value: unknown, col: AnyColumn, provider: SQLProvider) {
-  if (value === null) return null;
+  if (value === null) {
+    return null;
+  }
 
   if (!supportJson.includes(provider) && col.type === "json" && typeof value === "string") {
     return JSON.parse(value);
@@ -283,7 +293,9 @@ export function deserialize(value: unknown, col: AnyColumn, provider: SQLProvide
     return new Date(value);
   }
 
-  if (col.type === "bool" && typeof value === "number") return value === 1;
+  if (col.type === "bool" && typeof value === "number") {
+    return value === 1;
+  }
 
   if (col.type === "bigint" && value instanceof Buffer) {
     return value.readBigInt64BE(0);
@@ -342,7 +354,9 @@ export function serialize(value: unknown, col: AnyColumn, provider: SQLProvider)
     return value.getTime();
   }
 
-  if (provider === "sqlite" && typeof value === "boolean") return value ? 1 : 0;
+  if (provider === "sqlite" && typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
 
   if (provider === "sqlite" && typeof value === "bigint") {
     const buf = Buffer.alloc(8);

package/src/shared/settings-schema.ts

@@ -0,0 +1,61 @@
+import type { AbstractQuery } from "../query/query";
+import { schema, idColumn, column, type FragnoId } from "../schema/create";
+
+export const SETTINGS_TABLE_NAME = "fragno_db_settings" as const;
+export const SETTINGS_NAMESPACE = "fragno-db-settings" as const;
+
+export const settingsSchema = schema((s) => {
+  return s.addTable(SETTINGS_TABLE_NAME, (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("key", column("string"))
+      .addColumn("value", column("string"))
+      .createIndex("unique_key", ["key"], { unique: true });
+  });
+});
+
+export function createSettingsManager(
+  // oxlint-disable-next-line no-explicit-any
+  queryEngine: AbstractQuery<typeof settingsSchema, any>,
+  namespace: string,
+) {
+  return {
+    async get(key: string): Promise<{ id: FragnoId; key: string; value: string } | undefined> {
+      const uow = queryEngine
+        .createUnitOfWork()
+        .find(SETTINGS_TABLE_NAME, (b) =>
+          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
+        );
+      const [[result]] = await uow.executeRetrieve();
+      return result; // Safe: result can be undefined if key doesn't exist
+    },
+
+    async set(key: string, value: string) {
+      const uow = queryEngine
+        .createUnitOfWork("createSettingsManager#set")
+        .find(SETTINGS_TABLE_NAME, (b) =>
+          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
+        );
+      const [[existing]] = await uow.executeRetrieve();
+
+      if (existing) {
+        uow.update(SETTINGS_TABLE_NAME, existing.id, (b) => b.set({ value }).check());
+      } else {
+        uow.create(SETTINGS_TABLE_NAME, {
+          key: `${namespace}.${key}`,
+          value,
+        });
+      }
+
+      const { success } = await uow.executeMutations();
+
+      if (!success) {
+        throw new Error("Failed to set schema version");
+      }
+    },
+
+    async delete(id: FragnoId) {
+      await queryEngine.delete(SETTINGS_TABLE_NAME, id);
+    },
+  };
+}

package/src/util/deep-equal.ts

@@ -1,13 +1,21 @@
 // Minimal deep equal utility for primitives, arrays, and plain objects
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function deepEqual(a: any, b: any): boolean {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
 
   if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
+    if (a.length !== b.length) {
+      return false;
+    }
     for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) return false;
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
     }
     return true;
   }
@@ -15,11 +23,17 @@ export function deepEqual(a: any, b: any): boolean {
   if (typeof a === "object" && typeof b === "object") {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) return false;
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
     for (const key of aKeys) {
-      if (!(key in b)) return false;
+      if (!(key in b)) {
+        return false;
+      }
 
-      if (!Object.hasOwn(b, key) || !deepEqual(a[key], b[key])) return false;
+      if (!Object.hasOwn(b, key) || !deepEqual(a[key], b[key])) {
+        return false;
+      }
     }
 
     return true;

package/src/util/import-generator.ts

@@ -17,7 +17,9 @@ export function importGenerator() {
     format(): string {
       const v: string[] = [];
       for (const [specifier, names] of map) {
-        if (names.length === 0) continue;
+        if (names.length === 0) {
+          continue;
+        }
 
         v.push(`import { ${names.join(", ")} } from "${specifier}"`);
       }

package/src/util/parse.ts

@@ -2,7 +2,9 @@ const RegexVarchar = /^varchar\((\d+)\)$/;
 
 export function parseVarchar(template: string): number {
   const match = RegexVarchar.exec(template);
-  if (!match) throw new Error("Failed to match varchar(n)");
+  if (!match) {
+    throw new Error("Failed to match varchar(n)");
+  }
   return Number(match[1]);
 }
 

package/tsdown.config.ts

@@ -11,6 +11,7 @@ export default defineConfig({
     "./src/query/unit-of-work.ts",
     "./src/query/cursor.ts",
     "./src/fragment.ts",
+    "./src/migration-engine/generation-engine.ts",
   ],
   dts: true,
   unbundle: true,

package/.turbo/turbo-test.log

@@ -1,37 +0,0 @@
-$ vitest run
-
- RUN  v3.2.4 /home/runner/work/fragno/fragno/packages/fragno-db
-      Coverage enabled with istanbul
-
- ✓ src/adapters/kysely/migration/execute-postgres.test.ts (50 tests) 779ms
- ✓ src/adapters/kysely/kysely-query-builder.test.ts (83 tests) 575ms
- ✓ src/adapters/kysely/kysely-uow-joins.test.ts (26 tests) 422ms
- ✓ src/adapters/kysely/kysely-uow-compiler.test.ts (42 tests) 467ms
- ✓ src/schema/create.test.ts (28 tests) 208ms
- ✓ src/adapters/kysely/migration/execute-mysql.test.ts (36 tests) 331ms
- ✓ src/query/unit-of-work.test.ts (30 tests) 262ms
- ✓ src/adapters/drizzle/generate.test.ts (13 tests) 154ms
- ✓ src/query/result-transform.test.ts (47 tests) 173ms
- ✓ src/schema/serialize.test.ts (86 tests) 206ms
- ✓ src/adapters/drizzle/drizzle-uow-compiler.test.ts (45 tests) 24852ms
- ✓ src/adapters/kysely/kysely-adapter-pglite.test.ts (7 tests) 10686ms
-   ✓ KyselyAdapter PGLite > should run migrations and basic queries  623ms
-   ✓ KyselyAdapter PGLite > should support many-to-many queries through junction table  343ms
- ✓ src/query/query-type.test.ts (29 tests) 29ms
- ✓ src/query/condition-builder.test.ts (20 tests) 34ms
- ✓ src/migration-engine/create.test.ts (20 tests) 56ms
- ✓ src/migration-engine/auto-from-schema.test.ts (13 tests) 76ms
- ✓ src/adapters/drizzle/drizzle-adapter-pglite.test.ts (5 tests) 8905ms
- ✓ src/adapters/drizzle/migrate-drizzle.test.ts (1 test) 491ms
- ✓ src/fragment.test.ts (11 tests) 57ms
- ✓ src/query/cursor.test.ts (18 tests) 41ms
- ✓ src/query/unit-of-work-types.test.ts (5 tests) 37ms
- ✓ src/adapters/kysely/migration/kysely-migrator.test.ts (9 tests) 142ms
- ✓ src/adapters/drizzle/drizzle-adapter.test.ts (4 tests) 53ms
- ✓ src/adapters/drizzle/join-column-utils.test.ts (8 tests) 23ms
-
- Test Files  24 passed (24)
-      Tests  636 passed (636)
-   Start at  12:33:42
-   Duration  47.25s (transform 20.15s, setup 0ms, collect 51.86s, tests 49.06s, environment 119ms, prepare 11.76s)
-

package/.turbo/turbo-types$colon$check.log

@@ -1 +0,0 @@
-$ tsc --noEmit