@pothos/plugin-drizzle 0.0.1

package/src/utils/drizzle-graphql.ts

@@ -0,0 +1,235 @@
+import { asc, Column, desc, getOperators, SQL, Table, TableRelationalConfig } from 'drizzle-orm';
+import { GraphQLError } from 'graphql';
+
+export const remapFromGraphQLCore = (value: any, column: Column, columnName: string) => {
+  switch (column.dataType) {
+    case 'date': {
+      const formatted = new Date(value);
+      if (Number.isNaN(formatted.getTime()))
+        throw new GraphQLError(`Field '${columnName}' is not a valid date!`);
+
+      return formatted;
+    }
+
+    case 'buffer': {
+      if (!Array.isArray(value)) {
+        throw new GraphQLError(`Field '${columnName}' is not an array!`);
+      }
+
+      return Buffer.from(value);
+    }
+
+    case 'json': {
+      if (column.columnType === 'PgGeometryObject') return value;
+
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        throw new GraphQLError(
+          `Invalid JSON in field '${columnName}':\n${e instanceof Error ? e.message : 'Unknown error'}`,
+        );
+      }
+    }
+
+    case 'array': {
+      if (!Array.isArray(value)) {
+        throw new GraphQLError(`Field '${columnName}' is not an array!`);
+      }
+
+      if (column.columnType === 'PgGeometry' && value.length !== 2) {
+        throw new GraphQLError(
+          `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`,
+        );
+      }
+
+      return value;
+    }
+
+    case 'bigint': {
+      try {
+        return BigInt(value);
+      } catch (error) {
+        throw new GraphQLError(`Field '${columnName}' is not a BigInt!`);
+      }
+    }
+
+    default: {
+      return value;
+    }
+  }
+};
+
+export const remapFromGraphQLSingleInput = (
+  queryInput: Record<string, any>,
+  table: TableRelationalConfig,
+) => {
+  for (const [key, value] of Object.entries(queryInput)) {
+    if (value === undefined) {
+      delete queryInput[key];
+    } else {
+      const column = table.columns[key];
+      if (!column) throw new GraphQLError(`Unknown column: ${key}`);
+
+      if (value === null && column.notNull) {
+        delete queryInput[key];
+        continue;
+      }
+
+      queryInput[key] = remapFromGraphQLCore(value, column, key);
+    }
+  }
+
+  return queryInput;
+};
+
+export const remapFromGraphQLArrayInput = (
+  queryInput: Record<string, any>[],
+  table: TableRelationalConfig,
+) => {
+  for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table);
+
+  return queryInput;
+};
+
+export type OrderByArgs<TTable extends TableRelationalConfig> = {
+  [Key in keyof TTable['columns']]?: {
+    direction: 'asc' | 'desc';
+    priority: number;
+  };
+};
+
+export const extractOrderBy = <
+  TTable extends TableRelationalConfig,
+  TArgs extends OrderByArgs<any> = OrderByArgs<TTable>,
+>(
+  table: TTable,
+  orderArgs: TArgs,
+): SQL[] => {
+  const res = [] as SQL[];
+
+  for (const [column, config] of Object.entries(orderArgs).sort(
+    (a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0),
+  )) {
+    if (!config) continue;
+    const { direction } = config;
+
+    res.push(direction === 'asc' ? asc(table.columns[column]!) : desc(table.columns[column]!));
+  }
+
+  return res;
+};
+
+const ops = getOperators();
+
+export const extractFiltersColumn = <TColumn extends Column>(
+  column: TColumn,
+  columnName: string,
+  operators: Record<string, unknown> & { OR?: Record<string, unknown>[] },
+): SQL | undefined => {
+  if (!operators.OR?.length) delete operators.OR;
+
+  const entries = Object.entries(operators);
+
+  if (operators.OR) {
+    if (entries.length > 1) {
+      throw new GraphQLError(
+        `WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`,
+      );
+    }
+
+    const variants = [] as SQL[];
+
+    for (const variant of operators.OR) {
+      const extracted = extractFiltersColumn(column, columnName, variant);
+
+      if (extracted) variants.push(extracted);
+    }
+
+    return variants.length ? (variants.length > 1 ? ops.or(...variants) : variants[0]) : undefined;
+  }
+
+  const variants = [] as SQL[];
+  for (const [operatorName, operatorValue] of entries) {
+    if (operatorValue === null || operatorValue === false) continue;
+
+    switch (operatorName) {
+      case 'eq':
+      case 'ne':
+      case 'gt':
+      case 'gte':
+      case 'lt':
+      case 'lte':
+        const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
+        variants.push(ops[operatorName](column, singleValue));
+
+        break;
+      case 'like':
+      case 'notLike':
+      case 'ilike':
+      case 'notIlike':
+        variants.push(ops[operatorName](column, operatorValue as string));
+        break;
+      case 'inArray':
+      case 'notInArray':
+        if (!(operatorValue as any[]).length) {
+          throw new GraphQLError(
+            `WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`,
+          );
+        }
+        const arrayValue = (operatorValue as any[]).map((val) =>
+          remapFromGraphQLCore(val, column, columnName),
+        );
+
+        variants.push(ops[operatorName](column, arrayValue));
+        break;
+      case 'isNull':
+      case 'isNotNull':
+        variants.push(ops[operatorName](column));
+        break;
+      default:
+        throw new GraphQLError(`Unknown operator: ${operatorName}`);
+    }
+  }
+
+  return variants.length ? (variants.length > 1 ? ops.and(...variants) : variants[0]) : undefined;
+};
+
+export const extractFilters = <TTable extends TableRelationalConfig>(
+  table: TTable,
+  tableName: string,
+  filters: Record<string, unknown> & {
+    OR?: Record<string, unknown>[];
+  },
+): SQL | undefined => {
+  if (!filters.OR?.length) delete filters.OR;
+
+  const entries = Object.entries(filters);
+  if (!entries.length) return;
+
+  if (filters.OR) {
+    if (entries.length > 1) {
+      throw new GraphQLError(
+        `WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`,
+      );
+    }
+
+    const variants = [] as SQL[];
+
+    for (const variant of filters.OR) {
+      const extracted = extractFilters(table, tableName, variant);
+      if (extracted) variants.push(extracted);
+    }
+
+    return variants.length ? (variants.length > 1 ? ops.or(...variants) : variants[0]) : undefined;
+  }
+
+  const variants = [] as SQL[];
+  for (const [columnName, operators] of entries) {
+    if (operators === null) continue;
+
+    const column = table.columns[columnName]!;
+    variants.push(extractFiltersColumn(column, columnName, operators as Record<string, unknown>)!);
+  }
+
+  return variants.length ? (variants.length > 1 ? ops.and(...variants) : variants[0]) : undefined;
+};

package/src/utils/loader-map.ts

@@ -0,0 +1,51 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { createContextCache } from '@pothos/core';
+
+export type LoaderMappings = Record<
+  string,
+  {
+    field: string;
+    type: string;
+    mappings: LoaderMappings;
+    indirectPath: string[];
+  }
+>;
+
+const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
+
+export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[] = []) {
+  let key = '';
+  let current: GraphQLResolveInfo['path'] | undefined = path;
+
+  while (current) {
+    if (typeof current.key === 'string') {
+      key = key ? `${current.key}.${key}` : current.key;
+    }
+    current = current.prev;
+  }
+
+  for (const entry of subPath) {
+    key = `${key}.${entry}`;
+  }
+
+  return `${type}@${key}`;
+}
+
+export function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings) {
+  Object.keys(value).forEach((field) => {
+    const map = cache(ctx);
+
+    const mapping = value[field];
+    const subPath = [...mapping.indirectPath, field];
+    const key = cacheKey(mapping.type, info.path, subPath);
+
+    map.set(key, mapping.mappings);
+  });
+}
+
+export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string) {
+  const map = cache(ctx);
+  const key = cacheKey(type, path, []);
+
+  return map.get(key) ?? null;
+}