@fragno-dev/db 0.1.1 → 0.1.2

package/src/migration-engine/generation-engine.ts

@@ -0,0 +1,356 @@
+import type { FragnoDatabase } from "../mod";
+import type { AnySchema } from "../schema/create";
+import type { PreparedMigration } from "./create";
+import {
+  settingsSchema,
+  SETTINGS_NAMESPACE,
+  createSettingsManager,
+} from "../shared/settings-schema";
+
+export interface GenerationEngineResult {
+  schema: string;
+  path: string;
+  namespace: string;
+}
+
+export interface GenerationInternalResult {
+  schema: string;
+  path: string;
+  namespace: string;
+  fromVersion: number;
+  toVersion: number;
+  preparedMigration?: PreparedMigration;
+}
+
+export interface ExecuteMigrationResult {
+  namespace: string;
+  didMigrate: boolean;
+  fromVersion: number;
+  toVersion: number;
+}
+
+export async function generateMigrationsOrSchema<
+  const TDatabases extends FragnoDatabase<AnySchema>[],
+>(
+  databases: TDatabases,
+  options?: {
+    path?: string;
+    toVersion?: number;
+    fromVersion?: number;
+  },
+): Promise<GenerationEngineResult[]> {
+  if (databases.length === 0) {
+    throw new Error("No databases provided for schema generation");
+  }
+
+  const firstDb = databases[0];
+  const adapter = firstDb.adapter;
+
+  // If adapter has createSchemaGenerator, use it for combined generation (e.g., Drizzle)
+  if (adapter.createSchemaGenerator) {
+    if (options?.toVersion !== undefined || options?.fromVersion !== undefined) {
+      console.warn(
+        "⚠️ Warning: --from and --to version options are not supported when generating schemas for multiple fragments and will be ignored.",
+      );
+    }
+
+    const fragments = databases.map((db) => ({
+      schema: db.schema,
+      namespace: db.namespace,
+    }));
+
+    const generator = adapter.createSchemaGenerator(fragments, {
+      path: options?.path,
+    });
+
+    return [
+      {
+        ...generator.generateSchema(),
+        namespace: firstDb.namespace,
+      },
+    ];
+  }
+
+  // Otherwise, use migration engine for individual generation (e.g., Kysely)
+  if (!adapter.createMigrationEngine) {
+    throw new Error(
+      "Adapter does not support migration-based schema generation. Ensure your adapter implements createMigrationEngine.",
+    );
+  }
+
+  if (!(await adapter.isConnectionHealthy())) {
+    throw new Error(
+      "Database connection is not healthy. Please check your database connection and try again.",
+    );
+  }
+
+  const settingsQueryEngine = adapter.createQueryEngine(settingsSchema, "");
+  const settingsManager = createSettingsManager(settingsQueryEngine, SETTINGS_NAMESPACE);
+
+  let settingsSourceVersion: number;
+  try {
+    const result = await settingsManager.get("version");
+
+    if (!result) {
+      settingsSourceVersion = 0;
+    } else {
+      settingsSourceVersion = parseInt(result.value);
+    }
+  } catch {
+    // We don't really have a way to verify this error happens because the key doesn't exist in the database
+    settingsSourceVersion = 0;
+  }
+
+  const generatedFiles: GenerationInternalResult[] = [];
+
+  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, SETTINGS_NAMESPACE);
+  const settingsTargetVersion = settingsSchema.version;
+
+  // Generate settings table migration
+  const settingsMigration = await settingsMigrator.prepareMigrationTo(settingsTargetVersion, {
+    fromVersion: settingsSourceVersion,
+  });
+
+  if (!settingsMigration.getSQL) {
+    throw new Error(
+      "Migration engine does not support SQL generation. Ensure your adapter's migration engine provides getSQL().",
+    );
+  }
+
+  const settingsSql = settingsMigration.getSQL();
+
+  if (settingsSql.trim()) {
+    generatedFiles.push({
+      schema: settingsSql,
+      path: "settings-migration.sql", // Placeholder, will be renamed in post-processing
+      namespace: SETTINGS_NAMESPACE,
+      fromVersion: settingsSourceVersion,
+      toVersion: settingsTargetVersion,
+      preparedMigration: settingsMigration,
+    });
+  }
+
+  // Generate migration for each fragment
+  for (const db of databases) {
+    const dbAdapter = db.adapter;
+
+    // Use migration engine
+    if (!dbAdapter.createMigrationEngine) {
+      throw new Error(
+        `Adapter for ${db.namespace} does not support schema generation. ` +
+          `Ensure your adapter implements either createSchemaGenerator or createMigrationEngine.`,
+      );
+    }
+
+    const migrator = dbAdapter.createMigrationEngine(db.schema, db.namespace);
+    const targetVersion = options?.toVersion ?? db.schema.version;
+    const sourceVersion = options?.fromVersion ?? 0;
+
+    // Generate migration from source to target version
+    const preparedMigration = await migrator.prepareMigrationTo(targetVersion, {
+      fromVersion: sourceVersion,
+    });
+
+    if (!preparedMigration.getSQL) {
+      throw new Error(
+        "Migration engine does not support SQL generation. Ensure your adapter's migration engine provides getSQL().",
+      );
+    }
+
+    const sql = preparedMigration.getSQL();
+
+    // If no migrations needed, skip this fragment
+    if (sql.trim()) {
+      generatedFiles.push({
+        schema: sql,
+        path: "schema.sql", // Placeholder, will be renamed in post-processing
+        namespace: db.namespace,
+        fromVersion: sourceVersion,
+        toVersion: targetVersion,
+        preparedMigration: preparedMigration,
+      });
+    }
+  }
+
+  // Post-process filenames with ordering
+  return postProcessMigrationFilenames(generatedFiles);
+}
+
+/**
+ * Execute migrations for all fragments in the correct order.
+ * Migrates settings table first, then fragments alphabetically.
+ *
+ * @param databases - Array of FragnoDatabase instances to migrate
+ * @returns Array of execution results for each migration
+ */
+export async function executeMigrations<const TDatabases extends FragnoDatabase<AnySchema>[]>(
+  databases: TDatabases,
+): Promise<ExecuteMigrationResult[]> {
+  if (databases.length === 0) {
+    throw new Error("No databases provided for migration");
+  }
+
+  const firstDb = databases[0];
+  const adapter = firstDb.adapter;
+
+  // Validate adapter supports migrations
+  if (!adapter.createMigrationEngine) {
+    throw new Error(
+      "Adapter does not support running migrations. The adapter only supports schema generation.\n" +
+        "Try using 'generateMigrationsOrSchema' instead to generate schema files.",
+    );
+  }
+
+  // Validate all use same adapter
+  const allSameAdapter = databases.every((db) => db.adapter === adapter);
+  if (!allSameAdapter) {
+    throw new Error(
+      "All fragments must use the same database adapter instance. Mixed adapters are not supported.",
+    );
+  }
+
+  if (!(await adapter.isConnectionHealthy())) {
+    throw new Error(
+      "Database connection is not healthy. Please check your database connection and try again.",
+    );
+  }
+
+  const results: ExecuteMigrationResult[] = [];
+  const migrationsToExecute: Array<{
+    namespace: string;
+    fromVersion: number;
+    toVersion: number;
+    preparedMigration: PreparedMigration;
+  }> = [];
+
+  // 1. Prepare settings table migration
+  const settingsQueryEngine = adapter.createQueryEngine(settingsSchema, "");
+  const settingsManager = createSettingsManager(settingsQueryEngine, SETTINGS_NAMESPACE);
+
+  let settingsSourceVersion: number;
+  try {
+    const result = await settingsManager.get("version");
+    settingsSourceVersion = result ? parseInt(result.value) : 0;
+  } catch {
+    settingsSourceVersion = 0;
+  }
+
+  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, SETTINGS_NAMESPACE);
+  const settingsTargetVersion = settingsSchema.version;
+
+  if (settingsSourceVersion < settingsTargetVersion) {
+    const settingsMigration = await settingsMigrator.prepareMigrationTo(settingsTargetVersion, {
+      fromVersion: settingsSourceVersion,
+      updateSettings: true,
+    });
+
+    if (settingsMigration.operations.length > 0) {
+      migrationsToExecute.push({
+        namespace: SETTINGS_NAMESPACE,
+        fromVersion: settingsSourceVersion,
+        toVersion: settingsTargetVersion,
+        preparedMigration: settingsMigration,
+      });
+    }
+  }
+
+  // 2. Prepare fragment migrations (sorted alphabetically)
+  const sortedDatabases = [...databases].sort((a, b) => a.namespace.localeCompare(b.namespace));
+
+  for (const fragnoDb of sortedDatabases) {
+    const migrator = adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace);
+    const currentVersion = await migrator.getVersion();
+    const targetVersion = fragnoDb.schema.version;
+
+    if (currentVersion < targetVersion) {
+      const preparedMigration = await migrator.prepareMigrationTo(targetVersion, {
+        updateSettings: true,
+      });
+
+      if (preparedMigration.operations.length > 0) {
+        migrationsToExecute.push({
+          namespace: fragnoDb.namespace,
+          fromVersion: currentVersion,
+          toVersion: targetVersion,
+          preparedMigration: preparedMigration,
+        });
+      }
+    }
+  }
+
+  // 3. Execute all migrations in order
+  for (const migration of migrationsToExecute) {
+    await migration.preparedMigration.execute();
+    results.push({
+      namespace: migration.namespace,
+      didMigrate: true,
+      fromVersion: migration.fromVersion,
+      toVersion: migration.toVersion,
+    });
+  }
+
+  // 4. Add skipped migrations (already up-to-date)
+  for (const fragnoDb of databases) {
+    if (!results.find((r) => r.namespace === fragnoDb.namespace)) {
+      results.push({
+        namespace: fragnoDb.namespace,
+        didMigrate: false,
+        fromVersion: fragnoDb.schema.version,
+        toVersion: fragnoDb.schema.version,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Post-processes migration files to add ordering and standardize naming.
+ *
+ * Sorts files with settings namespace first, then alphabetically by namespace,
+ * and assigns ordering numbers. Transforms filenames to format:
+ * `<date>_<n>_f<from>_t<to>_<namespace>.sql`
+ *
+ * @param files - Array of generated migration files with version information
+ * @returns Array of files with standardized paths and ordering
+ */
+export function postProcessMigrationFilenames(
+  files: GenerationInternalResult[],
+): GenerationEngineResult[] {
+  if (files.length === 0) {
+    return [];
+  }
+
+  // Sort files: settings namespace first, then alphabetically by namespace
+  const sortedFiles = [...files].sort((a, b) => {
+    if (a.namespace === SETTINGS_NAMESPACE) {
+      return -1;
+    }
+    if (b.namespace === SETTINGS_NAMESPACE) {
+      return 1;
+    }
+    return a.namespace.localeCompare(b.namespace);
+  });
+
+  // Generate date prefix for filenames
+  const date = new Date().toISOString().split("T")[0].replace(/-/g, "");
+
+  // Rename files with ordering
+  return sortedFiles.map((file, index) => {
+    const fromVersion = file.fromVersion ?? 0;
+    const toVersion = file.toVersion ?? 0;
+
+    // Create new filename with ordering
+    const orderNum = (index + 1).toString().padStart(3, "0");
+    const fromPadded = fromVersion.toString().padStart(3, "0");
+    const toPadded = toVersion.toString().padStart(3, "0");
+    const safeName = file.namespace.replace(/[^a-z0-9-]/gi, "_");
+    const newPath = `${date}_${orderNum}_f${fromPadded}_t${toPadded}_${safeName}.sql`;
+
+    return {
+      schema: file.schema,
+      path: newPath,
+      namespace: file.namespace,
+    };
+  });
+}

package/src/migration-engine/shared.ts

@@ -20,10 +20,7 @@ export interface ColumnInfo {
     | `varchar(${number})`;
   isNullable: boolean;
   role: "external-id" | "internal-id" | "version" | "reference" | "regular";
-  default?: {
-    value?: unknown;
-    runtime?: "now" | "auto";
-  };
+  default?: { value: unknown } | { dbSpecial: "now" } | { runtime: "cuid" | "now" };
 }
 
 export type MigrationOperation =

package/src/mod.ts

@@ -115,72 +115,6 @@ export class FragnoDatabase<const T extends AnySchema> {
   get adapter() {
     return this.#adapter;
   }
-
-  async generateSchema(options?: {
-    path?: string;
-    toVersion?: number;
-    fromVersion?: number;
-  }): Promise<{ schema: string; path: string }> {
-    const adapter = this.#adapter;
-
-    if (adapter.createSchemaGenerator) {
-      if (options?.toVersion !== undefined || options?.fromVersion !== undefined) {
-        console.warn("⚠️ toVersion and fromVersion are not supported for schema generation.");
-      }
-
-      const generator = adapter.createSchemaGenerator(this.#schema, this.#namespace);
-      const defaultPath = options?.path ?? "schema.ts";
-      return generator.generateSchema({
-        path: defaultPath,
-        toVersion: options?.toVersion,
-        fromVersion: options?.fromVersion,
-      });
-    }
-
-    if (adapter.createMigrationEngine) {
-      const migrator = adapter.createMigrationEngine(this.#schema, this.#namespace);
-      const targetVersion = options?.toVersion ?? this.#schema.version;
-      const sourceVersion = options?.fromVersion;
-
-      // Get current version for file naming if not provided
-      const currentVersion = sourceVersion ?? (await migrator.getVersion());
-
-      // Determine the default path using the migrator's getDefaultFileName if available
-      const defaultPath =
-        options?.path ??
-        (migrator.getDefaultFileName
-          ? migrator.getDefaultFileName(this.#namespace, currentVersion, targetVersion)
-          : "schema.sql");
-
-      // Generate migration from source to target version
-      const preparedMigration = await migrator.prepareMigrationTo(targetVersion, {
-        updateSettings: true,
-        fromVersion: sourceVersion,
-      });
-
-      if (!preparedMigration.getSQL) {
-        throw new Error(
-          "Migration engine does not support SQL generation. Ensure your adapter's migration engine provides getSQL().",
-        );
-      }
-
-      const sql = preparedMigration.getSQL();
-
-      // If no migrations needed, return informative message
-      if (!sql.trim()) {
-        throw new Error("No migrations needed. Database is already at the target version.");
-      }
-
-      return {
-        schema: sql,
-        path: defaultPath,
-      };
-    }
-
-    throw new Error(
-      "Adapter does not support schema generation. Ensure your adapter implements either createSchemaGenerator or createMigrationEngine.",
-    );
-  }
 }
 
 export function defineFragnoDatabase<const TSchema extends AnySchema>(

package/src/query/condition-builder.ts

@@ -95,7 +95,9 @@ export function createBuilder<Columns extends Record<string, AnyColumn>>(
     if (args.length === 3) {
       const [a, operator, b] = args;
 
-      if (!operators.includes(operator)) throw new Error(`Unsupported operator: ${operator}`);
+      if (!operators.includes(operator)) {
+        throw new Error(`Unsupported operator: ${operator}`);
+      }
 
       return {
         type: "compare",
@@ -116,7 +118,9 @@ export function createBuilder<Columns extends Record<string, AnyColumn>>(
   builder.isNull = (a) => builder(a, "is", null);
   builder.isNotNull = (a) => builder(a, "is not", null);
   builder.not = (condition) => {
-    if (typeof condition === "boolean") return !condition;
+    if (typeof condition === "boolean") {
+      return !condition;
+    }
 
     return {
       type: "not",
@@ -131,13 +135,19 @@ export function createBuilder<Columns extends Record<string, AnyColumn>>(
     } as const;
 
     for (const item of conditions) {
-      if (item === true) return true;
-      if (item === false) continue;
+      if (item === true) {
+        return true;
+      }
+      if (item === false) {
+        continue;
+      }
 
       out.items.push(item);
     }
 
-    if (out.items.length === 0) return false;
+    if (out.items.length === 0) {
+      return false;
+    }
     return out;
   };
 
@@ -148,13 +158,19 @@ export function createBuilder<Columns extends Record<string, AnyColumn>>(
     } as const;
 
     for (const item of conditions) {
-      if (item === true) continue;
-      if (item === false) return false;
+      if (item === true) {
+        continue;
+      }
+      if (item === false) {
+        return false;
+      }
 
       out.items.push(item);
     }
 
-    if (out.items.length === 0) return true;
+    if (out.items.length === 0) {
+      return true;
+    }
     return out;
   };
 

package/src/query/result-transform.ts

@@ -51,10 +51,16 @@ export function generateRuntimeDefault(column: AnyColumn): unknown {
     return undefined;
   }
 
+  // If it's a database-level special function (defaultTo(b => b.now())), return undefined
+  // as the database should handle this via DEFAULT NOW() or equivalent
+  if ("dbSpecial" in column.default) {
+    return undefined;
+  }
+
   // Handle runtime defaults (defaultTo$)
   const runtime = column.default.runtime;
 
-  if (runtime === "auto") {
+  if (runtime === "cuid") {
     return createId();
   }
 

package/src/schema/create.test.ts

@@ -66,7 +66,10 @@ describe("create", () => {
       return s.addTable("test", (t) => {
         return t
           .addColumn("id", idColumn())
-          .addColumn("createdAt", column("timestamp").defaultTo$("now"))
+          .addColumn(
+            "createdAt",
+            column("timestamp").defaultTo$((b) => b.now()),
+          )
           .addColumn("status", column("string").defaultTo("active"));
       });
     });