@fragno-dev/db 0.1.1 → 0.1.2

package/src/adapters/kysely/kysely-adapter.ts

@@ -1,15 +1,15 @@
 import { sql, type Kysely } from "kysely";
 import type { SQLProvider } from "../../shared/providers";
 import type { DatabaseAdapter } from "../adapters";
-import { schemaToDBType } from "../../schema/serialize";
 import { createMigrator, type Migrator } from "../../migration-engine/create";
 import type { AnySchema } from "../../schema/create";
 import type { CustomOperation, MigrationOperation } from "../../migration-engine/shared";
 import { execute } from "./migration/execute";
 import type { AbstractQuery } from "../../query/query";
 import { fromKysely } from "./kysely-query";
-
-const SETTINGS_TABLE_NAME = "fragno_db_settings" as const;
+import { createTableNameMapper } from "./kysely-shared";
+import { createHash } from "node:crypto";
+import { SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
@@ -26,17 +26,26 @@ export class KyselyAdapter implements DatabaseAdapter {
     this.#kyselyConfig = config;
   }
 
-  createQueryEngine<T extends AnySchema>(schema: T, _namespace: string): AbstractQuery<T> {
-    return fromKysely(schema, this.#kyselyConfig);
+  createQueryEngine<T extends AnySchema>(schema: T, namespace: string): AbstractQuery<T> {
+    // Only create mapper if namespace is non-empty
+    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
+    return fromKysely(schema, this.#kyselyConfig, mapper);
+  }
+
+  async isConnectionHealthy(): Promise<boolean> {
+    try {
+      const result = await this.#kyselyConfig.db.executeQuery(
+        sql`SELECT 1 as healthy`.compile(this.#kyselyConfig.db),
+      );
+      return (result.rows[0] as Record<string, unknown>)["healthy"] === 1;
+    } catch {
+      return false;
+    }
   }
 
   createMigrationEngine(schema: AnySchema, namespace: string): Migrator {
-    const manager = createSettingsManager(
-      this.#kyselyConfig.db,
-      this.#kyselyConfig.provider,
-      SETTINGS_TABLE_NAME,
-      namespace,
-    );
+    const manager = createSettingsManager(this.#kyselyConfig.db, namespace);
+    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
 
     const onCustomNode = (node: CustomOperation, db: KyselyAny) => {
       const statement = sql.raw(node["sql"] as string);
@@ -63,7 +72,7 @@ export class KyselyAdapter implements DatabaseAdapter {
       }
 
       return operations.flatMap((op) =>
-        execute(op, this.#kyselyConfig, (node) => onCustomNode(node, db)),
+        execute(op, this.#kyselyConfig, (node) => onCustomNode(node, db), mapper),
       );
     };
 
@@ -97,69 +106,38 @@ export class KyselyAdapter implements DatabaseAdapter {
           return v ? parseInt(v) : 0;
         },
         updateSettingsInMigration: async (fromVersion, toVersion) => {
-          // Only create the settings table if we're migrating from version 0
-          if (fromVersion === 0) {
-            return [
-              { type: "custom", sql: manager.initTable() },
-              {
-                type: "custom",
-                sql: manager.insert(`schema_version`, toVersion.toString()),
-              },
-            ];
-          }
-
           return [
             {
               type: "custom",
-              sql: manager.update(`schema_version`, toVersion.toString()),
+              sql:
+                fromVersion === 0
+                  ? manager.insert(`schema_version`, toVersion.toString())
+                  : manager.update(`schema_version`, toVersion.toString()),
             },
           ];
         },
       },
     });
 
-    // Add getDefaultFileName implementation
-    migrator.getDefaultFileName = (namespace: string, fromVersion: number, toVersion: number) => {
-      const date = new Date().toISOString().split("T")[0].replace(/-/g, "");
-      const safeName = namespace.replace(/[^a-z0-9-]/gi, "_");
-      return `${date}_${safeName}_migration_${fromVersion}_to_${toVersion}.sql`;
-    };
-
     return migrator;
   }
 
   getSchemaVersion(namespace: string) {
-    const manager = createSettingsManager(
-      this.#kyselyConfig.db,
-      this.#kyselyConfig.provider,
-      SETTINGS_TABLE_NAME,
-      namespace,
-    );
+    const manager = createSettingsManager(this.#kyselyConfig.db, namespace);
 
     return manager.get(`schema_version`);
   }
 }
 
-function createSettingsManager(
-  db: KyselyAny,
-  provider: SQLProvider,
-  settingsTableName: string,
-  namespace: string,
-) {
-  function initTable() {
-    return db.schema
-      .createTable(settingsTableName)
-      .addColumn("key", provider === "sqlite" ? "text" : "varchar(255)", (col) => col.primaryKey())
-      .addColumn("value", sql.raw(schemaToDBType({ type: "string" }, provider)), (col) =>
-        col.notNull(),
-      );
-  }
+function createSettingsManager(db: KyselyAny, namespace: string) {
+  // Settings table is never namespaced, but keys include namespace prefix
+  const tableName = SETTINGS_TABLE_NAME;
 
   return {
     async get(key: string): Promise<string | undefined> {
       try {
         const result = await db
-          .selectFrom(settingsTableName)
+          .selectFrom(tableName)
           .where("key", "=", sql.lit(`${namespace}.${key}`))
           .select(["value"])
           .executeTakeFirstOrThrow();
@@ -169,14 +147,13 @@ function createSettingsManager(
       }
     },
 
-    initTable() {
-      return initTable().compile().sql;
-    },
-
     insert(key: string, value: string) {
       return db
-        .insertInto(settingsTableName)
+        .insertInto(tableName)
         .values({
+          id: sql.lit(
+            createHash("md5").update(`${namespace}.${key}`).digest("base64url").replace(/=/g, ""),
+          ),
           key: sql.lit(`${namespace}.${key}`),
           value: sql.lit(value),
         })
@@ -185,7 +162,7 @@ function createSettingsManager(
 
     update(key: string, value: string) {
       return db
-        .updateTable(settingsTableName)
+        .updateTable(tableName)
         .set({
           value: sql.lit(value),
         })

package/src/adapters/kysely/kysely-query-builder.ts

@@ -14,11 +14,13 @@ import type { Condition } from "../../query/condition-builder";
 import { serialize } from "../../schema/serialize";
 import type { CompiledJoin, SimplifyFindOptions } from "../../query/orm/orm";
 import { decodeResult, encodeValues, ReferenceSubquery } from "../../query/result-transform";
+import type { TableNameMapper } from "./kysely-shared";
 
 /**
  * Returns the fully qualified SQL name for a column (table.column).
  *
  * @param column - The column to get the full name for
+ * @param mapper - Optional table name mapper for namespace prefixing
  * @returns The fully qualified SQL name in the format "tableName.columnName"
  * @internal
  *
@@ -28,8 +30,9 @@ import { decodeResult, encodeValues, ReferenceSubquery } from "../../query/resul
  * // Returns: "users.email"
  * ```
  */
-export function fullSQLName(column: AnyColumn) {
-  return `${column.tableName}.${column.name}`;
+export function fullSQLName(column: AnyColumn, mapper?: TableNameMapper) {
+  const tableName = mapper ? mapper.toPhysical(column.tableName) : column.tableName;
+  return `${tableName}.${column.name}`;
 }
 
 /**
@@ -60,6 +63,7 @@ export function buildWhere(
   condition: Condition,
   eb: ExpressionBuilder<any, any>, // eslint-disable-line @typescript-eslint/no-explicit-any
   provider: SQLProvider,
+  mapper?: TableNameMapper,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): ExpressionWrapper<any, any, SqlBool> {
   if (condition.type === "compare") {
@@ -78,47 +82,55 @@ export function buildWhere(
       case "contains":
         v = "like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val))}, '%')` : `%${val}%`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            : `%${val}%`;
         break;
       case "not contains":
         v = "not like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val))}, '%')` : `%${val}%`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            : `%${val}%`;
         break;
       case "starts with":
         v = "like";
-        rhs = val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val))}, '%')` : `${val}%`;
+        rhs =
+          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
         break;
       case "not starts with":
         v = "not like";
-        rhs = val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val))}, '%')` : `${val}%`;
+        rhs =
+          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
         break;
       case "ends with":
         v = "like";
-        rhs = val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val))})` : `%${val}`;
+        rhs =
+          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
         break;
       case "not ends with":
         v = "not like";
-        rhs = val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val))})` : `%${val}`;
+        rhs =
+          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
         break;
       default:
         v = op;
-        rhs = val instanceof Column ? eb.ref(fullSQLName(val)) : val;
+        rhs = val instanceof Column ? eb.ref(fullSQLName(val, mapper)) : val;
     }
 
-    return eb(fullSQLName(left), v, rhs);
+    return eb(fullSQLName(left, mapper), v, rhs);
   }
 
   // Nested conditions
   if (condition.type === "and") {
-    return eb.and(condition.items.map((v) => buildWhere(v, eb, provider)));
+    return eb.and(condition.items.map((v) => buildWhere(v, eb, provider, mapper)));
   }
 
   if (condition.type === "not") {
-    return eb.not(buildWhere(condition.item, eb, provider));
+    return eb.not(buildWhere(condition.item, eb, provider, mapper));
   }
 
-  return eb.or(condition.items.map((v) => buildWhere(v, eb, provider)));
+  return eb.or(condition.items.map((v) => buildWhere(v, eb, provider, mapper)));
 }
 
 /**
@@ -353,14 +365,17 @@ export async function findMany(
  *
  * @param values - The encoded values that may contain ReferenceSubquery objects
  * @param kysely - The Kysely database instance for building subqueries
+ * @param mapper - Optional table name mapper for namespace prefixing
  * @returns Processed values with subqueries in place of ReferenceSubquery markers
  * @internal
  */
 function processReferenceSubqueries(
   values: Record<string, unknown>,
   kysely: Kysely<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
+  mapper?: TableNameMapper,
 ): Record<string, unknown> {
   const processed: Record<string, unknown> = {};
+  const getTableName = (table: AnyTable) => (mapper ? mapper.toPhysical(table.name) : table.name);
 
   for (const [key, value] of Object.entries(values)) {
     if (value instanceof ReferenceSubquery) {
@@ -369,7 +384,7 @@ function processReferenceSubqueries(
 
       // Build a subquery: SELECT _internal_id FROM referenced_table WHERE id = external_id LIMIT 1
       processed[key] = kysely
-        .selectFrom(refTable.name)
+        .selectFrom(getTableName(refTable))
         .select(refTable.getInternalIdColumn().name)
         .where(refTable.getIdColumn().name, "=", externalId)
         .limit(1);
@@ -399,21 +414,27 @@ function processReferenceSubqueries(
  * const result = await kysely.executeQuery(query);
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvider) {
+export function createKyselyQueryBuilder(
+  kysely: Kysely<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
+  provider: SQLProvider,
+  mapper?: TableNameMapper,
+) {
+  // Helper to get the physical table name (with namespace suffix if mapper is provided)
+  const getTableName = (table: AnyTable) => (mapper ? mapper.toPhysical(table.name) : table.name);
+
   return {
     count(table: AnyTable, { where }: { where?: Condition }): CompiledQuery {
-      let query = kysely.selectFrom(table.name).select(kysely.fn.countAll().as("count"));
+      let query = kysely.selectFrom(getTableName(table)).select(kysely.fn.countAll().as("count"));
       if (where) {
-        query = query.where((b) => buildWhere(where, b, provider));
+        query = query.where((b) => buildWhere(where, b, provider, mapper));
       }
       return query.compile();
     },
 
     create(table: AnyTable, values: Record<string, unknown>): CompiledQuery {
       const encodedValues = encodeValues(values, table, true, provider);
-      const processedValues = processReferenceSubqueries(encodedValues, kysely);
-      const insert = kysely.insertInto(table.name).values(processedValues);
+      const processedValues = processReferenceSubqueries(encodedValues, kysely, mapper);
+      const insert = kysely.insertInto(getTableName(table)).values(processedValues);
 
       if (provider === "mssql") {
         return (
@@ -425,7 +446,9 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
       }
 
       if (provider === "postgresql" || provider === "sqlite") {
-        return insert.returning(mapSelect(true, table)).compile();
+        return insert
+          .returning(mapSelect(true, table, { tableName: getTableName(table) }))
+          .compile();
       }
 
       // For MySQL/other providers, return the insert query
@@ -436,11 +459,11 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
       table: T,
       v: SimplifyFindOptions<FindManyOptions<T>>,
     ): CompiledQuery {
-      let query = kysely.selectFrom(table.name);
+      let query = kysely.selectFrom(getTableName(table));
 
       const where = v.where;
       if (where) {
-        query = query.where((eb) => buildWhere(where, eb, provider));
+        query = query.where((eb) => buildWhere(where, eb, provider, mapper));
       }
 
       if (v.offset !== undefined) {
@@ -453,7 +476,7 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
 
       if (v.orderBy) {
         for (const [col, mode] of v.orderBy) {
-          query = query.orderBy(fullSQLName(col), mode);
+          query = query.orderBy(fullSQLName(col, mapper), mode);
         }
       }
 
@@ -488,7 +511,7 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
             }),
           );
 
-          query = query.leftJoin(`${targetTable.name} as ${joinName}`, (b) =>
+          query = query.leftJoin(`${getTableName(targetTable)} as ${joinName}`, (b) =>
             b.on((eb) => {
               const conditions = [];
               for (const [left, right] of relation.on) {
@@ -507,7 +530,7 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
               }
 
               if (joinOptions.where) {
-                conditions.push(buildWhere(joinOptions.where, eb, provider));
+                conditions.push(buildWhere(joinOptions.where, eb, provider, mapper));
               }
 
               return eb.and(conditions);
@@ -519,10 +542,12 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
         }
       };
 
-      processJoins(v.join, table, table.name);
+      processJoins(v.join, table, getTableName(table));
 
       const compiledSelect = selectBuilder.compile();
-      mappedSelect.push(...mapSelect(compiledSelect.result, table));
+      mappedSelect.push(
+        ...mapSelect(compiledSelect.result, table, { tableName: getTableName(table) }),
+      );
 
       return query.select(mappedSelect).compile();
     },
@@ -535,26 +560,26 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
       },
     ): CompiledQuery {
       const encoded = encodeValues(v.set, table, false, provider);
-      const processed = processReferenceSubqueries(encoded, kysely);
+      const processed = processReferenceSubqueries(encoded, kysely, mapper);
 
       // Automatically increment _version for optimistic concurrency control
       const versionCol = table.getVersionColumn();
       // Safe cast: we're building a SQL expression for incrementing the version
       processed[versionCol.name] = sql.raw(`COALESCE(${versionCol.name}, 0) + 1`) as unknown;
 
-      let query = kysely.updateTable(table.name).set(processed);
+      let query = kysely.updateTable(getTableName(table)).set(processed);
       const { where } = v;
       if (where) {
-        query = query.where((eb) => buildWhere(where, eb, provider));
+        query = query.where((eb) => buildWhere(where, eb, provider, mapper));
       }
       return query.compile();
     },
 
     upsertCheck(table: AnyTable, where: Condition | undefined): CompiledQuery {
       const idColumn = table.getIdColumn();
-      let query = kysely.selectFrom(table.name).select([`${idColumn.name} as id`]);
+      let query = kysely.selectFrom(getTableName(table)).select([`${idColumn.name} as id`]);
       if (where) {
-        query = query.where((b) => buildWhere(where, b, provider));
+        query = query.where((b) => buildWhere(where, b, provider, mapper));
       }
       return query.limit(1).compile();
     },
@@ -566,13 +591,13 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
       top?: boolean,
     ): CompiledQuery {
       const encoded = encodeValues(update, table, false, provider);
-      const processed = processReferenceSubqueries(encoded, kysely);
-      let query = kysely.updateTable(table.name).set(processed);
+      const processed = processReferenceSubqueries(encoded, kysely, mapper);
+      let query = kysely.updateTable(getTableName(table)).set(processed);
       if (top) {
         query = query.top(1);
       }
       if (where) {
-        query = query.where((b) => buildWhere(where, b, provider));
+        query = query.where((b) => buildWhere(where, b, provider, mapper));
       }
       return query.compile();
     },
@@ -580,20 +605,26 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
     upsertUpdateById(table: AnyTable, update: Record<string, unknown>, id: unknown): CompiledQuery {
       const idColumn = table.getIdColumn();
       const encoded = encodeValues(update, table, false, provider);
-      const processed = processReferenceSubqueries(encoded, kysely);
-      return kysely.updateTable(table.name).set(processed).where(idColumn.name, "=", id).compile();
+      const processed = processReferenceSubqueries(encoded, kysely, mapper);
+      return kysely
+        .updateTable(getTableName(table))
+        .set(processed)
+        .where(idColumn.name, "=", id)
+        .compile();
     },
 
     createMany(table: AnyTable, values: Record<string, unknown>[]): CompiledQuery {
       const encodedValues = values.map((v) => encodeValues(v, table, true, provider));
-      const processedValues = encodedValues.map((v) => processReferenceSubqueries(v, kysely));
-      return kysely.insertInto(table.name).values(processedValues).compile();
+      const processedValues = encodedValues.map((v) =>
+        processReferenceSubqueries(v, kysely, mapper),
+      );
+      return kysely.insertInto(getTableName(table)).values(processedValues).compile();
     },
 
     deleteMany(table: AnyTable, { where }: { where?: Condition }): CompiledQuery {
-      let query = kysely.deleteFrom(table.name);
+      let query = kysely.deleteFrom(getTableName(table));
       if (where) {
-        query = query.where((eb) => buildWhere(where, eb, provider));
+        query = query.where((eb) => buildWhere(where, eb, provider, mapper));
       }
       return query.compile();
     },
@@ -601,8 +632,8 @@ export function createKyselyQueryBuilder(kysely: Kysely<any>, provider: SQLProvi
     findById(table: AnyTable, idValue: unknown): CompiledQuery {
       const idColumn = table.getIdColumn();
       return kysely
-        .selectFrom(table.name)
-        .select(mapSelect(true, table))
+        .selectFrom(getTableName(table))
+        .select(mapSelect(true, table, { tableName: getTableName(table) }))
         .where(idColumn.name, "=", idValue)
         .limit(1)
         .compile();

package/src/adapters/kysely/kysely-query-compiler.ts

@@ -5,6 +5,7 @@ import { buildFindOptions } from "../../query/orm/orm";
 import type { KyselyConfig } from "./kysely-adapter";
 import { createKyselyQueryBuilder } from "./kysely-query-builder";
 import type { ConditionBuilder, Condition } from "../../query/condition-builder";
+import type { TableNameMapper } from "./kysely-shared";
 
 /**
  * Internal query compiler interface for Kysely
@@ -27,9 +28,10 @@ export interface KyselyQueryCompiler {
 export function createKyselyQueryCompiler<T extends AnySchema>(
   schema: T,
   config: KyselyConfig,
+  mapper?: TableNameMapper,
 ): KyselyQueryCompiler {
   const { db: kysely, provider } = config;
-  const queryBuilder = createKyselyQueryBuilder(kysely, provider);
+  const queryBuilder = createKyselyQueryBuilder(kysely, provider, mapper);
 
   function toTable(name: unknown): AnyTable {
     const table = schema.tables[name as string];

package/src/adapters/kysely/kysely-query.ts

@@ -7,6 +7,7 @@ import { createKyselyUOWCompiler } from "./kysely-uow-compiler";
 import { executeKyselyRetrievalPhase, executeKyselyMutationPhase } from "./kysely-uow-executor";
 import { UnitOfWork } from "../../query/unit-of-work";
 import type { CompiledQuery } from "kysely";
+import type { TableNameMapper } from "./kysely-shared";
 
 /**
  * Creates a Kysely-based query engine for the given schema.
@@ -17,6 +18,7 @@ import type { CompiledQuery } from "kysely";
  *
  * @param schema - The database schema definition
  * @param config - Kysely configuration containing the database instance and provider
+ * @param mapper - Optional table name mapper for namespace prefixing
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
@@ -32,9 +34,13 @@ import type { CompiledQuery } from "kysely";
  * });
  * ```
  */
-export function fromKysely<T extends AnySchema>(schema: T, config: KyselyConfig): AbstractQuery<T> {
+export function fromKysely<T extends AnySchema>(
+  schema: T,
+  config: KyselyConfig,
+  mapper?: TableNameMapper,
+): AbstractQuery<T> {
   const { db: kysely, provider } = config;
-  const uowCompiler = createKyselyUOWCompiler(schema, config);
+  const uowCompiler = createKyselyUOWCompiler(schema, config, mapper);
 
   function createUOW(name?: string): UnitOfWork<T, []> {
     const executor: UOWExecutor<CompiledQuery, unknown> = {

package/src/adapters/kysely/kysely-shared.ts

@@ -0,0 +1,23 @@
+/**
+ * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)
+ */
+export interface TableNameMapper {
+  toPhysical(logicalName: string): string;
+  toLogical(physicalName: string): string;
+}
+
+/**
+ * Creates a table name mapper for a given namespace.
+ * Physical names have format: {logicalName}_{namespace}
+ */
+export function createTableNameMapper(namespace: string): TableNameMapper {
+  return {
+    toPhysical: (logicalName: string) => `${logicalName}_${namespace}`,
+    toLogical: (physicalName: string) => {
+      if (physicalName.endsWith(`_${namespace}`)) {
+        return physicalName.slice(0, -(namespace.length + 1));
+      }
+      return physicalName;
+    },
+  };
+}

package/src/adapters/kysely/kysely-uow-compiler.ts

@@ -12,6 +12,7 @@ import { createKyselyQueryBuilder } from "./kysely-query-builder";
 import { buildCondition, type Condition } from "../../query/condition-builder";
 import { decodeCursor, serializeCursorValues } from "../../query/cursor";
 import type { AnySelectClause } from "../../query/query";
+import type { TableNameMapper } from "./kysely-shared";
 
 /**
  * Create a Kysely-specific Unit of Work compiler
@@ -21,14 +22,16 @@ import type { AnySelectClause } from "../../query/query";
  *
  * @param schema - The database schema
  * @param config - Kysely configuration
+ * @param mapper - Optional table name mapper for namespace prefixing
  * @returns A UOWCompiler instance for Kysely
  */
 export function createKyselyUOWCompiler<TSchema extends AnySchema>(
   schema: TSchema,
   config: KyselyConfig,
+  mapper?: TableNameMapper,
 ): UOWCompiler<TSchema, CompiledQuery> {
-  const queryCompiler = createKyselyQueryCompiler(schema, config);
-  const queryBuilder = createKyselyQueryBuilder(config.db, config.provider);
+  const queryCompiler = createKyselyQueryCompiler(schema, config, mapper);
+  const queryBuilder = createKyselyQueryBuilder(config.db, config.provider, mapper);
   const { provider } = config;
 
   function toTable(name: unknown) {

package/src/adapters/kysely/migration/execute-mysql.test.ts

@@ -168,7 +168,7 @@ describe("execute() - MySQL", () => {
             type: "timestamp",
             isNullable: false,
             role: "regular",
-            default: { runtime: "now" },
+            default: { dbSpecial: "now" },
           },
         ],
       };
@@ -679,7 +679,7 @@ describe("execute() - MySQL", () => {
               type: "timestamp",
               isNullable: false,
               role: "regular",
-              default: { runtime: "now" },
+              default: { dbSpecial: "now" },
             },
             updateDataType: false,
             updateNullable: false,