@pothos/plugin-drizzle 0.1.0 → 0.2.0

package/lib/src/utils/config.js

@@ -2,14 +2,24 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getSchemaConfig", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getClient: function() {
+        return getClient;
+    },
+    getSchemaConfig: function() {
         return getSchemaConfig;
     }
 });
 const _core = require("@pothos/core");
-const cache = (0, _core.createContextCache)((config)=>{
+const configCache = (0, _core.createContextCache)((builder)=>{
+    var _builder_options_drizzle_schema;
+    const config = (_builder_options_drizzle_schema = builder.options.drizzle.schema) !== null && _builder_options_drizzle_schema !== void 0 ? _builder_options_drizzle_schema : builder.options.drizzle.client._;
     const dbToSchema = Object.values(config.schema).reduce((acc, table)=>{
         acc[table.dbName] = table;
         return acc;
@@ -19,8 +29,19 @@ const cache = (0, _core.createContextCache)((config)=>{
         ...config
     };
 });
+const clientCache = (0, _core.createContextCache)((builder)=>{
+    const clientConfig = builder.options.drizzle.client;
+    const getClient = typeof clientConfig === 'function' ? (0, _core.createContextCache)((ctx)=>clientConfig(ctx)) : (_ctx)=>clientConfig;
+    return (0, _core.createContextCache)((context)=>{
+        const client = getClient(context);
+        return client;
+    });
+});
 function getSchemaConfig(builder) {
-    return cache(builder.options.drizzle.client._);
+    return configCache(builder);
+}
+function getClient(builder, context) {
+    return clientCache(builder)(context);
 }
 
 //# sourceMappingURL=config.js.map

package/lib/src/utils/config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/config.ts"],"names":["getSchemaConfig","cache","createContextCache","config","dbToSchema","Object","values","schema","reduce","acc","table","dbName","builder","options","drizzle","client","_"],"mappings":";;;;+BA2BgBA;;;eAAAA;;;sBA3BqC;AAUrD,MAAMC,QAAQC,IAAAA,wBAAkB,EAC9B,CAACC;IACC,MAAMC,aAAaC,OAAOC,MAAM,CAACH,OAAOI,MAAM,EAAEC,MAAM,CACpD,CAACC,KAAKC;QACJD,GAAG,CAACC,MAAMC,MAAM,CAAC,GAAGD;QACpB,OAAOD;IACT,GACA,CAAC;IAGH,OAAO;QACLL;QACA,GAAGD,MAAM;IACX;AACF;AAGK,SAASH,gBACdY,OAA+C;IAE/C,OAAOX,MAAMW,QAAQC,OAAO,CAACC,OAAO,CAACC,MAAM,CAACC,CAAC;AAC/C"}
+{"version":3,"sources":["../../../src/utils/config.ts"],"names":["getClient","getSchemaConfig","configCache","createContextCache","builder","config","options","drizzle","schema","client","_","dbToSchema","Object","values","reduce","acc","table","dbName","clientCache","clientConfig","ctx","_ctx","context"],"mappings":";;;;;;;;;;;IAoDgBA,SAAS;eAATA;;IANAC,eAAe;eAAfA;;;sBA9CqC;AAWrD,MAAMC,cAAcC,IAAAA,wBAAkB,EACpC,CAACC;QACiBA;IAAhB,MAAMC,SAAUD,CAAAA,kCAAAA,QAAQE,OAAO,CAACC,OAAO,CAACC,MAAM,cAA9BJ,6CAAAA,kCACd,AAACA,QAAQE,OAAO,CAACC,OAAO,CAACE,MAAM,CAC5BC,CAAC;IAEN,MAAMC,aAAaC,OAAOC,MAAM,CAACR,OAAOG,MAAM,EAAEM,MAAM,CACpD,CAACC,KAAKC;QACJD,GAAG,CAACC,MAAMC,MAAM,CAAC,GAAGD;QACpB,OAAOD;IACT,GACA,CAAC;IAGH,OAAO;QACLJ;QACA,GAAGN,MAAM;IACX;AACF;AAGF,MAAMa,cAAcf,IAAAA,wBAAkB,EAAC,CAACC;IACtC,MAAMe,eAAef,QAAQE,OAAO,CAACC,OAAO,CAACE,MAAM;IACnD,MAAMT,YACJ,OAAOmB,iBAAiB,aACpBhB,IAAAA,wBAAkB,EAAC,CAACiB,MAAQD,aAAaC,QACzC,CAACC,OAAiBF;IAExB,OAAOhB,IAAAA,wBAAkB,EAAC,CAACmB;QACzB,MAAMb,SAAST,UAAUsB;QAEzB,OAAOb;IACT;AACF;AAEO,SAASR,gBACdG,OAA+C;IAE/C,OAAOF,YAAYE;AACrB;AAEO,SAASJ,UACdI,OAA+C,EAC/CkB,OAAe;IAEf,OAAOJ,YAAYd,SAAkBkB;AACvC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pothos/plugin-drizzle",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A Pothos plugin for drizzle",
   "main": "./lib/index.js",
   "types": "./dts/index.d.ts",
@@ -46,8 +46,8 @@
     "graphql-scalars": "^1.23.0",
     "graphql-tag": "^2.12.6",
     "postgres": "^3.4.4",
-    "@pothos/plugin-add-graphql": "4.1.0",
     "@pothos/core": "4.1.0",
+    "@pothos/plugin-add-graphql": "4.1.0",
     "@pothos/plugin-relay": "4.1.0",
     "@pothos/plugin-scope-auth": "4.1.0",
     "@pothos/plugin-with-input": "4.1.0",

package/src/drizzle-field-builder.ts

@@ -32,6 +32,7 @@ import type {
   TypesForRelation,
   VariantFieldOptions,
 } from './types';
+import { getSchemaConfig } from './utils/config';
 import {
   drizzleCursorConnectionQuery,
   getCursorFormatter,
@@ -195,10 +196,12 @@ export class DrizzleObjectFieldBuilder<
     connectionOptions = {},
     edgeOptions = {},
   ) {
-    const relationField =
-      this.builder.options.drizzle.client._.schema?.[this.table].relations[name as string];
-    const relatedModel =
-      this.builder.options.drizzle.client._.schema?.[relationField?.referencedTableName!]!;
+    const relationField = getSchemaConfig(this.builder).schema?.[this.table].relations[
+      name as string
+    ];
+    const relatedModel = getSchemaConfig(this.builder).schema?.[
+      relationField?.referencedTableName!
+    ]!;
 
     if (!relationField) {
       throw new PothosSchemaError(
@@ -381,8 +384,9 @@ export class DrizzleObjectFieldBuilder<
     >
   ): FieldRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>, 'Object'> {
     const [options = {} as never] = allArgs;
-    const relationField =
-      this.builder.options.drizzle.client._.schema?.[this.table].relations[name as string];
+    const relationField = getSchemaConfig(this.builder).schema?.[this.table].relations[
+      name as string
+    ];
 
     if (!relationField) {
       throw new PothosSchemaError(

package/src/field-builder.ts

@@ -125,10 +125,9 @@ fieldBuilderProto.drizzleConnection = function drizzleConnection<
         context: {},
         info: GraphQLResolveInfo,
       ) => {
-        const drizzleModel =
-          this.builder.options.drizzle.client._.schema?.[
-            typeof type === 'string' ? type : (ref as DrizzleRef<SchemaTypes>).tableName
-          ]!;
+        const drizzleModel = getSchemaConfig(this.builder).schema?.[
+          typeof type === 'string' ? type : (ref as DrizzleRef<SchemaTypes>).tableName
+        ]!;
 
         return resolveDrizzleCursorConnection(
           drizzleModel,

package/src/model-loader.ts

@@ -1,7 +1,8 @@
 import { type SchemaTypes, createContextCache } from '@pothos/core';
 import { type Column, type TableRelationalConfig, inArray, sql } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import { type PothosDrizzleSchemaConfig, getSchemaConfig } from './utils/config';
+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';
 import {
@@ -35,6 +36,7 @@ export class ModelLoader {
   table: TableRelationalConfig;
   columns: Column[];
   selectSQL;
+  client: DrizzleClient;
 
   constructor(
     context: object,
@@ -52,6 +54,8 @@ export class ModelLoader {
       this.columns.length > 1
         ? sql`(${sql.join(this.columns, sql`, `)})`
         : this.columns[0].getSQL();
+
+    this.client = getClient(builder, context);
   }
 
   static forModel<Types extends SchemaTypes>(
@@ -166,7 +170,7 @@ export class ModelLoader {
     nextTick.promise
       .then(() => {
         const api = (
-          this.builder.options.drizzle.client.query as Record<
+          this.client.query as Record<
             string,
             { findMany: (...args: unknown[]) => Promise<Record<string, unknown>[]> }
           >

package/src/schema-builder.ts

@@ -16,6 +16,7 @@ import { ModelLoader } from './model-loader';
 import { DrizzleNodeRef } from './node-ref';
 import { DrizzleObjectRef } from './object-ref';
 import type { DrizzleGraphQLInputExtensions, DrizzleNodeOptions } from './types';
+import { getSchemaConfig } from './utils/config';
 import { getColumnParser, getColumnSerializer } from './utils/cursors';
 import { getRefFromModel } from './utils/refs';
 
@@ -35,7 +36,7 @@ schemaBuilderProto.drizzleObject = function drizzleObject(table, { select, field
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: this.options.drizzle.client._.schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -63,7 +64,7 @@ schemaBuilderProto.drizzleInterface = function drizzleInterface(
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: this.options.drizzle.client._.schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -88,7 +89,7 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
     ...options
   }: DrizzleNodeOptions<SchemaTypes, keyof SchemaTypes['DrizzleRelationSchema'], {}, {}, []>,
 ) {
-  const tableConfig = this.options.drizzle.client._.schema![table];
+  const tableConfig = getSchemaConfig(this).schema![table];
   const idColumn = typeof column === 'function' ? column(tableConfig.columns) : column;
   const idColumns = Array.isArray(idColumn) ? idColumn : [idColumn];
   const interfaceRef = this.nodeInterfaceRef?.();
@@ -214,7 +215,7 @@ schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
       drizzleGraphQL: {
         inputType: 'orderBy',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -240,7 +241,7 @@ schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
       drizzleGraphQL: {
         inputType: 'filters',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -266,7 +267,7 @@ schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
       drizzleGraphQL: {
         inputType: 'insert',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -292,7 +293,7 @@ schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
       drizzleGraphQL: {
         inputType: 'update',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });

package/src/types.ts

@@ -41,11 +41,24 @@ import type { DrizzleRef } from './interface-ref';
 import type { IndirectInclude } from './utils/map-query';
 import type { SelectionMap } from './utils/selections';
 
-export interface DrizzlePluginOptions<_Types extends SchemaTypes> {
-  client: { _: Partial<RelationalSchemaConfig<TablesRelationalConfig>>; query: {} };
+export type DrizzleClient = {
+  _: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+  query: {};
+};
+
+export type DrizzlePluginOptions<Types extends SchemaTypes> = {
   maxConnectionSize?: number;
   defaultConnectionSize?: number;
-}
+} & (
+  | {
+      client: DrizzleClient;
+      schema?: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+    }
+  | {
+      client: (ctx: Types['Context']) => DrizzleClient;
+      schema: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+    }
+);
 
 export const drizzleTableName = Symbol.for('Pothos.drizzleTableName');
 

package/src/utils/config.ts

@@ -4,12 +4,17 @@ import type {
   TableRelationalConfig,
   TablesRelationalConfig,
 } from 'drizzle-orm';
+import type { DrizzleClient } from '../types';
 
 export interface PothosDrizzleSchemaConfig extends RelationalSchemaConfig<TablesRelationalConfig> {
   dbToSchema: Record<string, TableRelationalConfig>;
 }
-const cache = createContextCache(
-  (config: RelationalSchemaConfig<TablesRelationalConfig>): PothosDrizzleSchemaConfig => {
+const configCache = createContextCache(
+  (builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>): PothosDrizzleSchemaConfig => {
+    const config = (builder.options.drizzle.schema ??
+      (builder.options.drizzle.client as DrizzleClient)
+        ._) as RelationalSchemaConfig<TablesRelationalConfig>;
+
     const dbToSchema = Object.values(config.schema).reduce<Record<string, TableRelationalConfig>>(
       (acc, table) => {
         acc[table.dbName] = table;
@@ -25,8 +30,29 @@ const cache = createContextCache(
   },
 );
 
+const clientCache = createContextCache((builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>) => {
+  const clientConfig = builder.options.drizzle.client;
+  const getClient =
+    typeof clientConfig === 'function'
+      ? createContextCache((ctx) => clientConfig(ctx))
+      : (_ctx: object) => clientConfig;
+
+  return createContextCache((context: object) => {
+    const client = getClient(context);
+
+    return client;
+  });
+});
+
 export function getSchemaConfig<Types extends SchemaTypes>(
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
 ) {
-  return cache(builder.options.drizzle.client._ as RelationalSchemaConfig<TablesRelationalConfig>);
+  return configCache(builder as never);
+}
+
+export function getClient<Types extends SchemaTypes>(
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  context: object,
+) {
+  return clientCache(builder as never)(context);
 }