@pothos/plugin-drizzle 0.4.0 → 0.4.2

package/src/utils/config.ts

@@ -1,15 +1,18 @@
 import { type SchemaTypes, createContextCache } from '@pothos/core';
 import {
+  type Column,
   type RelationalSchemaConfig,
   type TableRelationalConfig,
   type TablesRelationalConfig,
   createTableRelationsHelpers,
   extractTablesRelationalConfig,
+  getTableName,
 } from 'drizzle-orm';
 import type { DrizzleClient } from '../types';
 
 export interface PothosDrizzleSchemaConfig extends RelationalSchemaConfig<TablesRelationalConfig> {
   dbToSchema: Record<string, TableRelationalConfig>;
+  columnToTsName: (column: Column) => string;
 }
 const configCache = createContextCache(
   (builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>): PothosDrizzleSchemaConfig => {
@@ -37,8 +40,33 @@ const configCache = createContextCache(
       {},
     );
 
+    const columnMappings = Object.values(dbToSchema).reduce<Record<string, Record<string, string>>>(
+      (acc, table) => {
+        acc[table.dbName] = Object.entries(table.columns).reduce<Record<string, string>>(
+          (acc, [name, column]) => {
+            acc[column.name] = name;
+            return acc;
+          },
+          {},
+        );
+        return acc;
+      },
+      {},
+    );
+
     return {
       dbToSchema,
+      columnToTsName: (column) => {
+        const tableName = getTableName(column.table);
+        const table = columnMappings[tableName];
+        const columnName = table?.[column.name];
+
+        if (!columnName) {
+          throw new Error(`Could not find column mapping for ${tableName}.${column.name}`);
+        }
+
+        return columnName;
+      },
       ...config,
     };
   },

package/src/utils/cursors.ts

@@ -39,8 +39,12 @@ export function formatCursorChunk(value: unknown) {
   }
 }
 
-export function formatDrizzleCursor(record: Record<string, unknown>, fields: Column[]) {
-  return getCursorFormatter(fields)(record);
+export function formatDrizzleCursor(
+  record: Record<string, unknown>,
+  fields: Column[],
+  config: PothosDrizzleSchemaConfig,
+) {
+  return getCursorFormatter(fields, config)(record);
 }
 
 export function formatIDChunk(value: unknown) {
@@ -58,40 +62,40 @@ export function formatIDChunk(value: unknown) {
   }
 }
 
-export function getIDSerializer(fields: Column[]) {
+export function getIDSerializer(fields: Column[], config: PothosDrizzleSchemaConfig) {
   if (fields.length === 0) {
     throw new PothosValidationError('Column serializer must have at least one field');
   }
 
   return (value: Record<string, unknown>) => {
     if (fields.length > 1) {
-      return `${JSON.stringify(fields.map((col) => value[col.name]))}`;
+      return `${JSON.stringify(fields.map((col) => value[config.columnToTsName(col)]))}`;
     }
 
-    return `${formatIDChunk(value[fields[0].name])}`;
+    return `${formatIDChunk(value[config.columnToTsName(fields[0])])}`;
   };
 }
 
-export function getColumnSerializer(fields: Column[]) {
+export function getColumnSerializer(fields: Column[], config: PothosDrizzleSchemaConfig) {
   if (fields.length === 0) {
     throw new PothosValidationError('Column serializer must have at least one field');
   }
 
   return (value: Record<string, unknown>) => {
     if (fields.length > 1) {
-      return `J:${JSON.stringify(fields.map((col) => value[col.name]))}`;
+      return `J:${JSON.stringify(fields.map((col) => value[config.columnToTsName(col)]))}`;
     }
 
-    return `${formatCursorChunk(value[fields[0].name])}`;
+    return `${formatCursorChunk(value[config.columnToTsName(fields[0])])}`;
   };
 }
 
-export function getCursorFormatter(fields: Column[]) {
+export function getCursorFormatter(fields: Column[], config: PothosDrizzleSchemaConfig) {
   if (fields.length === 0) {
     throw new PothosValidationError('Cursor must have at least one field');
   }
 
-  const serializer = getColumnSerializer(fields);
+  const serializer = getColumnSerializer(fields, config);
 
   return (value: Record<string, unknown>) => {
     return encodeBase64(`DC:${serializer(value)}`);
@@ -489,7 +493,7 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
           : q.orderBy
         : table.primaryKey,
     });
-    formatter = getCursorFormatter(cursorColumns);
+    formatter = getCursorFormatter(cursorColumns, config);
 
     const where = typeof q.where === 'function' ? q.where(table.columns, getOperators()) : q.where;