@pothos/plugin-prisma 0.17.1 → 0.19.0

package/src/util/deep-equal.ts

@@ -0,0 +1,51 @@
+/* eslint-disable no-continue */
+export function deepEqual(left: unknown, right: unknown, ignore?: Set<string>) {
+  if (left === right) {
+    return true;
+  }
+
+  if (left && right && typeof left === 'object' && typeof right === 'object') {
+    if (Array.isArray(left)) {
+      if (!Array.isArray(right)) {
+        return false;
+      }
+
+      const { length } = left;
+
+      if (right.length !== length) {
+        return false;
+      }
+
+      for (let i = 0; i < length; i += 1) {
+        if (!deepEqual(left[i], right[i])) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    const keys = Object.keys(left);
+    const keyLength = keys.length;
+
+    if (keyLength !== Object.keys(right).length) {
+      return false;
+    }
+
+    for (const key of keys) {
+      if (ignore?.has(key)) {
+        continue;
+      }
+
+      if (
+        !deepEqual((left as Record<string, unknown>)[key], (right as Record<string, unknown>)[key])
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}

package/src/{loader-map.ts → util/loader-map.ts}

@@ -1,10 +1,11 @@
-import { GraphQLResolveInfo } from 'graphql';
+import { GraphQLNamedType, GraphQLResolveInfo } from 'graphql';
 import { createContextCache } from '@pothos/core';
-import { LoaderMappings } from './types';
+import { LoaderMappings } from '../types';
+import { getIndirectType } from './map-query';
 
 const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
 
-export function cacheKey(path: GraphQLResolveInfo['path'], subPath: string[]) {
+export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[]) {
   let key = '';
   let current: GraphQLResolveInfo['path'] | undefined = path;
 
@@ -19,30 +20,29 @@ export function cacheKey(path: GraphQLResolveInfo['path'], subPath: string[]) {
     key = `${key}.${entry}`;
   }
 
-  return key;
+  return `${type}@${key}`;
 }
 
 export function setLoaderMappings(
   ctx: object,
-  path: GraphQLResolveInfo['path'],
+  info: GraphQLResolveInfo,
   value: LoaderMappings,
+  type: GraphQLNamedType,
 ) {
   Object.keys(value).forEach((field) => {
     const map = cache(ctx);
 
-    for (const mapping of value[field]) {
-      const selectionName = mapping.alias ?? mapping.field;
-      const subPath = [...mapping.indirectPath, selectionName];
-      const key = cacheKey(path, subPath);
+    const mapping = value[field];
+    const subPath = [...mapping.indirectPath, field];
+    const key = cacheKey(getIndirectType(type, info).name, info.path, subPath);
 
-      map.set(key, mapping.mappings);
-    }
+    map.set(key, mapping.mappings);
   });
 }
 
-export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path']) {
+export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string) {
   const map = cache(ctx);
-  const key = cacheKey(path, []);
+  const key = cacheKey(type, path, []);
 
   return map.get(key) ?? null;
 }

package/src/util/map-query.ts

@@ -0,0 +1,327 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-continue */
+import {
+  FieldNode,
+  FragmentDefinitionNode,
+  getNamedType,
+  GraphQLNamedType,
+  GraphQLObjectType,
+  GraphQLResolveInfo,
+  InlineFragmentNode,
+  isObjectType,
+  Kind,
+  SelectionSetNode,
+} from 'graphql';
+import { getArgumentValues } from 'graphql/execution/values';
+import { setLoaderMappings } from './loader-map';
+import { FieldMap } from './relation-map';
+import {
+  createState,
+  mergeSelection,
+  selectionCompatible,
+  SelectionState,
+  selectionToQuery,
+} from './selections';
+
+import { FieldSelection, IncludeMap, IndirectInclude, LoaderMappings, SelectionMap } from '..';
+
+function addTypeSelectionsForField(
+  type: GraphQLNamedType,
+  context: object,
+  info: GraphQLResolveInfo,
+  state: SelectionState,
+  selection: FieldNode,
+  indirectPath: string[],
+) {
+  if (selection.name.value.startsWith('__')) {
+    return;
+  }
+
+  const {
+    pothosPrismaInclude,
+    pothosPrismaSelect,
+    pothosPrismaIndirectInclude,
+    pothosPrismaModel,
+  } = (type.extensions ?? {}) as {
+    pothosPrismaModel?: string;
+    pothosPrismaInclude?: IncludeMap;
+    pothosPrismaSelect?: IncludeMap;
+    pothosPrismaIndirectInclude?: IndirectInclude;
+  };
+
+  if (pothosPrismaIndirectInclude) {
+    resolveIndirectInclude(
+      type,
+      info,
+      selection,
+      pothosPrismaIndirectInclude.path,
+      indirectPath,
+      (resolvedType, field, path) => {
+        addTypeSelectionsForField(resolvedType, context, info, state, field, path);
+      },
+    );
+  }
+
+  if (!isObjectType(type)) {
+    return;
+  }
+
+  if (pothosPrismaModel && !pothosPrismaSelect) {
+    state.mode = 'include';
+  }
+
+  if (pothosPrismaInclude || pothosPrismaSelect) {
+    mergeSelection(state, {
+      select: pothosPrismaSelect ? { ...pothosPrismaSelect } : undefined,
+      include: pothosPrismaInclude ? { ...pothosPrismaInclude } : undefined,
+    });
+  }
+
+  if (selection.selectionSet) {
+    addNestedSelections(type, context, info, state, selection.selectionSet, indirectPath);
+  }
+}
+
+function resolveIndirectInclude(
+  type: GraphQLNamedType,
+  info: GraphQLResolveInfo,
+  selection: FieldNode | FragmentDefinitionNode | InlineFragmentNode,
+  includePath: IndirectInclude['path'],
+  path: string[],
+  resolve: (type: GraphQLNamedType, field: FieldNode, path: string[]) => void,
+) {
+  const [include, ...rest] = includePath;
+  if (!selection.selectionSet || !include) {
+    return;
+  }
+
+  for (const sel of selection.selectionSet.selections) {
+    switch (sel.kind) {
+      case Kind.FIELD:
+        if (sel.name.value === include.name && isObjectType(type)) {
+          const returnType = getNamedType(type.getFields()[sel.name.value].type);
+
+          if (rest.length === 0) {
+            resolve(returnType, sel, [...path, sel.alias?.value ?? sel.name.value]);
+          } else {
+            resolveIndirectInclude(
+              returnType,
+              info,
+              sel,
+              rest,
+              [...path, sel.alias?.value ?? sel.name.value],
+              resolve,
+            );
+          }
+        }
+        continue;
+      case Kind.FRAGMENT_SPREAD:
+        if (info.fragments[sel.name.value].typeCondition.name.value === include.type) {
+          resolveIndirectInclude(
+            info.schema.getType(include.type)!,
+            info,
+            info.fragments[sel.name.value],
+            includePath,
+            path,
+            resolve,
+          );
+        }
+
+        continue;
+
+      case Kind.INLINE_FRAGMENT:
+        if (!sel.typeCondition || sel.typeCondition.name.value === include.type) {
+          resolveIndirectInclude(
+            sel.typeCondition ? info.schema.getType(sel.typeCondition.name.value)! : type,
+            info,
+            sel,
+            includePath,
+            path,
+            resolve,
+          );
+        }
+
+        continue;
+
+      default:
+        throw new Error(`Unsupported selection kind ${(selection as { kind: string }).kind}`);
+    }
+  }
+}
+
+function addNestedSelections(
+  type: GraphQLObjectType,
+  context: object,
+  info: GraphQLResolveInfo,
+  state: SelectionState,
+  selections: SelectionSetNode,
+  indirectPath: string[],
+) {
+  for (const selection of selections.selections) {
+    switch (selection.kind) {
+      case Kind.FIELD:
+        addFieldSelection(type, context, info, state, selection, indirectPath);
+
+        continue;
+      case Kind.FRAGMENT_SPREAD:
+        if (info.fragments[selection.name.value].typeCondition.name.value !== type.name) {
+          continue;
+        }
+
+        addNestedSelections(
+          type,
+          context,
+          info,
+          state,
+          info.fragments[selection.name.value].selectionSet,
+          indirectPath,
+        );
+
+        continue;
+
+      case Kind.INLINE_FRAGMENT:
+        if (selection.typeCondition && selection.typeCondition.name.value !== type.name) {
+          continue;
+        }
+
+        addNestedSelections(type, context, info, state, selection.selectionSet, indirectPath);
+
+        continue;
+
+      default:
+        throw new Error(`Unsupported selection kind ${(selection as { kind: string }).kind}`);
+    }
+  }
+}
+
+function addFieldSelection(
+  type: GraphQLObjectType,
+  context: object,
+  info: GraphQLResolveInfo,
+  state: SelectionState,
+  selection: FieldNode,
+  indirectPath: string[],
+) {
+  if (selection.name.value.startsWith('__')) {
+    return;
+  }
+
+  const field = type.getFields()[selection.name.value];
+
+  if (!field) {
+    throw new Error(`Unknown field ${selection.name.value} on ${type.name}`);
+  }
+
+  const fieldSelect = field.extensions?.pothosPrismaSelect as FieldSelection | undefined;
+
+  let fieldSelectionMap: SelectionMap;
+
+  const fieldParentSelect = field.extensions?.pothosPrismaParentSelect as
+    | Record<string, SelectionMap | boolean>
+    | undefined;
+  let mappings: LoaderMappings = {};
+
+  if (typeof fieldSelect === 'function') {
+    const args = getArgumentValues(field, selection, info.variableValues) as Record<
+      string,
+      unknown
+    >;
+
+    fieldSelectionMap = fieldSelect(args, context, (rawQuery) => {
+      const returnType = getNamedType(field.type);
+      const query = typeof rawQuery === 'function' ? rawQuery(args, context) : rawQuery;
+
+      const fieldState = createStateForType(returnType, info, state);
+
+      if (typeof query === 'object' && Object.keys(query).length > 0) {
+        mergeSelection(fieldState, { select: {}, ...query });
+      }
+
+      addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
+
+      // eslint-disable-next-line prefer-destructuring
+      mappings = fieldState.mappings;
+
+      return selectionToQuery(fieldState);
+    });
+  } else {
+    fieldSelectionMap = { select: fieldSelect };
+  }
+
+  if (fieldSelect && selectionCompatible(state, fieldSelectionMap, true)) {
+    mergeSelection(state, fieldSelectionMap);
+    state.mappings[selection.alias?.value ?? selection.name.value] = {
+      field: selection.name.value,
+      mappings,
+      indirectPath,
+    };
+  } else if (
+    fieldParentSelect &&
+    state.parent &&
+    selectionCompatible(state.parent, { select: fieldParentSelect }, true)
+  ) {
+    mergeSelection(state.parent, { select: fieldParentSelect });
+    state.mappings[selection.alias?.value ?? selection.name.value] = {
+      field: selection.name.value,
+      mappings,
+      indirectPath,
+    };
+  }
+}
+
+export function queryFromInfo(context: object, info: GraphQLResolveInfo, typeName?: string): {} {
+  const type = typeName ? info.schema.getTypeMap()[typeName] : getNamedType(info.returnType);
+  const state = createStateForType(type, info);
+
+  addTypeSelectionsForField(type, context, info, state, info.fieldNodes[0], []);
+
+  setLoaderMappings(context, info, state.mappings, type);
+
+  return selectionToQuery(state);
+}
+
+export function selectionStateFromInfo(
+  context: object,
+  info: GraphQLResolveInfo,
+  typeName?: string,
+) {
+  const type = typeName ? info.schema.getTypeMap()[typeName] : info.parentType;
+
+  const state = createStateForType(type, info);
+
+  if (!isObjectType(type)) {
+    throw new Error('Prisma plugin can only resolve includes for object types');
+  }
+
+  addFieldSelection(type, context, info, state, info.fieldNodes[0], []);
+
+  return state;
+}
+
+function createStateForType(
+  type: GraphQLNamedType,
+  info: GraphQLResolveInfo,
+  parent?: SelectionState,
+) {
+  const targetType = getIndirectType(type, info);
+
+  const fieldMap = targetType.extensions.pothosPrismaFieldMap as FieldMap;
+
+  return createState(
+    fieldMap,
+    targetType.extensions.pothosPrismaSelect ? 'select' : 'include',
+    parent,
+  );
+}
+
+export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo) {
+  let targetType = type;
+
+  while (targetType.extensions.pothosPrismaIndirectInclude) {
+    targetType = info.schema.getType(
+      (targetType.extensions.pothosPrismaIndirectInclude as IndirectInclude).getType(),
+    )!;
+  }
+
+  return targetType;
+}

package/src/util/relation-map.ts

@@ -0,0 +1,36 @@
+import { createContextCache } from '@pothos/core';
+import { DMMF } from '@prisma/generator-helper';
+
+export interface FieldMap {
+  model: string;
+  relations: Map<string, FieldMap>;
+}
+
+export type RelationMap = Map<string, FieldMap>;
+
+export const getRelationMap = createContextCache((client: object) =>
+  createRelationMap(
+    // eslint-disable-next-line no-underscore-dangle
+    (client as unknown as { _dmmf: { datamodel: DMMF.Datamodel } })._dmmf.datamodel,
+  ),
+);
+
+export function createRelationMap({ models }: DMMF.Datamodel) {
+  const relationMap: RelationMap = new Map();
+
+  models.forEach((model) => {
+    relationMap.set(model.name, { model: model.name, relations: new Map() });
+  });
+
+  models.forEach((model) => {
+    const map = relationMap.get(model.name)!.relations;
+
+    model.fields.forEach((field) => {
+      if (field.kind === 'object' && relationMap.has(field.type)) {
+        map.set(field.name, relationMap.get(field.type)!);
+      }
+    });
+  });
+
+  return relationMap;
+}

package/src/util/selections.ts

@@ -0,0 +1,192 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-underscore-dangle */
+import { deepEqual } from './deep-equal';
+import { FieldMap } from './relation-map';
+
+import { LoaderMappings, SelectionMap } from '..';
+
+export type SelectionMode = 'select' | 'include';
+
+export interface SelectionState {
+  fieldMap: FieldMap;
+  query: object;
+  mode: SelectionMode;
+  fields: Set<string>;
+  counts: Set<string>;
+  relations: Map<string, SelectionState>;
+  mappings: LoaderMappings;
+  parent?: SelectionState;
+}
+
+export function selectionCompatible(
+  state: SelectionState,
+  selectionMap: SelectionMap | boolean,
+  ignoreQuery = false,
+): boolean {
+  if (typeof selectionMap === 'boolean') {
+    return ignoreQuery || !selectionMap || Object.keys(state.query).length === 0;
+  }
+
+  const { select, include, ...query } = selectionMap;
+
+  if (select && Object.keys(select).some((key) => compare(key, select[key]))) {
+    return false;
+  }
+
+  if (include && Object.keys(include).some((key) => compare(key, include[key]))) {
+    return false;
+  }
+
+  return ignoreQuery || deepEqual(state.query, query);
+
+  function compare(key: string, value: SelectionMap | boolean) {
+    return (
+      value &&
+      state.fieldMap.relations.has(key) &&
+      state.relations.has(key) &&
+      !selectionCompatible(state.relations.get(key)!, value)
+    );
+  }
+}
+
+export function stateCompatible(
+  state: SelectionState,
+  newState: SelectionState,
+  ignoreQuery = false,
+): boolean {
+  for (const [name, relationState] of newState.relations) {
+    if (state.relations.has(name) && !stateCompatible(state.relations.get(name)!, relationState)) {
+      return false;
+    }
+  }
+
+  return ignoreQuery || deepEqual(state.query, newState.query);
+}
+
+export function mergeState(state: SelectionState, newState: SelectionState) {
+  for (const [name, relationState] of newState.relations) {
+    if (state.relations.has(name)) {
+      mergeState(state.relations.get(name)!, relationState);
+    }
+  }
+
+  if (newState.mode === 'include') {
+    state.mode = 'include';
+  } else {
+    for (const name of newState.fields) {
+      state.fields.add(name);
+    }
+  }
+}
+
+export function createState(
+  fieldMap: FieldMap,
+  mode: SelectionMode,
+  parent?: SelectionState,
+): SelectionState {
+  return {
+    parent,
+    mode,
+    fieldMap,
+    query: {},
+    fields: new Set(),
+    counts: new Set(),
+    relations: new Map(),
+    mappings: {},
+  };
+}
+
+export function mergeSelection(state: SelectionState, { select, include, ...query }: SelectionMap) {
+  if (state.mode === 'select' && !select) {
+    state.mode = 'include';
+  }
+
+  if (include) {
+    Object.keys(include).forEach((key) => {
+      merge(key, include[key]);
+    });
+  }
+
+  if (select) {
+    Object.keys(select).forEach((key) => {
+      merge(key, select[key]);
+    });
+  }
+
+  if (Object.keys(query).length > 0) {
+    state.query = query;
+  }
+
+  function merge(key: string, value: SelectionMap | boolean) {
+    if (!value) {
+      return;
+    }
+
+    if (key === '_count') {
+      const counts = (value as { select?: {} }).select ?? {};
+      Object.keys(counts).forEach((count) => {
+        state.counts.add(count);
+      });
+
+      return;
+    }
+
+    const selection = value === true ? { include: {} } : value;
+    const childMap = state.fieldMap.relations.get(key);
+
+    if (childMap) {
+      if (state.relations.has(key)) {
+        mergeSelection(state.relations.get(key)!, selection);
+      } else {
+        const relatedState = createState(childMap, 'select');
+        mergeSelection(relatedState, selection);
+        state.relations.set(key, relatedState);
+      }
+    } else {
+      state.fields.add(key);
+    }
+  }
+}
+
+export function selectionToQuery(state: SelectionState): SelectionMap {
+  const nestedIncludes: Record<string, SelectionMap | boolean> = {};
+  const counts: Record<string, boolean> = {};
+
+  let hasSelection = false;
+
+  state.relations.forEach((sel, relation) => {
+    hasSelection = true;
+    const nested = selectionToQuery(sel);
+    nestedIncludes[relation] = Object.keys(nested).length > 0 ? nested : true;
+  });
+
+  if (state.counts.size > 0) {
+    hasSelection = true;
+    for (const count of state.counts) {
+      counts[count] = true;
+    }
+
+    nestedIncludes._count = {
+      select: counts,
+    };
+  }
+
+  if (state.mode === 'select') {
+    state.fields.forEach((field) => {
+      hasSelection = true;
+      nestedIncludes[field] = true;
+    });
+
+    return {
+      ...(state.query as SelectionMap),
+      select: nestedIncludes,
+    };
+  }
+
+  return hasSelection
+    ? {
+        ...state.query,
+        include: nestedIncludes,
+      }
+    : (state.query as SelectionMap);
+}

package/.turbo/turbo-build.log

@@ -1,17 +0,0 @@
-@pothos/plugin-prisma:build: cache hit, replaying output 9c93fd074a680c48
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: > @pothos/plugin-prisma@0.17.1 build /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:build: > pnpm build:cjs && pnpm build:esm
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: > @pothos/plugin-prisma@0.17.1 build:cjs /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:build: > tsc --module commonjs --outDir lib
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: > @pothos/plugin-prisma@0.17.1 build:esm /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:build: > tsc --module es2020 --outDir esm && pnpm esm:extensions
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: 
-@pothos/plugin-prisma:build: > @pothos/plugin-prisma@0.17.1 esm:extensions /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:build: > ts-node --compiler-options "{\"module\":\"commonjs\"}" ../../.config/esm-transformer.ts
-@pothos/plugin-prisma:build: 

package/.turbo/turbo-test.log

@@ -1,18 +0,0 @@
-@pothos/plugin-prisma:test: cache hit, replaying output 1f0f9df2409eabae
-@pothos/plugin-prisma:test: 
-@pothos/plugin-prisma:test: > @pothos/plugin-prisma@0.17.1 test /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:test: > pnpm jest --runInBand
-@pothos/plugin-prisma:test: 
-@pothos/plugin-prisma:test: PASS tests/connections.test.ts (27.557 s)
-@pothos/plugin-prisma:test: PASS tests/index.test.ts
-@pothos/plugin-prisma:test: PASS tests/counts.test.ts
-@pothos/plugin-prisma:test: PASS tests/nodes.test.ts
-@pothos/plugin-prisma:test: PASS tests/relation-query.test.ts
-@pothos/plugin-prisma:test: PASS tests/variants.test.ts
-@pothos/plugin-prisma:test: PASS tests/type-include.test.ts
-@pothos/plugin-prisma:test: 
-@pothos/plugin-prisma:test: Test Suites: 7 passed, 7 total
-@pothos/plugin-prisma:test: Tests:       36 passed, 36 total
-@pothos/plugin-prisma:test: Snapshots:   71 passed, 71 total
-@pothos/plugin-prisma:test: Time:        50.169 s
-@pothos/plugin-prisma:test: Ran all test suites.

package/.turbo/turbo-type.log

@@ -1,5 +0,0 @@
-@pothos/plugin-prisma:type: cache hit, replaying output ebb014e08a51cd14
-@pothos/plugin-prisma:type: 
-@pothos/plugin-prisma:type: > @pothos/plugin-prisma@0.17.1 type /home/runner/work/pothos/pothos/packages/plugin-prisma
-@pothos/plugin-prisma:type: > tsc --noEmit && tsc --project tests/tsconfig.json
-@pothos/plugin-prisma:type: