@fragno-dev/db 0.1.8 → 0.1.9

package/src/adapters/drizzle/generate.ts

@@ -4,11 +4,12 @@ import {
   type AnyColumn,
   type AnySchema,
   type AnyTable,
+  type Relation,
   InternalIdColumn,
 } from "../../schema/create";
 import type { SQLProvider } from "../../shared/providers";
 import { schemaToDBType, type DBTypeLiteral } from "../../schema/serialize";
-import { createTableNameMapper } from "./shared";
+import { createTableNameMapper, sanitizeNamespace } from "./shared";
 import { settingsSchema, SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
 
 // ============================================================================
@@ -407,10 +408,13 @@ function generateTable(
   const columns = generateAllColumns(ctx, table, customTypes);
   const constraints = generateTableConstraints(ctx, table, namespace);
 
-  // Suffix table name with namespace if provided
-  const physicalTableName = namespace ? `${table.ormName}_${namespace}` : table.ormName;
-  // Sanitize namespace for use in export name (valid JS identifier)
-  const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+  // Suffix table name with namespace if provided, and sanitize for use as database table name
+  // Database table names must also be valid identifiers to work with Drizzle's relational query system
+  const physicalTableName = namespace
+    ? `${table.ormName}_${sanitizeNamespace(namespace)}`
+    : table.ormName;
+  // Same sanitized name for TypeScript export
+  const exportName = physicalTableName;
 
   const args: string[] = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 
@@ -429,11 +433,13 @@ function generateRelation(
   ctx: GeneratorContext,
   table: AnyTable,
   namespace?: string,
+  inverseRelations?: Array<{ fromTable: AnyTable; relation: Relation }>,
 ): string | undefined {
   const relations: string[] = [];
   let hasOne = false;
   let hasMany = false;
 
+  // Generate explicit relations defined on this table
   for (const relation of Object.values(table.relations)) {
     const options: string[] = [`relationName: "${relation.id}"`];
 
@@ -479,6 +485,30 @@ function generateRelation(
     relations.push(ident(`${relation.name}: ${relation.type}(${args.join(", ")})`));
   }
 
+  // Generate inverse relations for tables that reference this table
+  // Drizzle requires both sides of a relation to be defined
+  if (inverseRelations && inverseRelations.length > 0) {
+    for (const { fromTable, relation } of inverseRelations) {
+      // Only generate inverse for "one" relations (they become "many" on this side)
+      if (relation.type === "one") {
+        hasMany = true;
+
+        const fromTableRef = namespace
+          ? `${fromTable.ormName}_${sanitizeNamespace(namespace)}`
+          : fromTable.ormName;
+
+        // Generate inverse relation name with consistent suffix
+        // e.g., if session has "sessionOwner" relation to user, user gets "sessionList" inverse relation
+        const inverseRelationName = `${fromTable.ormName}List`;
+
+        const options: string[] = [`relationName: "${relation.id}"`];
+        const args: string[] = [fromTableRef, `{\n${ident(options.join(",\n"))}\n}`];
+
+        relations.push(ident(`${inverseRelationName}: many(${args.join(", ")})`));
+      }
+    }
+  }
+
   if (relations.length === 0) {
     return undefined;
   }
@@ -508,19 +538,15 @@ ${relations.join(",\n")}
 // UTILITIES
 // ============================================================================
 
-/**
- * Sanitize a namespace to be a valid JavaScript identifier
- * Replaces hyphens and other invalid characters with underscores
- */
-function sanitizeNamespace(namespace: string): string {
-  return namespace.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-
 /**
  * Generate a schema export object for a fragment
  * This groups all tables by their logical names for easier access
  */
-function generateFragmentSchemaExport(schema: AnySchema, namespace: string): string {
+function generateFragmentSchemaExport(
+  schema: AnySchema,
+  namespace: string,
+  tablesWithRelations?: Set<string>,
+): string {
   const entries: string[] = [];
 
   for (const table of Object.values(schema.tables)) {
@@ -528,14 +554,23 @@ function generateFragmentSchemaExport(schema: AnySchema, namespace: string): str
       ? `${table.ormName}_${sanitizeNamespace(namespace)}`
       : table.ormName;
 
+    // Use sanitized export name (valid JS identifier) as the key
+    // Drizzle requires all schema keys to be valid identifiers
+    entries.push(`  ${physicalExportName}: ${physicalExportName}`);
+
+    // Add convenient alias using the original table name (without namespace)
     if (namespace) {
-      const physicalTableName = namespace ? `${table.ormName}_${namespace}` : table.ormName;
-      // Use physical table name as key for Drizzle schema lookups
-      entries.push(`  "${physicalTableName}": ${physicalExportName}`);
+      entries.push(`  ${table.ormName}: ${physicalExportName}`);
     }
 
-    // Also provide logical name for convenience
-    entries.push(`  ${table.ormName}: ${physicalExportName}`);
+    // Include relations for this table if they exist (either explicit or inverse)
+    if (tablesWithRelations?.has(table.name)) {
+      const relationsName = namespace
+        ? `${table.ormName}_${sanitizeNamespace(namespace)}Relations`
+        : `${table.ormName}Relations`;
+
+      entries.push(`  ${relationsName}: ${relationsName}`);
+    }
   }
 
   // Add schema version as a number
@@ -616,17 +651,41 @@ export function generateSchema(
       const tableCode = generateTable(ctx, table, customTypes, namespace);
       fragmentTables.push("");
       fragmentTables.push(tableCode);
+    }
 
-      const relationCode = generateRelation(ctx, table, namespace);
+    // Build a map of inverse relations for tables that are referenced but don't have their own relations
+    // This is needed for Drizzle's relational query API to work correctly
+    const inverseRelations = new Map<string, Array<{ fromTable: AnyTable; relation: Relation }>>();
+    for (const table of Object.values(schema.tables)) {
+      for (const relation of Object.values(table.relations)) {
+        // Track this relation as an inverse on the target table
+        const targetTableName = relation.table.name;
+        if (!inverseRelations.has(targetTableName)) {
+          inverseRelations.set(targetTableName, []);
+        }
+        inverseRelations.get(targetTableName)!.push({ fromTable: table, relation });
+      }
+    }
+
+    // Generate relations for all tables (both explicit and inverse)
+    const tablesWithRelations = new Set<string>();
+    for (const table of Object.values(schema.tables)) {
+      const relationCode = generateRelation(
+        ctx,
+        table,
+        namespace,
+        inverseRelations.get(table.name),
+      );
       if (relationCode) {
         fragmentTables.push("");
         fragmentTables.push(relationCode);
+        tablesWithRelations.add(table.name);
       }
     }
 
     // Generate schema export object
     fragmentTables.push("");
-    fragmentTables.push(generateFragmentSchemaExport(schema, namespace));
+    fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
 
     sections.push(...fragmentTables);
   }

package/src/adapters/drizzle/shared.ts

@@ -30,16 +30,26 @@ export interface TableNameMapper {
   toLogical(physicalName: string): string;
 }
 
+/**
+ * Sanitize a namespace to be a valid JavaScript identifier
+ * Replaces hyphens and other invalid characters with underscores
+ */
+export function sanitizeNamespace(namespace: string): string {
+  return namespace.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
 /**
  * Creates a table name mapper for a given namespace.
- * Physical names have format: {logicalName}_{namespace}
+ * Physical names have format: {logicalName}_{sanitizedNamespace}
+ * The namespace is sanitized to match TypeScript export names used in the schema
  */
 export function createTableNameMapper(namespace: string): TableNameMapper {
+  const sanitized = sanitizeNamespace(namespace);
   return {
-    toPhysical: (logicalName: string) => `${logicalName}_${namespace}`,
+    toPhysical: (logicalName: string) => `${logicalName}_${sanitized}`,
     toLogical: (physicalName: string) => {
-      if (physicalName.endsWith(`_${namespace}`)) {
-        return physicalName.slice(0, -(namespace.length + 1));
+      if (physicalName.endsWith(`_${sanitized}`)) {
+        return physicalName.slice(0, -(sanitized.length + 1));
       }
       return physicalName;
     },

package/src/adapters/drizzle/test-utils.ts

@@ -53,6 +53,7 @@ export async function writeAndLoadSchema(
   return {
     schemaModule,
     schemaFilePath,
+    drizzleSchemaTs,
     cleanup,
   };
 }

package/src/query/unit-of-work.ts

@@ -801,6 +801,11 @@ export function createUnitOfWork<
   >;
 }
 
+export interface UnitOfWorkConfig {
+  dryRun?: boolean;
+  onQuery?: (query: unknown) => void;
+}
+
 /**
  * Unit of Work implementation with optimistic concurrency control
  *
@@ -835,13 +840,19 @@ export class UnitOfWork<
   const TRawInput = unknown,
 > {
   #schema: TSchema;
+
   #name?: string;
+  #config?: UnitOfWorkConfig;
+
   #state: UOWState = "building-retrieval";
+
   #retrievalOps: RetrievalOperation<TSchema>[] = [];
   #mutationOps: MutationOperation<TSchema>[] = [];
+
   #compiler: UOWCompiler<TSchema, unknown>;
   #executor: UOWExecutor<unknown, TRawInput>;
   #decoder: UOWDecoder<TSchema, TRawInput>;
+
   #retrievalResults?: TRetrievalResults;
   #createdInternalIds: (bigint | null)[] = [];
 
@@ -851,12 +862,14 @@ export class UnitOfWork<
     executor: UOWExecutor<unknown, TRawInput>,
     decoder: UOWDecoder<TSchema, TRawInput>,
     name?: string,
+    config?: UnitOfWorkConfig,
   ) {
     this.#schema = schema;
     this.#compiler = compiler;
     this.#executor = executor;
     this.#decoder = decoder;
     this.#name = name;
+    this.#config = config;
   }
 
   get schema(): TSchema {
@@ -891,10 +904,17 @@ export class UnitOfWork<
     for (const op of this.#retrievalOps) {
       const compiled = this.#compiler.compileRetrievalOperation(op);
       if (compiled !== null) {
+        this.#config?.onQuery?.(compiled);
+
         retrievalBatch.push(compiled);
       }
     }
 
+    if (this.#config?.dryRun) {
+      this.#state = "executed";
+      return [] as unknown as TRetrievalResults;
+    }
+
     const results = this.#decoder(
       await this.#executor.executeRetrievalPhase(retrievalBatch),
       this.#retrievalOps,
@@ -1099,10 +1119,18 @@ export class UnitOfWork<
     for (const op of this.#mutationOps) {
       const compiled = this.#compiler.compileMutationOperation(op);
       if (compiled !== null) {
+        this.#config?.onQuery?.(compiled);
         mutationBatch.push(compiled);
       }
     }
 
+    if (this.#config?.dryRun) {
+      this.#state = "executed";
+      return {
+        success: true,
+      };
+    }
+
     // Execute mutation phase
     const result = await this.#executor.executeMutationPhase(mutationBatch);
     this.#state = "executed";

package/tsdown.config.ts

@@ -9,6 +9,7 @@ export default defineConfig({
     "./src/adapters/adapters.ts",
     "./src/adapters/kysely/kysely-adapter.ts",
     "./src/adapters/drizzle/drizzle-adapter.ts",
+    "./src/adapters/drizzle/generate.ts",
     "./src/query/unit-of-work.ts",
     "./src/query/cursor.ts",
     "./src/fragment.ts",

package/dist/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.11_@libsql_client@0.15.15_@types_better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/table.utils.js

@@ -1,6 +0,0 @@
-//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.11_@libsql+client@0.15.15_@types+better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/table.utils.js
-const TableName = Symbol.for("drizzle:Name");
-
-//#endregion
-export { TableName };
-//# sourceMappingURL=table.utils.js.map

package/dist/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.11_@libsql_client@0.15.15_@types_better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/tracing-utils.js

@@ -1,8 +0,0 @@
-//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.11_@libsql+client@0.15.15_@types+better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args) {
-	return fn(...args);
-}
-
-//#endregion
-export { iife };
-//# sourceMappingURL=tracing-utils.js.map

package/dist/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.11_@libsql_client@0.15.15_@types_better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/tracing.js

@@ -1,8 +0,0 @@
-//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.11_@libsql+client@0.15.15_@types+better-sql_aee8b50e4fe3dba0cf9f533329f36260/node_modules/drizzle-orm/tracing.js
-const tracer = { startActiveSpan(name, fn) {
-	return fn();
-} };
-
-//#endregion
-export { tracer };
-//# sourceMappingURL=tracing.js.map