@pothos/plugin-drizzle 0.17.4 → 0.17.6

package/src/drizzle-field-builder.ts

@@ -37,7 +37,7 @@ import {
   isInterfaceType,
   isObjectType,
 } from 'graphql';
-import type { DrizzleRef } from './interface-ref';
+import type { DrizzleRef } from './interface-ref.js';
 import type {
   DrizzleConnectionShape,
   ListRelation,
@@ -48,15 +48,15 @@ import type {
   ShapeFromConnection,
   TypesForRelation,
   VariantFieldOptions,
-} from './types';
-import { getClient, getSchemaConfig } from './utils/config';
+} from './types.js';
+import { getClient, getSchemaConfig } from './utils/config.js';
 import {
   drizzleCursorConnectionQuery,
   getCursorFormatter,
   wrapConnectionResult,
-} from './utils/cursors';
-import { getRefFromModel } from './utils/refs';
-import type { SelectionMap } from './utils/selections';
+} from './utils/cursors.js';
+import { getRefFromModel } from './utils/refs.js';
+import { omitUndefinedKeys, type SelectionMap } from './utils/selections.js';
 
 // Workaround for FieldKind not being extended on Builder classes
 const RootBuilder: {
@@ -526,7 +526,7 @@ export class DrizzleObjectFieldBuilder<
       const relQuery = {
         columns: {},
         with: {
-          [name]: {
+          [name]: omitUndefinedKeys({
             ...nestedQuery(query),
             ...((typeof query === 'function'
               ? (query as (args: {}, context: {}, pathInfo: PathInfo) => {})(
@@ -535,7 +535,7 @@ export class DrizzleObjectFieldBuilder<
                   pathInfo,
                 )
               : query) as {}),
-          },
+          }),
         },
       };
 

package/src/field-builder.ts

@@ -3,13 +3,13 @@ import { type FieldKind, ObjectRef, RootFieldBuilder, type SchemaTypes } from '@
 import type { TableRelationalConfig } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
 import { isInterfaceType, isObjectType, Kind } from 'graphql';
-import type { DrizzleRef } from './interface-ref';
-import type { DrizzleConnectionFieldOptions } from './types';
-import { getSchemaConfig } from './utils/config';
-import { resolveDrizzleCursorConnection } from './utils/cursors';
-import { queryFromInfo } from './utils/map-query';
-import { getRefFromModel } from './utils/refs';
-import type { SelectionMap } from './utils/selections';
+import type { DrizzleRef } from './interface-ref.js';
+import type { DrizzleConnectionFieldOptions } from './types.js';
+import { getSchemaConfig } from './utils/config.js';
+import { resolveDrizzleCursorConnection } from './utils/cursors.js';
+import { queryFromInfo } from './utils/map-query.js';
+import { getRefFromModel } from './utils/refs.js';
+import type { SelectionMap } from './utils/selections.js';
 
 const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFieldBuilder<
   SchemaTypes,

package/src/global-types.ts

@@ -17,11 +17,11 @@ import type {
   TableRelationalConfig,
   TablesRelationalConfig,
 } from 'drizzle-orm';
-import type { PothosDrizzlePlugin } from '.';
-import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import type { DrizzleInterfaceRef, DrizzleRef } from './interface-ref';
-import type { DrizzleNodeRef } from './node-ref';
-import type { DrizzleObjectRef, drizzleTableKey } from './object-ref';
+import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder.js';
+import type { PothosDrizzlePlugin } from './index.js';
+import type { DrizzleInterfaceRef, DrizzleRef } from './interface-ref.js';
+import type { DrizzleNodeRef } from './node-ref.js';
+import type { DrizzleObjectRef, drizzleTableKey } from './object-ref.js';
 import type {
   DrizzleConnectionFieldOptions,
   DrizzleConnectionShape,
@@ -35,7 +35,7 @@ import type {
   drizzleTableName,
   ShapeFromConnection,
   ShapeFromIdColumns,
-} from './types';
+} from './types.js';
 
 declare global {
   export namespace PothosSchemaTypes {

package/src/index.ts

@@ -1,6 +1,6 @@
-import './global-types';
-import './field-builder';
-import './schema-builder';
+import './global-types.js';
+import './field-builder.js';
+import './schema-builder.js';
 import SchemaBuilder, {
   BasePlugin,
   type PothosOutputFieldConfig,
@@ -9,14 +9,14 @@ import SchemaBuilder, {
   type SchemaTypes,
 } from '@pothos/core';
 import type { GraphQLFieldResolver } from 'graphql';
-import type { ModelLoader } from './model-loader';
-import { getLoaderMapping, setLoaderMappings } from './utils/loader-map';
-
-export { drizzleConnectionHelpers } from './connection-helpers';
-export { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-export * from './types';
-export { drizzleTableName } from './types';
-export { drizzleClientCache } from './utils/config';
+import type { ModelLoader } from './model-loader.js';
+import { getLoaderMapping, setLoaderMappings } from './utils/loader-map.js';
+
+export { drizzleConnectionHelpers } from './connection-helpers.js';
+export { DrizzleObjectFieldBuilder } from './drizzle-field-builder.js';
+export * from './types.js';
+export { drizzleTableName } from './types.js';
+export { drizzleClientCache } from './utils/config.js';
 
 const pluginName = 'drizzle';
 

package/src/interface-ref.ts

@@ -1,6 +1,6 @@
 import { InterfaceRef, type SchemaTypes } from '@pothos/core';
-import type { DrizzleNodeRef } from './node-ref';
-import { type DrizzleObjectRef, drizzleTableKey } from './object-ref';
+import type { DrizzleNodeRef } from './node-ref.js';
+import { type DrizzleObjectRef, drizzleTableKey } from './object-ref.js';
 
 export type DrizzleRef<
   Types extends SchemaTypes,

package/src/model-loader.ts

@@ -9,16 +9,16 @@ import {
   type TableRelationalConfig,
 } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import { getClient, getSchemaConfig, type PothosDrizzleSchemaConfig } from './utils/config';
-import { cacheKey, setLoaderMappings } from './utils/loader-map';
-import { selectionStateFromInfo, stateFromInfo } from './utils/map-query';
+import { getClient, getSchemaConfig, type PothosDrizzleSchemaConfig } from './utils/config.js';
+import { cacheKey, setLoaderMappings } from './utils/loader-map.js';
+import { selectionStateFromInfo, stateFromInfo } from './utils/map-query.js';
 import {
   mergeSelection,
   type SelectionMap,
   type SelectionState,
   selectionCompatible,
   selectionToQuery,
-} from './utils/selections';
+} from './utils/selections.js';
 
 interface ResolvablePromise<T> {
   promise: Promise<T>;

package/src/node-ref.ts

@@ -1,5 +1,5 @@
 import type { SchemaTypes } from '@pothos/core';
-import { DrizzleObjectRef } from './object-ref';
+import { DrizzleObjectRef } from './object-ref.js';
 
 export const relayIDShapeKey = Symbol.for('Pothos.relayIDShapeKey');
 

package/src/object-ref.ts

@@ -5,7 +5,7 @@ import {
   type SchemaTypes,
   typeBrandKey,
 } from '@pothos/core';
-import type { WithBrand } from './types';
+import type { WithBrand } from './types.js';
 
 export const drizzleTableKey = Symbol.for('Pothos.drizzleTableKey');
 

package/src/schema-builder.ts

@@ -10,15 +10,15 @@ import SchemaBuilder, {
 } from '@pothos/core';
 import type { Column } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import { DrizzleInterfaceRef } from './interface-ref';
-import { ModelLoader } from './model-loader';
-import { DrizzleNodeRef } from './node-ref';
-import { DrizzleObjectRef } from './object-ref';
-import type { DrizzleNodeOptions } from './types';
-import { getSchemaConfig } from './utils/config';
-import { getIDParser, getIDSerializer } from './utils/cursors';
-import { getRefFromModel } from './utils/refs';
+import { DrizzleObjectFieldBuilder } from './drizzle-field-builder.js';
+import { DrizzleInterfaceRef } from './interface-ref.js';
+import { ModelLoader } from './model-loader.js';
+import { DrizzleNodeRef } from './node-ref.js';
+import { DrizzleObjectRef } from './object-ref.js';
+import type { DrizzleNodeOptions } from './types.js';
+import { getSchemaConfig } from './utils/config.js';
+import { getIDParser, getIDSerializer } from './utils/cursors.js';
+import { getRefFromModel } from './utils/refs.js';
 
 const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
 

package/src/types.ts

@@ -39,10 +39,10 @@ import type {
   TableRelationalConfig,
 } from 'drizzle-orm';
 import type { FieldNode, GraphQLResolveInfo } from 'graphql';
-import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import type { DrizzleRef } from './interface-ref';
-import type { IndirectInclude } from './utils/map-query';
-import type { SelectionMap } from './utils/selections';
+import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder.js';
+import type { DrizzleRef } from './interface-ref.js';
+import type { IndirectInclude } from './utils/map-query.js';
+import type { SelectionMap } from './utils/selections.js';
 
 export interface FieldPathInfo {
   field: string;
@@ -736,4 +736,4 @@ export interface DrizzleGraphQLInputExtensions {
   inputType: 'insert' | 'filters' | 'orderBy' | 'update';
 }
 
-export { DrizzleObjectRef } from './object-ref';
+export { DrizzleObjectRef } from './object-ref.js';

package/src/utils/config.ts

@@ -1,6 +1,6 @@
 import { createContextCache, type SchemaTypes } from '@pothos/core';
 import { type AnyRelations, type Column, getColumns, isTable, type Table } from 'drizzle-orm';
-import type { DrizzleClient } from '../types';
+import type { DrizzleClient } from '../types.js';
 
 export interface PothosDrizzleSchemaConfig {
   skipDeferredFragments: boolean;

package/src/utils/cursors.ts

@@ -14,10 +14,10 @@ import {
   type TableRelationalConfig,
 } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import type { ConnectionOrderBy, QueryForDrizzleConnection } from '../types';
-import type { PothosDrizzleSchemaConfig } from './config';
-import { queryFromInfo } from './map-query';
-import type { SelectionMap } from './selections';
+import type { ConnectionOrderBy, QueryForDrizzleConnection } from '../types.js';
+import type { PothosDrizzleSchemaConfig } from './config.js';
+import { queryFromInfo } from './map-query.js';
+import { omitUndefinedKeys, type SelectionMap } from './selections.js';
 
 const DEFAULT_MAX_SIZE = 100;
 const DEFAULT_SIZE = 20;
@@ -446,13 +446,13 @@ export function drizzleCursorConnectionQuery({
     whereClauses.push(parts.length > 1 ? { OR: parts } : parts[0]);
   }
 
-  return {
+  return omitUndefinedKeys({
     cursorColumns: parsedOrderBy.columns,
     columns,
     orderBy: parsedOrderBy.orderBy,
     limit,
     where: whereClauses.length > 1 ? { AND: whereClauses } : whereClauses[0],
-  };
+  });
 }
 
 export function wrapConnectionResult<T extends {}>(
@@ -540,7 +540,7 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
     query = queryFromInfo({
       context: options.ctx,
       info,
-      select: {
+      select: omitUndefinedKeys({
         ...connectionQuery,
         columns: {
           ...q.columns,
@@ -552,7 +552,7 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
                 AND: [q.where, connectionQuery.where],
               }
             : q.where || connectionQuery.where,
-      } as never,
+      }) as never,
       paths: [['nodes'], ['edges', 'node']],
       typeName,
       config,

package/src/utils/map-query.ts

@@ -20,9 +20,9 @@ import {
   Kind,
   type SelectionSetNode,
 } from 'graphql';
-import type { DrizzleFieldSelection, FieldPathInfo, PathInfo } from '../types';
-import type { PothosDrizzleSchemaConfig } from './config';
-import { type LoaderMappings, setLoaderMappings } from './loader-map';
+import type { DrizzleFieldSelection, FieldPathInfo, PathInfo } from '../types.js';
+import type { PothosDrizzleSchemaConfig } from './config.js';
+import { type LoaderMappings, setLoaderMappings } from './loader-map.js';
 import {
   createState,
   mergeSelection,
@@ -30,8 +30,8 @@ import {
   type SelectionState,
   selectionCompatible,
   selectionToQuery,
-} from './selections';
-import { wrapWithUsageCheck } from './usage';
+} from './selections.js';
+import { wrapWithUsageCheck } from './usage.js';
 
 export interface IndirectInclude {
   getType: () => string;

package/src/utils/refs.ts

@@ -1,6 +1,6 @@
 import { PothosSchemaError, type SchemaTypes } from '@pothos/core';
-import { DrizzleInterfaceRef, type DrizzleRef } from '../interface-ref';
-import { DrizzleObjectRef } from '../object-ref';
+import { DrizzleInterfaceRef, type DrizzleRef } from '../interface-ref.js';
+import { DrizzleObjectRef } from '../object-ref.js';
 
 export const refMap = new WeakMap<object, Map<string, DrizzleRef<never>>>();
 

package/src/utils/selections.ts

@@ -1,8 +1,8 @@
 import { PothosValidationError } from '@pothos/core';
 import type { DBQueryConfig, TableRelationalConfig } from 'drizzle-orm';
-import type { PothosDrizzleSchemaConfig } from './config';
-import { deepEqual } from './deep-equal';
-import type { LoaderMappings } from './loader-map';
+import type { PothosDrizzleSchemaConfig } from './config.js';
+import { deepEqual } from './deep-equal.js';
+import type { LoaderMappings } from './loader-map.js';
 
 export interface SelectionState {
   table: TableRelationalConfig;
@@ -19,6 +19,13 @@ export interface SelectionState {
 
 export type SelectionMap = DBQueryConfig<'one'>;
 
+export function omitUndefinedKeys<T extends object>(query: T): T {
+  const entries = Object.entries(query);
+  const defined = entries.filter(([, value]) => value !== undefined);
+
+  return defined.length === entries.length ? query : (Object.fromEntries(defined) as T);
+}
+
 export function selectionCompatible(
   state: SelectionState,
   selectionMap: SelectionMap | boolean,
@@ -53,7 +60,7 @@ export function selectionCompatible(
     return false;
   }
 
-  return ignoreQuery || deepEqual(state.query, query);
+  return ignoreQuery || deepEqual(state.query, omitUndefinedKeys(query));
 }
 
 export function stateCompatible(
@@ -134,8 +141,9 @@ export function mergeSelection(
     }
   }
 
-  if (Object.keys(query).length > 0) {
-    state.query = query;
+  const normalizedQuery = omitUndefinedKeys(query);
+  if (Object.keys(normalizedQuery).length > 0) {
+    state.query = normalizedQuery;
   }
 
   if (extras) {
@@ -178,7 +186,7 @@ export function selectionToQuery(
   state: SelectionState,
 ): SelectionMap {
   const query: SelectionMap & { extras: Record<string, unknown> } = {
-    ...state.query,
+    ...omitUndefinedKeys(state.query),
     columns: undefined,
     with: {},
     extras: {},