@pothos/plugin-drizzle 0.11.2 → 0.12.1

package/src/types.ts

@@ -75,7 +75,7 @@ export type DrizzlePluginOptions<Types extends SchemaTypes> = {
         }[];
         readonly columns: Column[];
       };
-      relations?: Types['DrizzleRelations'];
+      relations: Types['DrizzleRelations'];
     }
 );
 
@@ -93,7 +93,7 @@ type NameOrVariant =
 
 export type DrizzleObjectOptions<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   Shape,
   Selection,
   Interfaces extends InterfaceParam<Types>[],
@@ -103,7 +103,7 @@ export type DrizzleObjectOptions<
     fields?: (
       t: DrizzleObjectFieldBuilder<
         Types,
-        Types['DrizzleRelationsConfig'][Table],
+        Types['DrizzleRelations'][Table],
         Shape & { [drizzleTableName]?: Table }
       >,
     ) => FieldMap;
@@ -111,7 +111,7 @@ export type DrizzleObjectOptions<
 
 export type DrizzleInterfaceOptions<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   Shape,
   Selection,
   Interfaces extends InterfaceParam<Types>[],
@@ -121,7 +121,7 @@ export type DrizzleInterfaceOptions<
     fields?: (
       t: DrizzleObjectFieldBuilder<
         Types,
-        Types['DrizzleRelationsConfig'][Table],
+        Types['DrizzleRelations'][Table],
         Shape & { [drizzleTableName]?: Table }
       >,
     ) => FieldMap;
@@ -129,7 +129,7 @@ export type DrizzleInterfaceOptions<
 
 export type DrizzleNodeOptions<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   Shape,
   Selection,
   Interfaces extends InterfaceParam<Types>[],
@@ -157,14 +157,14 @@ export type DrizzleNodeOptions<
         (
           | Column
           | Column[]
-          | ((columns: Types['DrizzleRelationsConfig'][Table]['columns']) => Column | Column[])
+          | ((columns: Types['DrizzleRelations'][Table]['table']) => Column | Column[])
         );
     };
     select?: Selection;
     fields?: (
       t: DrizzleObjectFieldBuilder<
         Types,
-        Types['DrizzleRelationsConfig'][Table],
+        Types['DrizzleRelations'][Table],
         Shape & { [drizzleTableName]?: Table }
       >,
     ) => FieldMap;
@@ -172,7 +172,7 @@ export type DrizzleNodeOptions<
 
 export type ShapeFromIdColumns<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   IDColumns,
 > = IDColumns extends Column
   ? IDColumns['_']['data']
@@ -191,7 +191,7 @@ export type ShapeFromIdColumns<
 export type DrizzleFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   Type extends TypeParam<Types>,
   Nullable extends FieldNullability<Type>,
   Args extends InputFieldMap,
@@ -214,7 +214,9 @@ export type DrizzleFieldOptions<
 > & {
   type: Param;
   resolve: (
-    query: <T extends QueryForDrizzleField<Types, Param, Table>>(selection?: T) => T,
+    query: <T extends QueryForDrizzleField<Types, Param, Table>>(
+      selection?: T,
+    ) => Omit<T, 'columns'>,
     parent: ParentShape,
     args: InputShapeFromFields<Args>,
     ctx: Types['Context'],
@@ -225,7 +227,7 @@ export type DrizzleFieldOptions<
 export type DrizzleFieldWithInputOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   Type extends TypeParam<Types>,
   Nullable extends FieldNullability<Type>,
   Args extends InputFieldMap,
@@ -271,7 +273,7 @@ export type DrizzleObjectFieldOptions<
       unknown extends Select
         ? ParentShape
         : BuildQueryResult<
-            Types['DrizzleRelationsConfig'],
+            Types['DrizzleRelations'],
             ExtractTable<Types, ParentShape>,
             Record<string, unknown> &
               // biome-ignore lint/suspicious/noExplicitAny: this is fine
@@ -302,7 +304,7 @@ export type DrizzleObjectFieldOptions<
   > & {
     select?: Select &
       (
-        | DBQueryConfig<'one', Types['DrizzleRelationsConfig'], ExtractTable<Types, ParentShape>>
+        | DBQueryConfig<'one', Types['DrizzleRelations'], ExtractTable<Types, ParentShape>>
         | ((
             args: InputShapeFromFields<Args>,
             ctx: Types['Context'],
@@ -310,11 +312,7 @@ export type DrizzleObjectFieldOptions<
               selection?: Selection,
               path?: string[],
             ) => Selection,
-          ) => DBQueryConfig<
-            'one',
-            Types['DrizzleRelationsConfig'],
-            ExtractTable<Types, ParentShape>
-          >)
+          ) => DBQueryConfig<'one', Types['DrizzleRelations'], ExtractTable<Types, ParentShape>>)
       );
   };
 
@@ -335,9 +333,9 @@ export type DrizzleFieldSelection =
     ) => SelectionMap);
 
 export type ExtractTable<Types extends SchemaTypes, Shape> = Shape extends {
-  [drizzleTableName]?: keyof Types['DrizzleRelationsConfig'];
+  [drizzleTableName]?: keyof Types['DrizzleRelations'];
 }
-  ? Types['DrizzleRelationsConfig'][NonNullable<Shape[typeof drizzleTableName]>]
+  ? Types['DrizzleRelations'][NonNullable<Shape[typeof drizzleTableName]>]
   : never;
 
 export type RelatedFieldOptions<
@@ -371,7 +369,7 @@ export type RelatedFieldOptions<
 
 export type VariantFieldOptions<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
   // biome-ignore lint/suspicious/noExplicitAny: this is fine
   Variant extends DrizzleRef<any, Table> | Table,
   Args extends InputFieldMap,
@@ -400,7 +398,7 @@ export type VariantFieldOptions<
           unknown extends ResolveShape
             ? Shape
             : BuildQueryResult<
-                Types['DrizzleRelationsConfig'],
+                Types['DrizzleRelations'],
                 ExtractTable<Types, Shape>,
                 Record<string, unknown> &
                   // biome-ignore lint/suspicious/noExplicitAny: this is fine
@@ -425,8 +423,8 @@ export type RefForRelation<Types extends SchemaTypes, Rel extends Relation> = Re
   : [ObjectRef<Types, TypesForRelation<Types, Rel>>];
 
 export type TypesForRelation<Types extends SchemaTypes, Rel extends Relation> = BuildQueryResult<
-  Types['DrizzleRelationsConfig'],
-  Types['DrizzleRelationsConfig'][Rel['targetTable']['_']['name']],
+  Types['DrizzleRelations'],
+  Types['DrizzleRelations'][Rel['targetTable']['_']['name']],
   true
 >;
 
@@ -441,16 +439,16 @@ export type QueryForField<
     ? Omit<
         DBQueryConfig<
           'one',
-          Types['DrizzleRelationsConfig'],
-          Types['DrizzleRelationsConfig'][Rel['targetTable']['_']['name']]
+          Types['DrizzleRelations'],
+          Types['DrizzleRelations'][Rel['targetTable']['_']['name']]
         >,
         'columns' | 'extra' | 'with'
       >
     : Omit<
         DBQueryConfig<
           'many',
-          Types['DrizzleRelationsConfig'],
-          Types['DrizzleRelationsConfig'][Rel['targetTable']['_']['name']]
+          Types['DrizzleRelations'],
+          Types['DrizzleRelations'][Rel['targetTable']['_']['name']]
         >,
         'columns' | 'extra' | 'with'
       >
@@ -461,14 +459,9 @@ export type QueryForField<
 export type QueryForDrizzleField<
   Types extends SchemaTypes,
   Param,
-  Table extends keyof Types['DrizzleRelationsConfig'],
+  Table extends keyof Types['DrizzleRelations'],
 > = Omit<
-  DBQueryConfig<
-    'many',
-    Types['DrizzleRelationsConfig'],
-    Types['DrizzleRelationsConfig'][Table],
-    true
-  >,
+  DBQueryConfig<'many', Types['DrizzleRelations'], Types['DrizzleRelations'][Table]>,
   Param extends [unknown] ? never : 'limit'
 >;
 
@@ -477,33 +470,33 @@ export type QueryForRelatedConnection<
   Table extends TableRelationalConfig,
   Args,
 > = Omit<
-  DBQueryConfig<'many', Types['DrizzleRelationsConfig'], Table>,
+  DBQueryConfig<'many', Types['DrizzleRelations'], Table>,
   'limit' | 'offset' | 'columns' | 'extra' | 'with' | 'orderBy'
 > & {
-  orderBy?: ConnectionOrderBy<Table> | ((columns: Table['columns']) => ConnectionOrderBy<Table>);
+  orderBy?: ConnectionOrderBy<Table> | ((table: Table) => ConnectionOrderBy<Table>);
 } extends infer QueryConfig
   ? QueryConfig | ((args: Args, context: Types['Context']) => QueryConfig)
   : never;
 
 export type QueryForDrizzleConnection<
   Types extends SchemaTypes,
-  Table extends TableRelationalConfig,
+  TableConfig extends TableRelationalConfig,
 > = Omit<
-  DBQueryConfig<'many', Types['DrizzleRelationsConfig'], Table>,
+  DBQueryConfig<'many', Types['DrizzleRelations'], TableConfig>,
   'limit' | 'offset' | 'orderBy'
 > & {
-  orderBy?: ConnectionOrderBy<Table> | ((columns: Table['columns']) => ConnectionOrderBy<Table>);
+  orderBy?: ConnectionOrderBy<TableConfig> | ((table: Table) => ConnectionOrderBy<TableConfig>);
 };
 
 export type ListRelation<T extends TableRelationalConfig> = {
-  [K in keyof T['relations']]: T['relations'][K] extends Many<string, string> ? K : never;
+  [K in keyof T['relations']]: T['relations'][K] extends Many<string> ? K : never;
 }[keyof T['relations']];
 
 export type DrizzleConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
   Type extends // biome-ignore lint/suspicious/noExplicitAny: this is fine
-  DrizzleRef<any, keyof Types['DrizzleRelationsConfig']> | keyof Types['DrizzleRelationsConfig'],
+  DrizzleRef<any, keyof Types['DrizzleRelations']> | keyof Types['DrizzleRelations'],
   TableConfig extends TableRelationalConfig,
   Param extends OutputType<Types>,
   Nullable extends boolean,
@@ -547,9 +540,11 @@ export type DrizzleConnectionFieldOptions<
         resolve: (
           query: <T extends QueryForRelatedConnection<Types, TableConfig, ConnectionArgs>>(
             selection?: T,
-          ) => Omit<T, 'orderBy'> & {
+          ) => Omit<T, 'orderBy' | 'columns'> & {
             orderBy: {
-              [K in keyof TableConfig['columns']]?: 'asc' | 'desc' | undefined;
+              [K in TableConfig['table']['_'] extends { columns: infer Columns }
+                ? keyof Columns
+                : never]?: 'asc' | 'desc' | undefined;
             };
           },
           parent: ParentShape,
@@ -572,7 +567,7 @@ export type RelatedConnectionOptions<
   Nullable extends boolean,
   Args extends InputFieldMap,
   NodeTable extends
-    TableRelationalConfig = Types['DrizzleRelationsConfig'][Table['relations'][Field]['targetTable']['_']['name']],
+    TableRelationalConfig = Types['DrizzleRelations'][Table['relations'][Field]['targetTable']['_']['name']],
 > = Omit<
   PothosSchemaTypes.ObjectFieldOptions<
     Types,
@@ -627,7 +622,10 @@ export type ConnectionOrderBy<T extends TableRelationalConfig> =
   | Column
   | Column[]
   | {
-      [K in keyof T['columns']]?: 'asc' | 'desc' | undefined;
+      [K in T['table']['_'] extends { columns: infer Columns } ? keyof Columns : never]?:
+        | 'asc'
+        | 'desc'
+        | undefined;
     };
 
 export type ShapeFromConnection<T> = T extends { shape: unknown } ? T['shape'] : never;

package/src/utils/config.ts

@@ -1,5 +1,5 @@
 import { createContextCache, type SchemaTypes } from '@pothos/core';
-import { type AnyRelations, type Column, getTableName, type Table } from 'drizzle-orm';
+import { type AnyRelations, type Column, getTableColumns, isTable, type Table } from 'drizzle-orm';
 import type { DrizzleClient } from '../types';
 
 export interface PothosDrizzleSchemaConfig {
@@ -17,46 +17,35 @@ const configCache = createContextCache(
       relations = (builder.options.drizzle.client as DrizzleClient)._.relations;
     }
 
-    const dbToSchema = Object.values(relations.tables).reduce<Record<string, Table>>(
-      (acc, table) => {
-        const tableName = getTableName(table);
-        if (tableName) {
-          acc[tableName] = table;
-        }
-        return acc;
-      },
-      {},
-    );
-
-    const columnMappings = Object.values(dbToSchema).reduce<Record<string, Record<string, string>>>(
-      (acc, table) => {
-        acc[getTableName(table)] = Object.entries(table).reduce<Record<string, string>>(
-          (acc, [name, column]) => {
-            acc[(column as Column).name] = name;
-            return acc;
-          },
-          {},
-        );
-        return acc;
-      },
-      {},
-    );
+    const columnNameMappings: Record<string, string> = {};
+
+    Object.values(relations).forEach(({ table }) => {
+      if (isTable(table)) {
+        Object.entries(getTableColumns(table)).forEach(([tsName, col]) => {
+          if (col.uniqueName) {
+            columnNameMappings[col.uniqueName] = tsName;
+          }
+        });
+      }
+    });
 
     return {
       skipDeferredFragments: builder.options.drizzle.skipDeferredFragments ?? true,
       columnToTsName: (column) => {
-        const tableName = getTableName(column.table);
-        const table = columnMappings[tableName];
-        const columnName = table?.[column.name];
+        if (!column.uniqueName) {
+          throw new Error(`Column ${String(column.name)} has no uniqueName`);
+        }
 
-        if (!columnName) {
-          throw new Error(`Could not find column mapping for ${tableName}.${column.name}`);
+        if (!(column.uniqueName in columnNameMappings)) {
+          throw new Error(`Typescript name not found for ${column.uniqueName}`);
         }
 
-        return columnName;
+        return columnNameMappings[column.uniqueName];
       },
       getPrimaryKey: (tableName) => {
-        const tableConfig = builder.options.drizzle.getTableConfig(relations.tables[tableName]);
+        const tableConfig = builder.options.drizzle.getTableConfig(
+          relations[tableName].table as Table,
+        );
 
         const primaryKey = tableConfig.columns.find((column) => column.primary);
 

package/src/utils/cursors.ts

@@ -5,7 +5,14 @@ import {
   PothosValidationError,
   type SchemaTypes,
 } from '@pothos/core';
-import type { Column, DBQueryConfig, SQL, TableConfig, TableRelationalConfig } from 'drizzle-orm';
+import {
+  type Column,
+  type DBQueryConfig,
+  getTableColumns,
+  type SQL,
+  type Table,
+  type TableRelationalConfig,
+} from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
 import type { ConnectionOrderBy, QueryForDrizzleConnection } from '../types';
 import type { PothosDrizzleSchemaConfig } from './config';
@@ -150,18 +157,23 @@ export function parseSerializedIDColumn(id: string, field: Column): unknown {
   }
 
   try {
-    switch (field.dataType) {
-      case 'date':
-        return new Date(id);
-      case 'string':
-        return id;
-      case 'number':
-        return Number.parseInt(id, 10);
-      case 'bigint':
-        return BigInt(id);
-      default:
-        throw new PothosValidationError(`Unsupported ID type ${field.dataType}`);
+    if (field.dataType.startsWith('number')) {
+      return Number.parseInt(id, 10);
     }
+
+    if (field.dataType.startsWith('bigint')) {
+      return BigInt(id);
+    }
+
+    if (field.dataType.startsWith('string')) {
+      return id;
+    }
+
+    if (field.dataType === 'object date') {
+      return new Date(id);
+    }
+
+    throw new PothosValidationError(`Unsupported ID type ${field.dataType}`);
   } catch (error: unknown) {
     if (error instanceof PothosValidationError) {
       throw error;
@@ -283,12 +295,12 @@ export interface DrizzleCursorConnectionQueryOptions {
   orderBy: ConnectionOrderBy<TableRelationalConfig>;
   where?: SQL;
   config: PothosDrizzleSchemaConfig;
-  table: TableRelationalConfig | TableConfig;
+  table: TableRelationalConfig;
 }
 
 function parseOrderBy(
   config: PothosDrizzleSchemaConfig,
-  table: TableRelationalConfig | TableConfig,
+  table: TableRelationalConfig,
   orderBy: ConnectionOrderBy<TableRelationalConfig>,
   invert: boolean,
 ) {
@@ -310,13 +322,14 @@ function parseOrderBy(
       normalized.push({ direction: 'asc', column: field });
     }
   } else {
+    const tableColumns = getTableColumns(table.table as Table);
     Object.entries(
       orderBy as {
         [k: string]: 'asc' | 'desc' | undefined;
       },
     ).forEach(([name, direction]) => {
       if (direction) {
-        const column = table.columns[name] as Column;
+        const column = tableColumns[name];
         columns.push(column);
         entries.push([name, direction === 'asc' ? asc : desc]);
         normalized.push({ direction: direction, column });
@@ -506,7 +519,7 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
   ) => MaybePromise<readonly T[]>,
   parent: unknown,
 ) {
-  const table = config.relations.tablesConfig[tableName];
+  const table = config.relations[tableName];
   let query: DBQueryConfig<'many'>;
   let formatter: (node: Record<string, unknown>) => string;
   const results = await resolve((q = {}) => {
@@ -514,8 +527,8 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
       ...options,
       config,
       orderBy:
-        (typeof q.orderBy === 'function' ? q.orderBy(table.columns) : q.orderBy) ??
-        config.getPrimaryKey(table.tsName),
+        (typeof q.orderBy === 'function' ? q.orderBy(table.table as Table) : q.orderBy) ??
+        config.getPrimaryKey(table.name),
       table,
     });
     formatter = getCursorFormatter(cursorColumns, config);

package/src/utils/selections.ts

@@ -1,10 +1,5 @@
 import { PothosValidationError } from '@pothos/core';
-import {
-  type DBQueryConfig,
-  getTableUniqueName,
-  type Table,
-  type TableRelationalConfig,
-} from 'drizzle-orm';
+import type { DBQueryConfig, TableRelationalConfig } from 'drizzle-orm';
 import type { PothosDrizzleSchemaConfig } from './config';
 import { deepEqual } from './deep-equal';
 import type { LoaderMappings } from './loader-map';
@@ -132,12 +127,10 @@ export function mergeSelection(
       const relation = state.table.relations[key];
 
       if (!relation) {
-        throw new PothosValidationError(`Relation ${key} does not exist on ${state.table.dbName}`);
+        throw new PothosValidationError(`Relation ${key} does not exist on ${state.table.name}`);
       }
 
-      const tableUniqueName = getTableUniqueName(relation.targetTable as Table);
-      const tableName = config.relations.tableNamesMap[tableUniqueName];
-      merge(config.relations.tablesConfig[tableName], key, value as SelectionMap | boolean);
+      merge(config.relations[relation.targetTableName], key, value as SelectionMap | boolean);
     }
   }
 
@@ -184,21 +177,18 @@ export function selectionToQuery(
 ): SelectionMap {
   const query: SelectionMap & { extras: Record<string, unknown> } = {
     ...state.query,
+    columns: undefined,
     with: {},
-    columns: {},
     extras: {},
   };
 
-  if (state.allColumns) {
-    for (const key of Object.keys(state.table.columns)) {
-      query.columns![key] = true;
-    }
-  } else {
+  if (!state.allColumns) {
+    query.columns = {};
     for (const key of state.columns) {
       query.columns![key] = true;
     }
 
-    for (const column of config.getPrimaryKey(state.table.tsName)) {
+    for (const column of config.getPrimaryKey(state.table.name)) {
       const tsName = config.columnToTsName(column);
       query.columns![tsName] = true;
     }