@pothos/plugin-drizzle 0.13.0 → 0.15.0

package/src/global-types.ts

@@ -37,10 +37,6 @@ import type {
   ShapeFromIdColumns,
 } from './types';
 
-type MapToDbName<T> = {
-  [K in keyof T as T[K] extends { dbName: infer K2 extends string } ? K2 : K]: T[K];
-};
-
 declare global {
   export namespace PothosSchemaTypes {
     export interface Plugins<Types extends SchemaTypes> {

package/src/model-loader.ts

@@ -2,7 +2,7 @@ import { createContextCache, type SchemaTypes } from '@pothos/core';
 import {
   type AnyTable,
   type Column,
-  getTableColumns,
+  getColumns,
   inArray,
   type SQL,
   sql,
@@ -60,7 +60,7 @@ export class ModelLoader {
     this.columns = columns ?? this.primaryKey;
     this.selectSQL = (table) => {
       const columns = this.columns.map((column) =>
-        Object.values(getTableColumns(table)).find(
+        Object.values(getColumns(table)).find(
           (tblColumn) => 'columnType' in tblColumn && tblColumn.name === column.name,
         ),
       );

package/src/utils/config.ts

@@ -1,5 +1,5 @@
 import { createContextCache, type SchemaTypes } from '@pothos/core';
-import { type AnyRelations, type Column, getTableColumns, isTable, type Table } from 'drizzle-orm';
+import { type AnyRelations, type Column, getColumns, isTable, type Table } from 'drizzle-orm';
 import type { DrizzleClient } from '../types';
 
 export interface PothosDrizzleSchemaConfig {
@@ -17,14 +17,12 @@ const configCache = createContextCache(
       relations = (builder.options.drizzle.client as DrizzleClient)._.relations;
     }
 
-    const columnNameMappings: Record<string, string> = {};
+    const columnNameMappings = new Map<Column, string>();
 
     Object.values(relations).forEach(({ table }) => {
       if (isTable(table)) {
-        Object.entries(getTableColumns(table)).forEach(([tsName, col]) => {
-          if (col.uniqueName) {
-            columnNameMappings[col.uniqueName] = tsName;
-          }
+        Object.entries(getColumns(table)).forEach(([tsName, col]) => {
+          columnNameMappings.set(col, tsName);
         });
       }
     });
@@ -32,15 +30,13 @@ const configCache = createContextCache(
     return {
       skipDeferredFragments: builder.options.drizzle.skipDeferredFragments ?? true,
       columnToTsName: (column) => {
-        if (!column.uniqueName) {
-          throw new Error(`Column ${String(column.name)} has no uniqueName`);
-        }
+        const tsName = columnNameMappings.get(column);
 
-        if (!(column.uniqueName in columnNameMappings)) {
-          throw new Error(`Typescript name not found for ${column.uniqueName}`);
+        if (!tsName) {
+          throw new Error(`Typescript name not found for column ${String(column.name)}`);
         }
 
-        return columnNameMappings[column.uniqueName];
+        return tsName;
       },
       getPrimaryKey: (tableName) => {
         const tableConfig = builder.options.drizzle.getTableConfig(

package/src/utils/cursors.ts

@@ -8,7 +8,7 @@ import {
 import {
   type Column,
   type DBQueryConfig,
-  getTableColumns,
+  getColumns,
   type SQL,
   type Table,
   type TableRelationalConfig,
@@ -322,7 +322,7 @@ function parseOrderBy(
       normalized.push({ direction: 'asc', column: field });
     }
   } else {
-    const tableColumns = getTableColumns(table.table as Table);
+    const tableColumns = getColumns(table.table as Table);
     Object.entries(
       orderBy as {
         [k: string]: 'asc' | 'desc' | undefined;

package/src/utils/drizzle-graphql.ts

@@ -1,3 +1,4 @@
+export {};
 // import {
 //   type Column,
 //   type SQL,

package/src/utils/map-query.ts

@@ -401,15 +401,35 @@ function addFieldSelection(
 
   if (fieldSelect && selectionCompatible(state, fieldSelectionMap, true)) {
     mergeSelection(config, state, fieldSelectionMap);
-    state.mappings[selection.alias?.value ?? selection.name.value] = {
-      field: selection.name.value,
-      type: type.name,
-      mappings,
-      indirectPath,
-    };
+
+    state.mappings = mergeMappings(state.mappings, {
+      [selection.alias?.value ?? selection.name.value]: {
+        field: selection.name.value,
+        type: type.name,
+        mappings,
+        indirectPath,
+      },
+    });
   }
 }
 
+function mergeMappings(existing: LoaderMappings, incoming: LoaderMappings): LoaderMappings {
+  const result: LoaderMappings = { ...existing };
+
+  for (const [key, value] of Object.entries(incoming)) {
+    if (result[key]) {
+      result[key] = {
+        ...result[key],
+        mappings: mergeMappings(result[key].mappings, value.mappings),
+      };
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
 export interface QueryFromInfoOptions<T extends SelectionMap> {
   config: PothosDrizzleSchemaConfig;
   context: object;
@@ -567,7 +587,7 @@ export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo
 
   while (targetType.extensions?.pothosIndirectInclude) {
     targetType = info.schema.getType(
-      (targetType.extensions?.pothosIndirectInclude as IndirectInclude).getType(),
+      (targetType.extensions.pothosIndirectInclude as IndirectInclude).getType(),
     )!;
   }
 

package/src/utils/usage.ts

@@ -1,6 +1,6 @@
 export const usageSymbol = Symbol.for('Pothos.isUsed');
 
-export function wrapWithUsageCheck<T extends Object>(obj: T): T {
+export function wrapWithUsageCheck<T extends object>(obj: T): T {
   const result = {};
   let used = true;