@pothos/plugin-drizzle 0.18.0 → 0.19.0

package/src/utils/path-info.ts

@@ -0,0 +1,40 @@
+import type { Position } from '@pothos/selection-mapper';
+import { type GraphQLOutputType, isListType, isNonNullType } from 'graphql';
+import type { FieldPathInfo, PathInfo } from '../types.js';
+
+/**
+ * The public `PathInfo` of a position: `path` as `Type.field` from the field the query was
+ * planned for down to the field being planned, and one segment per step with the alias the
+ * document used and whether the field is a list.
+ *
+ * The walker hands out positions, which are links rather than paths; this is the only place the
+ * chain is walked, and it is walked only when a `query` callback or a `select` function actually
+ * wants one. A field whose query is a plain object never builds either array.
+ */
+export function pathInfoFor(position: Position | undefined): PathInfo | undefined {
+  if (!position) {
+    return undefined;
+  }
+
+  const path: string[] = [];
+  const segments: FieldPathInfo[] = [];
+
+  for (let at: Position | undefined = position; at; at = at.parent) {
+    const field = at.node.name.value;
+
+    path.push(`${at.type.name}.${field}`);
+    segments.push({
+      field,
+      alias: at.node.alias?.value ?? field,
+      parentType: at.type.name,
+      isList: isListField(at.field.type),
+    });
+  }
+
+  return { path: path.reverse(), segments: segments.reverse() };
+}
+
+/** A list field, whether or not the list itself is non-null (`[Post!]!`). */
+function isListField(type: GraphQLOutputType) {
+  return isListType(type) || (isNonNullType(type) && isListType(type.ofType));
+}

package/src/utils/relation-filter.ts

@@ -0,0 +1,185 @@
+import {
+  aliasedTable,
+  aliasedTableColumn,
+  and,
+  type Column,
+  count,
+  countDistinct,
+  exists,
+  getTableName,
+  inArray,
+  is,
+  type Relation,
+  relationToSQL,
+  type SQL,
+  type SQLWrapper,
+  sql,
+  type Table,
+} from 'drizzle-orm';
+import { SQLiteTable } from 'drizzle-orm/sqlite-core';
+
+import type { DrizzleClient } from '../types.js';
+
+/** The public client's SQL construction capability. */
+export type RelationQueryBuilder = Pick<DrizzleClient, 'select'>;
+
+export interface RelationFilter {
+  /**
+   * A predicate over the target table alone, for the places where only the target table is in
+   * scope: a `where` handed to a user `select`, or a count that selects from the target table.
+   * SQLite many-to-many relations with a non-null unique target key project identities through
+   * Drizzle's join. Other cases use an `exists` over the junction.
+   */
+  filter: SQL;
+  /**
+   * Counts the rows the relation yields, as an expression for the surrounding query to select.
+   * A many-to-many relation joins the junction table in, so the count matches the rows the
+   * relational query builder returns for the same relation, junction duplicates included.
+   *
+   * `where` is the predicate the page query was given, and it goes ahead of the relation's own
+   * predicate because that is the order the relational query builder combines the two in. The
+   * count then repeats the page query's `where` verbatim, minus the limit and keyset clauses.
+   */
+  countRows: (where?: SQL) => SQL<number>;
+  /**
+   * Counts the distinct target rows the relation reaches, for the callers that count a related
+   * row once however many junction rows lead to it. `key` identifies a target row, so it has to
+   * be a single column the database guarantees is unique and non-null.
+   *
+   * This counts off the junction rather than counting the target table filtered by `filter`,
+   * which says the same thing the long way round: the join reads the junction rows the parent
+   * reaches and stops, where the filter reads the same rows and then looks every key it found
+   * back up in the target table.
+   */
+  countDistinctRows: (key: Column, where?: SQL) => SQL<number>;
+}
+
+// `select 1`, for an `exists` that only has to find a row.
+const one = { one: sql`1` };
+
+/**
+ * The parent-to-child SQL for one relation, built by drizzle so the plugin agrees with the
+ * relational query builder on what "related" means: `through` (many-to-many), the relation's own
+ * `where`, and a reversed relation's inherited `where` all come from drizzle rather than from a
+ * join reassembled here out of source and target columns.
+ *
+ * Both the join and its restrictions come from `relationToSQL`, including when the target is
+ * aliased for the identity lookup. No junction columns or comparisons are reconstructed here.
+ *
+ * `parentTable` is the parent as it appears in the surrounding query, so the aliased table when
+ * the query builder aliased it.
+ */
+export function buildRelationFilter(
+  client: RelationQueryBuilder,
+  relation: Relation,
+  parentTable: Table,
+  targetKey?: Column[],
+): RelationFilter {
+  const targetTable = relation.targetTable as Table;
+  const throughTable = relation.throughTable as Table | undefined;
+  // `filter` correlates the parent to the target, or to the junction table when there is one, in
+  // which case `joinCondition` is what carries the junction the rest of the way to the target.
+  const { filter, joinCondition } = relationToSQL(
+    relation,
+    parentTable,
+    targetTable,
+    throughTable,
+  ) as { filter: SQL; joinCondition?: SQL };
+
+  if (!throughTable || !joinCondition) {
+    // Without a junction table every related row is a distinct target row, so the two counts are
+    // the same query.
+    const countRows = (where?: SQL) =>
+      countOf(client.select(countStar()).from(targetTable).where(and(where, filter)));
+
+    return { filter, countRows, countDistinctRows: (_key, where) => countRows(where) };
+  }
+
+  const relatedRows = (aggregate: Record<string, SQL>, where?: SQL) =>
+    countOf(
+      client
+        .select(aggregate)
+        .from(targetTable)
+        .innerJoin(throughTable, joinCondition)
+        .where(and(where, filter)),
+    );
+
+  return {
+    // SQLite needs the identity lookup to avoid target scans. PostgreSQL can plan EXISTS as
+    // a semijoin; projecting identities adds a target join its planner may not eliminate.
+    filter:
+      targetKey?.length && is(targetTable, SQLiteTable)
+        ? targetIdentityInRelation(
+            client,
+            relation,
+            parentTable,
+            targetTable,
+            throughTable,
+            targetKey,
+          )
+        : exists(client.select(one).from(throughTable).where(and(filter, joinCondition))),
+    countRows: (where) => relatedRows(countStar(), where),
+    countDistinctRows: (key, where) => relatedRows({ count: countDistinct(key) }, where),
+  };
+}
+
+/**
+ * Project a non-null unique target key through the original relation join, then compare that
+ * key with itself. Comparing the target key directly with a junction column would change
+ * SQLite's collation precedence. Keeping the join also handles composite relation keys and
+ * excludes null junction keys without special truth-table guards.
+ *
+ * `key` must be a database-enforced unique constraint whose columns are all NOT NULL. That
+ * makes membership identify exactly one target row and keeps negation two-valued. SQLite can
+ * allow nulls even in primary keys, so callers must check notNull, not just primary.
+ *
+ * Build object restrictions and RAW callbacks against the inner target alias. Static RAW SQL
+ * is passed through by Drizzle: references to the outer target can still force a target scan.
+ * A RAW callback must use its supplied table to benefit from the identity lookup.
+ */
+function targetIdentityInRelation(
+  client: RelationQueryBuilder,
+  relation: Relation,
+  parentTable: Table,
+  targetTable: Table,
+  throughTable: Table,
+  key: Column[],
+): SQL {
+  const names = new Set([parentTable, targetTable, throughTable].map(getTableName));
+  let alias = '_pothos_related';
+
+  while (names.has(alias)) {
+    alias += '_';
+  }
+
+  const matchedTable = aliasedTable(targetTable, alias);
+  const { filter, joinCondition } = relationToSQL(
+    relation,
+    parentTable,
+    matchedTable,
+    throughTable,
+  ) as { filter: SQL; joinCondition: SQL };
+  const fields = Object.fromEntries(
+    key.map((column, i) => [String(i), sql`${aliasedTableColumn(column, alias)}`]),
+  );
+  const columns = key.map((column) => sql`${column}`);
+  const identity = columns.length === 1 ? columns[0] : sql`(${sql.join(columns, sql`, `)})`;
+
+  return inArray(
+    identity,
+    client.select(fields).from(throughTable).innerJoin(matchedTable, joinCondition).where(filter),
+  );
+}
+
+// A fresh `count(*)` each time: `mapWith` mutates the `SQL` it is called on, so a shared one
+// would be re-decoded by every query that selected it.
+function countStar(): Record<string, SQL> {
+  return { count: count() };
+}
+
+// The count as a value the surrounding query can select. `count()` carries drizzle's `Number`
+// decoder, but a `select` built around it decodes as the row it returns, so the mapping is
+// restored here and the count comes back as a number on every dialect.
+function countOf(rows: SQLWrapper): SQL<number> {
+  return sql`${rows.getSQL()}`.mapWith(Number);
+}

package/src/utils/selections.ts

@@ -1,216 +1,11 @@
-import { PothosValidationError } from '@pothos/core';
-import type { DBQueryConfig, TableRelationalConfig } from 'drizzle-orm';
-import type { PothosDrizzleSchemaConfig } from './config.js';
-import { deepEqual } from './deep-equal.js';
-import type { LoaderMappings } from './loader-map.js';
-
-export interface SelectionState {
-  table: TableRelationalConfig;
-  query: object;
-  allColumns: boolean;
-  columns: Set<string>;
-  with: Map<string, SelectionState>;
-  extras: Map<string, NonNullable<SelectionMap['extras']>[string]>;
-  mappings: LoaderMappings;
-  parent?: SelectionState;
-  depth: number;
-  skipDeferredFragments: boolean;
-}
+import type { DBQueryConfig } from 'drizzle-orm';
 
 export type SelectionMap = DBQueryConfig<'one'>;
 
+/** Drops keys holding `undefined`, so `{ where: cond ? filter : undefined }` reads as `{}`. */
 export function omitUndefinedKeys<T extends object>(query: T): T {
   const entries = Object.entries(query);
   const defined = entries.filter(([, value]) => value !== undefined);
 
   return defined.length === entries.length ? query : (Object.fromEntries(defined) as T);
 }
-
-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 { with: withSelection, extras, columns: _, ...query } = selectionMap;
-
-  if (
-    withSelection &&
-    Object.entries(withSelection).some(
-      ([key, value]) =>
-        value &&
-        state.with.has(key) &&
-        // TODO: make sure nested extras are normalized
-        !selectionCompatible(state.with.get(key)!, value as SelectionMap),
-    )
-  ) {
-    return false;
-  }
-
-  if (
-    extras &&
-    Object.entries(extras).some(([key, value]) => {
-      const existing = state.extras.get(key);
-      return existing && existing !== value;
-    })
-  ) {
-    return false;
-  }
-
-  return ignoreQuery || deepEqual(state.query, omitUndefinedKeys(query));
-}
-
-export function stateCompatible(
-  state: SelectionState,
-  newState: SelectionState,
-  ignoreQuery = false,
-): boolean {
-  for (const [name, relationState] of newState.with) {
-    if (state.with.has(name) && !stateCompatible(state.with.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.with) {
-    if (state.with.has(name)) {
-      mergeState(state.with.get(name)!, relationState);
-    }
-  }
-
-  if (!state.allColumns) {
-    if (newState.allColumns) {
-      state.allColumns = true;
-    } else {
-      for (const name of newState.columns) {
-        state.columns.add(name);
-      }
-    }
-  }
-
-  for (const [name, value] of newState.extras) {
-    state.extras.set(name, value);
-  }
-}
-
-export function createState(
-  table: TableRelationalConfig,
-  skipDeferredFragments: boolean,
-  parent?: SelectionState,
-): SelectionState {
-  return {
-    table,
-    skipDeferredFragments,
-    parent,
-    query: {},
-    columns: new Set(),
-    with: new Map(),
-    extras: new Map(),
-    mappings: {},
-    allColumns: false,
-    depth: parent ? parent.depth + 1 : 0,
-  };
-}
-
-export function mergeSelection(
-  config: PothosDrizzleSchemaConfig,
-  state: SelectionState,
-  selection: SelectionMap | boolean,
-) {
-  const {
-    with: withSelection,
-    extras,
-    columns,
-    ...query
-  } = typeof selection === 'boolean' ? (selection === true ? {} : { columns: {} }) : selection;
-  if (withSelection) {
-    for (const [key, value] of Object.entries(withSelection)) {
-      const relation = state.table.relations[key];
-
-      if (!relation) {
-        throw new PothosValidationError(`Relation ${key} does not exist on ${state.table.name}`);
-      }
-
-      merge(config.relations[relation.targetTableName], key, value as SelectionMap | boolean);
-    }
-  }
-
-  const normalizedQuery = omitUndefinedKeys(query);
-  if (Object.keys(normalizedQuery).length > 0) {
-    state.query = normalizedQuery;
-  }
-
-  if (extras) {
-    for (const [key, value] of Object.entries(extras)) {
-      state.extras.set(key, value);
-    }
-  }
-
-  if (state.allColumns) {
-    return;
-  }
-
-  if (columns && !state.allColumns) {
-    for (const [key, value] of Object.entries(columns)) {
-      if (value) {
-        state.columns.add(key);
-      }
-    }
-  } else {
-    state.allColumns = true;
-  }
-
-  function merge(table: TableRelationalConfig, key: string, value?: SelectionMap | boolean) {
-    if (!value) {
-      return;
-    }
-
-    if (state.with.has(key)) {
-      mergeSelection(config, state.with.get(key)!, value);
-    } else {
-      const relatedState = createState(table, state.skipDeferredFragments, state);
-      mergeSelection(config, relatedState, value);
-      state.with.set(key, relatedState);
-    }
-  }
-}
-
-export function selectionToQuery(
-  config: PothosDrizzleSchemaConfig,
-  state: SelectionState,
-): SelectionMap {
-  const query: SelectionMap & { extras: Record<string, unknown> } = {
-    ...omitUndefinedKeys(state.query),
-    columns: undefined,
-    with: {},
-    extras: {},
-  };
-
-  if (!state.allColumns) {
-    query.columns = {};
-    for (const key of state.columns) {
-      query.columns![key] = true;
-    }
-
-    for (const column of config.getPrimaryKey(state.table.name)) {
-      const tsName = config.columnToTsName(column);
-      query.columns![tsName] = true;
-    }
-  }
-
-  for (const [key, value] of state.extras) {
-    query.extras![key] = value;
-  }
-
-  state.with.forEach((sel, relation) => {
-    query.with![relation] = selectionToQuery(config, sel);
-  });
-
-  return query;
-}

package/dts/utils/deep-equal.d.ts

@@ -1,2 +0,0 @@
-export declare function deepEqual(left: unknown, right: unknown, ignore?: Set<string>): boolean;
-//# sourceMappingURL=deep-equal.d.ts.map

package/dts/utils/deep-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../src/utils/deep-equal.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,WAwD5E"}

package/dts/utils/drizzle-graphql.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=drizzle-graphql.d.ts.map

package/dts/utils/drizzle-graphql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drizzle-graphql.d.ts","sourceRoot":"","sources":["../../src/utils/drizzle-graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dts/utils/loader-map.d.ts

@@ -1,11 +0,0 @@
-import type { GraphQLResolveInfo } from 'graphql';
-export type LoaderMappings = Record<string, {
-    field: string;
-    type: string;
-    mappings: LoaderMappings;
-    indirectPath: string[];
-}>;
-export declare function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath?: string[]): string;
-export declare function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings): void;
-export declare function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string): LoaderMappings | null;
-//# sourceMappingURL=loader-map.d.ts.map

package/dts/utils/loader-map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader-map.d.ts","sourceRoot":"","sources":["../../src/utils/loader-map.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,MAAM,cAAc,GAAG,MAAM,CACjC,MAAM,EACN;IACE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,CAAC;IACzB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CACF,CAAC;AAIF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,EAAE,OAAO,GAAE,MAAM,EAAO,UAgB9F;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,cAAc,QAQ7F;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,yBAK3F"}

package/dts/utils/usage.d.ts

@@ -1,5 +0,0 @@
-export declare const usageSymbol: unique symbol;
-export declare function wrapWithUsageCheck<T extends object>(obj: T): T;
-export declare function isUsed(obj: object): boolean;
-export declare function extendWithUsage<T extends object, U extends object>(original: T, extension: U): T & U;
-//# sourceMappingURL=usage.d.ts.map

package/dts/utils/usage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../src/utils/usage.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,eAA8B,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CA4B9D;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3C;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAChE,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,CAAC,GACX,CAAC,GAAG,CAAC,CAsBP"}

package/esm/utils/deep-equal.d.ts

@@ -1,2 +0,0 @@
-export declare function deepEqual(left: unknown, right: unknown, ignore?: Set<string>): boolean;
-//# sourceMappingURL=deep-equal.d.ts.map

package/esm/utils/deep-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../src/utils/deep-equal.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,WAwD5E"}

package/esm/utils/deep-equal.js

@@ -1,45 +0,0 @@
-export function deepEqual(left, right, ignore) {
-    if (left === right) {
-        return true;
-    }
-    if (left && right && typeof left === 'object' && typeof right === 'object') {
-        var _left_valueOf, _right_valueOf;
-        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 lValue = (_left_valueOf = left.valueOf) === null || _left_valueOf === void 0 ? void 0 : _left_valueOf.call(left);
-        const rValue = (_right_valueOf = right.valueOf) === null || _right_valueOf === void 0 ? void 0 : _right_valueOf.call(right);
-        if ((lValue != null || rValue != null) && typeof lValue !== 'object') {
-            return lValue === rValue;
-        }
-        const keys = Object.keys(left);
-        const keyLength = keys.length;
-        if (keyLength !== Object.keys(right).length) {
-            return false;
-        }
-        for (const key of keys){
-            if (ignore === null || ignore === void 0 ? void 0 : ignore.has(key)) {
-                continue;
-            }
-            if (!deepEqual(left[key], right[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}
-
-//# sourceMappingURL=deep-equal.js.map

package/esm/utils/deep-equal.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/deep-equal.ts"],"names":["deepEqual","left","right","ignore","Array","isArray","length","i","lValue","valueOf","rValue","keys","Object","keyLength","key","has"],"mappings":"AAAA,OAAO,SAASA,UAAUC,IAAa,EAAEC,KAAc,EAAEC,MAAoB;IAC3E,IAAIF,SAASC,OAAO;QAClB,OAAO;IACT;IAEA,IAAID,QAAQC,SAAS,OAAOD,SAAS,YAAY,OAAOC,UAAU,UAAU;YAqB3DD,eACAC;QArBf,IAAIE,MAAMC,OAAO,CAACJ,OAAO;YACvB,IAAI,CAACG,MAAMC,OAAO,CAACH,QAAQ;gBACzB,OAAO;YACT;YAEA,MAAM,EAAEI,MAAM,EAAE,GAAGL;YAEnB,IAAIC,MAAMI,MAAM,KAAKA,QAAQ;gBAC3B,OAAO;YACT;YAEA,IAAK,IAAIC,IAAI,GAAGA,IAAID,QAAQC,KAAK,EAAG;gBAClC,IAAI,CAACP,UAAUC,IAAI,CAACM,EAAE,EAAEL,KAAK,CAACK,EAAE,GAAG;oBACjC,OAAO;gBACT;YACF;YAEA,OAAO;QACT;QAEA,MAAMC,UAASP,gBAAAA,KAAKQ,OAAO,cAAZR,oCAAAA,mBAAAA;QACf,MAAMS,UAASR,iBAAAA,MAAMO,OAAO,cAAbP,qCAAAA,oBAAAA;QAEf,IAAI,AAACM,CAAAA,UAAU,QAAQE,UAAU,IAAG,KAAM,OAAOF,WAAW,UAAU;YACpE,OAAOA,WAAWE;QACpB;QAEA,MAAMC,OAAOC,OAAOD,IAAI,CAACV;QACzB,MAAMY,YAAYF,KAAKL,MAAM;QAE7B,IAAIO,cAAcD,OAAOD,IAAI,CAACT,OAAOI,MAAM,EAAE;YAC3C,OAAO;QACT;QAEA,KAAK,MAAMQ,OAAOH,KAAM;YACtB,IAAIR,mBAAAA,6BAAAA,OAAQY,GAAG,CAACD,MAAM;gBACpB;YACF;YAEA,IACE,CAACd,UAAU,AAACC,IAAgC,CAACa,IAAI,EAAE,AAACZ,KAAiC,CAACY,IAAI,GAC1F;gBACA,OAAO;YACT;QACF;QAEA,OAAO;IACT;IAEA,OAAO;AACT"}

package/esm/utils/drizzle-graphql.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=drizzle-graphql.d.ts.map

package/esm/utils/drizzle-graphql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drizzle-graphql.d.ts","sourceRoot":"","sources":["../../src/utils/drizzle-graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}