@pothos/plugin-drizzle 0.8.1 → 0.9.0

package/src/interface-ref.ts

@@ -1,15 +1,19 @@
 import { InterfaceRef, type SchemaTypes } from '@pothos/core';
+import type { DrizzleNodeRef } from './node-ref';
 import { type DrizzleObjectRef, drizzleTableKey } from './object-ref';
 
 export type DrizzleRef<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationSchema'] = keyof Types['DrizzleRelationSchema'],
+  Table extends keyof Types['DrizzleRelationsConfig'] = keyof Types['DrizzleRelationsConfig'],
   T = {},
-> = DrizzleInterfaceRef<Types, Table, T> | DrizzleObjectRef<Types, Table, T>;
+> =
+  | DrizzleInterfaceRef<Types, Table, T>
+  | DrizzleObjectRef<Types, Table, T>
+  | DrizzleNodeRef<Types, Table, T>;
 
 export class DrizzleInterfaceRef<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationSchema'] = keyof Types['DrizzleRelationSchema'],
+  Table extends keyof Types['DrizzleRelationsConfig'] = keyof Types['DrizzleRelationsConfig'],
   T = {},
 > extends InterfaceRef<Types, T> {
   [drizzleTableKey]!: Table;

package/src/model-loader.ts

@@ -1,7 +1,13 @@
 import { type SchemaTypes, createContextCache } from '@pothos/core';
-import { type Column, type TableRelationalConfig, inArray, sql } from 'drizzle-orm';
+import {
+  type AnyTable,
+  type Column,
+  type SQL,
+  type TableRelationalConfig,
+  inArray,
+  sql,
+} from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import type { DrizzleClient } from './types';
 import { type PothosDrizzleSchemaConfig, getClient, getSchemaConfig } from './utils/config';
 import { cacheKey, setLoaderMappings } from './utils/loader-map';
 import { selectionStateFromInfo, stateFromInfo } from './utils/map-query';
@@ -35,7 +41,8 @@ export class ModelLoader {
   config: PothosDrizzleSchemaConfig;
   table: TableRelationalConfig;
   columns: Column[];
-  selectSQL;
+  primaryKey: Column[];
+  selectSQL: (table: AnyTable<{}>) => SQL;
 
   constructor(
     context: object,
@@ -47,12 +54,17 @@ export class ModelLoader {
     this.builder = builder;
     this.modelName = modelName;
     this.config = getSchemaConfig(builder);
-    this.table = this.config.schema[modelName];
-    this.columns = columns ?? this.table.primaryKey;
-    this.selectSQL =
-      this.columns.length > 1
-        ? sql`(${sql.join(this.columns, sql`, `)})`
-        : this.columns[0].getSQL();
+    this.table = this.config.relations.tablesConfig[modelName];
+    this.primaryKey = this.config.getPrimaryKey(modelName);
+    this.columns = columns ?? this.primaryKey;
+    this.selectSQL = (table) => {
+      const columns = this.columns.map((column) =>
+        Object.values(table).find(
+          (tblColumn) => 'columnType' in tblColumn && tblColumn.name === column.name,
+        ),
+      );
+      return columns.length > 1 ? sql`(${sql.join(columns, sql`, `)})` : columns[0].getSQL();
+    };
   }
 
   static forModel<Types extends SchemaTypes>(
@@ -84,7 +96,7 @@ export class ModelLoader {
       const selection = selectionStateFromInfo(this.config, this.context, info);
       this.queryCache.set(key, {
         selection,
-        query: selectionToQuery(selection),
+        query: selectionToQuery(this.config, selection),
       });
     }
 
@@ -103,7 +115,7 @@ export class ModelLoader {
 
       this.queryCache.set(key, {
         selection,
-        query: selectionToQuery(selection),
+        query: selectionToQuery(this.config, selection),
       });
     }
 
@@ -176,18 +188,21 @@ export class ModelLoader {
         )[this.modelName];
 
         const query = api.findMany({
-          ...selectionToQuery(selection),
-          where: inArray(
-            this.selectSQL,
-            [...entry.models.keys()].map((model) => this.sqlForModel(model)),
-          ),
+          ...selectionToQuery(this.config, selection),
+          where: {
+            RAW: (table: AnyTable<{}>) =>
+              inArray(
+                this.selectSQL(table),
+                [...entry.models.keys()].map((model) => this.sqlForModel(model)),
+              ),
+          },
         });
 
         query.then(
           (results) => {
             for (const [model, promise] of entry.models.entries()) {
               const result = results.find((row) =>
-                this.table.primaryKey.every(
+                this.primaryKey.every(
                   (key) => row[key.name] === (model as Record<string, unknown>)[key.name],
                 ),
               );

package/src/node-ref.ts

@@ -5,7 +5,7 @@ export const relayIDShapeKey = Symbol.for('Pothos.relayIDShapeKey');
 
 export class DrizzleNodeRef<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationSchema'] = keyof Types['DrizzleRelationSchema'],
+  Table extends keyof Types['DrizzleRelationsConfig'] = keyof Types['DrizzleRelationsConfig'],
   T = {},
   IDShape = string,
 > extends DrizzleObjectRef<Types, Table, T> {

package/src/object-ref.ts

@@ -11,10 +11,10 @@ export const drizzleTableKey = Symbol.for('Pothos.drizzleTableKey');
 
 export class DrizzleObjectRef<
   Types extends SchemaTypes,
-  Table extends keyof Types['DrizzleRelationSchema'] = keyof Types['DrizzleRelationSchema'],
+  Table extends keyof Types['DrizzleRelationsConfig'] = keyof Types['DrizzleRelationsConfig'],
   T = {},
 > extends ObjectRef<Types, T> {
-  [drizzleTableKey]!: Types['DrizzleRelationSchema'][Table];
+  [drizzleTableKey]!: Types['DrizzleRelationsConfig'][Table];
 
   [abstractReturnShapeKey]!: WithBrand<T>;
 

package/src/schema-builder.ts

@@ -37,7 +37,7 @@ schemaBuilderProto.drizzleObject = function drizzleObject(table, { select, field
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).relations.tablesConfig[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -54,18 +54,14 @@ schemaBuilderProto.drizzleInterface = function drizzleInterface(
 ) {
   const name = options.name ?? table;
 
-  const ref = options.variant
-    ? new DrizzleInterfaceRef(options.variant, name)
-    : (getRefFromModel(table, this, 'interface') as InterfaceRef<SchemaTypes, unknown>);
-
-  ref.name = name ?? table;
+  const ref = new DrizzleInterfaceRef(name, table);
 
   this.interfaceType(ref, {
     ...(options as {}),
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).relations.tablesConfig[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -82,7 +78,7 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes> & {
     nodeInterfaceRef?: () => InterfaceRef<SchemaTypes, unknown>;
   },
-  table: keyof SchemaTypes['DrizzleRelationSchema'],
+  table: keyof SchemaTypes['DrizzleRelations']['config'],
   {
     id: { column, ...idOptions },
     name,
@@ -90,7 +86,7 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
     ...options
   }: DrizzleNodeOptions<
     SchemaTypes,
-    keyof SchemaTypes['DrizzleRelationSchema'],
+    keyof SchemaTypes['DrizzleRelations']['config'],
     {},
     {},
     [],
@@ -98,7 +94,7 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
   >,
 ) {
   const schemaConfig = getSchemaConfig(this);
-  const tableConfig = schemaConfig.schema![table];
+  const tableConfig = schemaConfig.relations.tablesConfig[table];
   const idColumn = typeof column === 'function' ? column(tableConfig.columns) : column;
   const idColumns = Array.isArray(idColumn) ? idColumn : [idColumn];
   const interfaceRef = this.nodeInterfaceRef?.();
@@ -106,7 +102,14 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
   const idParser = getIDParser(idColumns);
   const typeName = variant ?? name ?? table;
   const nodeRef = new DrizzleNodeRef(typeName, table, {
-    parseId: idParser,
+    parseId: (id) => {
+      const parsed = idParser(id);
+      if (Array.isArray(idColumn)) {
+        return parsed;
+      }
+
+      return parsed[schemaConfig.columnToTsName(idColumn)];
+    },
   });
   const modelLoader = ModelLoader.forModel(table, this, idColumns);
 
@@ -206,106 +209,106 @@ schemaBuilderProto.drizzleInterfaceFields = function drizzleInterfaceFields(type
   });
 };
 
-schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
-  this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
-  table: string,
-  type: GraphQLInputObjectType,
-  options?: { extensions?: object },
-) {
-  return (
-    this as typeof this & {
-      addGraphQLInput: (
-        type: GraphQLInputObjectType,
-        options: Record<string, unknown>,
-      ) => InputObjectRef<SchemaTypes, {}>;
-    }
-  ).addGraphQLInput(type, {
-    ...options,
-    extensions: {
-      ...options?.extensions,
-      drizzleGraphQL: {
-        inputType: 'orderBy',
-        table,
-        tableConfig: getSchemaConfig(this).schema?.[table]!,
-      } satisfies DrizzleGraphQLInputExtensions,
-    },
-  });
-} as never;
+// schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
+//   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+//   table: string,
+//   type: GraphQLInputObjectType,
+//   options?: { extensions?: object },
+// ) {
+//   return (
+//     this as typeof this & {
+//       addGraphQLInput: (
+//         type: GraphQLInputObjectType,
+//         options: Record<string, unknown>,
+//       ) => InputObjectRef<SchemaTypes, {}>;
+//     }
+//   ).addGraphQLInput(type, {
+//     ...options,
+//     extensions: {
+//       ...options?.extensions,
+//       drizzleGraphQL: {
+//         inputType: 'orderBy',
+//         table,
+//         tableConfig: getSchemaConfig(this).relations.tablesConfig[table],
+//       } satisfies DrizzleGraphQLInputExtensions,
+//     },
+//   });
+// } as never;
 
-schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
-  this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
-  table: string,
-  type: GraphQLInputObjectType,
-  options?: { extensions?: object },
-) {
-  return (
-    this as typeof this & {
-      addGraphQLInput: (
-        type: GraphQLInputObjectType,
-        options: Record<string, unknown>,
-      ) => InputObjectRef<SchemaTypes, {}>;
-    }
-  ).addGraphQLInput(type, {
-    ...options,
-    extensions: {
-      ...options?.extensions,
-      drizzleGraphQL: {
-        inputType: 'filters',
-        table,
-        tableConfig: getSchemaConfig(this).schema?.[table]!,
-      } satisfies DrizzleGraphQLInputExtensions,
-    },
-  });
-} as never;
+// schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
+//   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+//   table: string,
+//   type: GraphQLInputObjectType,
+//   options?: { extensions?: object },
+// ) {
+//   return (
+//     this as typeof this & {
+//       addGraphQLInput: (
+//         type: GraphQLInputObjectType,
+//         options: Record<string, unknown>,
+//       ) => InputObjectRef<SchemaTypes, {}>;
+//     }
+//   ).addGraphQLInput(type, {
+//     ...options,
+//     extensions: {
+//       ...options?.extensions,
+//       drizzleGraphQL: {
+//         inputType: 'filters',
+//         table,
+//         tableConfig: getSchemaConfig(this).relations.tablesConfig[table],
+//       } satisfies DrizzleGraphQLInputExtensions,
+//     },
+//   });
+// } as never;
 
-schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
-  this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
-  table: string,
-  type: GraphQLInputObjectType,
-  options?: { extensions?: object },
-) {
-  return (
-    this as typeof this & {
-      addGraphQLInput: (
-        type: GraphQLInputObjectType,
-        options: Record<string, unknown>,
-      ) => InputObjectRef<SchemaTypes, {}>;
-    }
-  ).addGraphQLInput(type, {
-    ...options,
-    extensions: {
-      ...options?.extensions,
-      drizzleGraphQL: {
-        inputType: 'insert',
-        table,
-        tableConfig: getSchemaConfig(this).schema?.[table]!,
-      } satisfies DrizzleGraphQLInputExtensions,
-    },
-  });
-} as never;
+// schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
+//   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+//   table: string,
+//   type: GraphQLInputObjectType,
+//   options?: { extensions?: object },
+// ) {
+//   return (
+//     this as typeof this & {
+//       addGraphQLInput: (
+//         type: GraphQLInputObjectType,
+//         options: Record<string, unknown>,
+//       ) => InputObjectRef<SchemaTypes, {}>;
+//     }
+//   ).addGraphQLInput(type, {
+//     ...options,
+//     extensions: {
+//       ...options?.extensions,
+//       drizzleGraphQL: {
+//         inputType: 'insert',
+//         table,
+//         tableConfig: getSchemaConfig(this).relations.tablesConfig[table],
+//       } satisfies DrizzleGraphQLInputExtensions,
+//     },
+//   });
+// } as never;
 
-schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
-  this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
-  table: string,
-  type: GraphQLInputObjectType,
-  options?: { extensions?: object },
-) {
-  return (
-    this as typeof this & {
-      addGraphQLInput: (
-        type: GraphQLInputObjectType,
-        options: Record<string, unknown>,
-      ) => InputObjectRef<SchemaTypes, {}>;
-    }
-  ).addGraphQLInput(type, {
-    ...options,
-    extensions: {
-      ...options?.extensions,
-      drizzleGraphQL: {
-        inputType: 'update',
-        table,
-        tableConfig: getSchemaConfig(this).schema?.[table]!,
-      } satisfies DrizzleGraphQLInputExtensions,
-    },
-  });
-} as never;
+// schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
+//   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+//   table: string,
+//   type: GraphQLInputObjectType,
+//   options?: { extensions?: object },
+// ) {
+//   return (
+//     this as typeof this & {
+//       addGraphQLInput: (
+//         type: GraphQLInputObjectType,
+//         options: Record<string, unknown>,
+//       ) => InputObjectRef<SchemaTypes, {}>;
+//     }
+//   ).addGraphQLInput(type, {
+//     ...options,
+//     extensions: {
+//       ...options?.extensions,
+//       drizzleGraphQL: {
+//         inputType: 'update',
+//         table,
+//         tableConfig: getSchemaConfig(this).relations.tablesConfig[table],
+//       } satisfies DrizzleGraphQLInputExtensions,
+//     },
+//   });
+// } as never;