@drizzle-graphql-suite/schema 0.5.0

package/index.js

@@ -0,0 +1,1812 @@
+// src/index.ts
+import { createTableRelationsHelpers as createTableRelationsHelpers2, extractTablesRelationalConfig } from "drizzle-orm";
+
+// src/schema-builder.ts
+import {
+  and,
+  asc,
+  count,
+  createTableRelationsHelpers,
+  desc,
+  eq,
+  exists,
+  getTableColumns as getTableColumns2,
+  getTableName,
+  gt,
+  gte,
+  ilike,
+  inArray,
+  is as is3,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  normalizeRelation,
+  not,
+  notIlike,
+  notInArray,
+  notLike,
+  One,
+  or,
+  Relations,
+  sql
+} from "drizzle-orm";
+import { PgTable as PgTable2 } from "drizzle-orm/pg-core";
+import {
+  GraphQLBoolean as GraphQLBoolean2,
+  GraphQLEnumType as GraphQLEnumType2,
+  GraphQLError as GraphQLError2,
+  GraphQLInputObjectType as GraphQLInputObjectType2,
+  GraphQLInt as GraphQLInt2,
+  GraphQLList as GraphQLList2,
+  GraphQLNonNull as GraphQLNonNull2,
+  GraphQLObjectType as GraphQLObjectType2,
+  GraphQLSchema,
+  GraphQLString as GraphQLString2,
+  printSchema
+} from "graphql";
+import { parseResolveInfo } from "graphql-parse-resolve-info";
+
+// src/adapters/pg.ts
+import { is } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+
+class PgAdapter {
+  supportsReturning = true;
+  isTable(value) {
+    return is(value, PgTable);
+  }
+  async executeInsert(db, table, values, returningColumns) {
+    let query = db.insert(table).values(values);
+    if (returningColumns) {
+      query = query.returning(returningColumns);
+    }
+    query = query.onConflictDoNothing();
+    return await query;
+  }
+  async executeUpdate(db, table, set, where, returningColumns) {
+    let query = db.update(table).set(set);
+    if (where) {
+      query = query.where(where);
+    }
+    if (returningColumns) {
+      query = query.returning(returningColumns);
+    }
+    return await query;
+  }
+  async executeDelete(db, table, where, returningColumns) {
+    let query = db.delete(table);
+    if (where) {
+      query = query.where(where);
+    }
+    if (returningColumns) {
+      query = query.returning(returningColumns);
+    }
+    return await query;
+  }
+}
+
+// src/case-ops.ts
+var uncapitalize = (input) => input.length ? `${input[0]?.toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+var capitalize = (input) => input.length ? `${input[0]?.toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+
+// src/data-mappers.ts
+import { getTableColumns } from "drizzle-orm";
+import { GraphQLError } from "graphql";
+var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (value instanceof Buffer)
+    return Array.from(value);
+  if (typeof value === "bigint")
+    return value.toString();
+  if (Array.isArray(value)) {
+    const rel = relationMap?.[tableName]?.[key];
+    if (rel) {
+      return remapToGraphQLArrayOutput(value, rel.targetTableName, rel.relation.referencedTable, relationMap);
+    }
+    if (column.columnType === "PgGeometry" || column.columnType === "PgVector")
+      return value;
+    return value.map((arrVal) => remapToGraphQLCore(key, arrVal, tableName, column, relationMap));
+  }
+  if (typeof value === "object") {
+    const rel = relationMap?.[tableName]?.[key];
+    if (rel) {
+      return remapToGraphQLSingleOutput(value, rel.targetTableName, rel.relation.referencedTable, relationMap);
+    }
+    if (column.columnType === "PgGeometryObject")
+      return value;
+    if (column.dataType === "json")
+      return value;
+    return JSON.stringify(value);
+  }
+  return value;
+};
+var remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
+  for (const [key, value] of Object.entries(queryOutput)) {
+    if (value === undefined || value === null) {
+      delete queryOutput[key];
+    } else {
+      queryOutput[key] = remapToGraphQLCore(key, value, tableName, table[key], relationMap);
+    }
+  }
+  return queryOutput;
+};
+var remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) => {
+  for (const entry of queryOutput) {
+    remapToGraphQLSingleOutput(entry, tableName, table, relationMap);
+  }
+  return queryOutput;
+};
+var remapFromGraphQLCore = (value, column, columnName) => {
+  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;
+      return value;
+    }
+    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 {
+        throw new GraphQLError(`Field '${columnName}' is not a BigInt!`);
+      }
+    }
+    default: {
+      return value;
+    }
+  }
+};
+var remapFromGraphQLSingleInput = (queryInput, table) => {
+  for (const [key, value] of Object.entries(queryInput)) {
+    if (value === undefined) {
+      delete queryInput[key];
+    } else {
+      const column = getTableColumns(table)[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;
+};
+var remapFromGraphQLArrayInput = (queryInput, table) => {
+  for (const entry of queryInput)
+    remapFromGraphQLSingleInput(entry, table);
+  return queryInput;
+};
+
+// src/graphql/type-builder.ts
+import { is as is2 } from "drizzle-orm";
+import {
+  PgBigInt53,
+  PgBigSerial53,
+  PgInteger,
+  PgSerial,
+  PgSmallInt,
+  PgSmallSerial
+} from "drizzle-orm/pg-core";
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+// src/graphql/scalars.ts
+import { GraphQLScalarType, Kind } from "graphql";
+var GraphQLJSON = new GraphQLScalarType({
+  name: "JSON",
+  description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
+  serialize(value) {
+    return value;
+  },
+  parseValue(value) {
+    return value;
+  },
+  parseLiteral(ast) {
+    switch (ast.kind) {
+      case Kind.STRING:
+      case Kind.BOOLEAN:
+        return ast.value;
+      case Kind.INT:
+      case Kind.FLOAT:
+        return parseFloat(ast.value);
+      case Kind.OBJECT: {
+        const value = Object.create(null);
+        ast.fields.forEach((field) => {
+          value[field.name.value] = GraphQLJSON.parseLiteral(field.value);
+        });
+        return value;
+      }
+      case Kind.LIST:
+        return ast.values.map((n) => GraphQLJSON.parseLiteral(n));
+      case Kind.NULL:
+        return null;
+      default:
+        return;
+    }
+  }
+});
+
+// src/graphql/type-builder.ts
+var allowedNameChars = /^[a-zA-Z0-9_]+$/;
+var enumMap = new WeakMap;
+var generateEnumCached = (column, columnName, tableName) => {
+  const cached = enumMap.get(column);
+  if (cached)
+    return cached;
+  const gqlEnum = new GraphQLEnumType({
+    name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
+    values: Object.fromEntries((column.enumValues ?? []).map((e, index) => {
+      const enumName = e.replace(/-/g, "_");
+      const finalName = allowedNameChars.test(enumName) ? enumName : `Option${index}`;
+      return [
+        finalName,
+        {
+          value: e,
+          description: `Value: ${e}`
+        }
+      ];
+    }))
+  });
+  enumMap.set(column, gqlEnum);
+  return gqlEnum;
+};
+var geoXyType = new GraphQLObjectType({
+  name: "PgGeometryObject",
+  fields: {
+    x: { type: GraphQLFloat },
+    y: { type: GraphQLFloat }
+  }
+});
+var geoXyInputType = new GraphQLInputObjectType({
+  name: "PgGeometryObjectInput",
+  fields: {
+    x: { type: GraphQLFloat },
+    y: { type: GraphQLFloat }
+  }
+});
+var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
+  switch (column.dataType) {
+    case "boolean":
+      return { type: GraphQLBoolean, description: "Boolean" };
+    case "json":
+      return column.columnType === "PgGeometryObject" ? {
+        type: isInput ? geoXyInputType : geoXyType,
+        description: "Geometry points XY"
+      } : { type: GraphQLJSON, description: "JSON" };
+    case "date":
+      return { type: GraphQLString, description: "Date" };
+    case "string":
+      if (column.enumValues?.length) {
+        return { type: generateEnumCached(column, columnName, tableName) };
+      }
+      return { type: GraphQLString, description: "String" };
+    case "bigint":
+      return { type: GraphQLString, description: "BigInt" };
+    case "number":
+      return is2(column, PgInteger) || is2(column, PgSmallInt) || is2(column, PgBigInt53) || is2(column, PgSerial) || is2(column, PgSmallSerial) || is2(column, PgBigSerial53) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
+    case "buffer":
+      return {
+        type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
+        description: "Buffer"
+      };
+    case "array": {
+      if (column.columnType === "PgVector") {
+        return {
+          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+          description: "Array<Float>"
+        };
+      }
+      if (column.columnType === "PgGeometry") {
+        return {
+          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+          description: "Tuple<[Float, Float]>"
+        };
+      }
+      const innerType = columnToGraphQLCore(column.baseColumn, columnName, tableName, isInput);
+      return {
+        type: new GraphQLList(new GraphQLNonNull(innerType.type)),
+        description: `Array<${innerType.description}>`
+      };
+    }
+    default:
+      throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
+  }
+};
+var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
+  const typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
+  const noDesc = ["string", "boolean", "number"];
+  if (noDesc.find((e) => e === column.dataType))
+    delete typeDesc.description;
+  if (forceNullable)
+    return typeDesc;
+  if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
+    return {
+      type: new GraphQLNonNull(typeDesc.type),
+      description: typeDesc.description
+    };
+  }
+  return typeDesc;
+};
+
+// src/schema-builder.ts
+class SchemaBuilder {
+  db;
+  tables;
+  relationMap;
+  relationalSchema;
+  tableNamesMap;
+  config;
+  hooks;
+  adapter;
+  suffixes;
+  limitRelationDepth;
+  limitSelfRelationDepth;
+  excludedTables;
+  tableOperations;
+  pruneRelations;
+  filterTypes = new Map;
+  orderByTypes = new Map;
+  filterValueTypes = new Map;
+  selectFieldTypes = new Map;
+  innerOrder;
+  constructor(db, config) {
+    this.db = db;
+    this.config = config ?? {};
+    this.hooks = config?.hooks ?? {};
+    this.adapter = new PgAdapter;
+    this.suffixes = {
+      list: config?.suffixes?.list ?? "",
+      single: config?.suffixes?.single ?? "Single"
+    };
+    this.limitRelationDepth = config?.limitRelationDepth ?? 3;
+    this.limitSelfRelationDepth = config?.limitSelfRelationDepth ?? 1;
+    this.pruneRelations = new Map(Object.entries(config?.pruneRelations ?? {}));
+    const schema = db._.fullSchema;
+    if (!schema) {
+      throw new Error("Drizzle-GraphQL Error: Schema not found in drizzle instance. Make sure you're using drizzle-orm v0.30.9 or above and schema is passed to drizzle constructor!");
+    }
+    const dbConfig = db._;
+    this.relationalSchema = dbConfig.schema;
+    this.tableNamesMap = dbConfig.tableNamesMap;
+    if (typeof this.limitRelationDepth === "number") {
+      if (this.limitRelationDepth < 0 || this.limitRelationDepth !== ~~this.limitRelationDepth) {
+        throw new Error("Drizzle-GraphQL Error: config.limitRelationDepth is supposed to be nonnegative integer or undefined!");
+      }
+    }
+    if (this.limitSelfRelationDepth < 1 || this.limitSelfRelationDepth !== ~~this.limitSelfRelationDepth) {
+      throw new Error("Drizzle-GraphQL Error: config.limitSelfRelationDepth must be a positive integer!");
+    }
+    if (this.suffixes.list === this.suffixes.single) {
+      throw new Error("Drizzle-GraphQL Error: List and single query suffixes cannot be the same. This would create conflicting GraphQL field names.");
+    }
+    this.innerOrder = new GraphQLInputObjectType2({
+      name: "InnerOrder",
+      fields: {
+        direction: {
+          type: new GraphQLNonNull2(new GraphQLEnumType2({
+            name: "OrderDirection",
+            description: "Order by direction",
+            values: {
+              asc: { value: "asc", description: "Ascending order" },
+              desc: { value: "desc", description: "Descending order" }
+            }
+          }))
+        },
+        priority: {
+          type: new GraphQLNonNull2(GraphQLInt2),
+          description: "Priority of current field"
+        }
+      }
+    });
+    this.tables = this.extractTables(schema);
+    this.excludedTables = new Set(config?.tables?.exclude ?? []);
+    this.tableOperations = config?.tables?.config ?? {};
+    for (const tableName of this.excludedTables) {
+      delete this.tables[tableName];
+    }
+    this.relationMap = this.buildRelationMap(schema);
+  }
+  toFieldMap(tableFields, relationFields) {
+    return { ...tableFields, ...relationFields };
+  }
+  buildEntities() {
+    const queries = {};
+    const mutations = {};
+    const inputs = {};
+    const outputs = {};
+    for (const tableName of Object.keys(this.tables)) {
+      const tableOps = this.tableOperations[tableName];
+      const generateQueries = tableOps?.queries !== false;
+      const generateMutations = tableOps?.mutations !== false && this.config.mutations !== false;
+      if (!generateQueries && !generateMutations)
+        continue;
+      const tableTypes = this.generateTableTypes(tableName);
+      const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
+      const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+      if (generateQueries) {
+        const selectArr = this.createQueryResolver(tableName, tableOrder, tableFilters);
+        queries[selectArr.name] = {
+          type: selectArrOutput,
+          args: selectArr.args,
+          resolve: selectArr.resolver
+        };
+        const selectSingle = this.createSingleQueryResolver(tableName, tableOrder, tableFilters);
+        queries[selectSingle.name] = {
+          type: selectSingleOutput,
+          args: selectSingle.args,
+          resolve: selectSingle.resolver
+        };
+        const selectCount = this.createCountResolver(tableName, tableFilters);
+        queries[selectCount.name] = {
+          type: GraphQLInt2,
+          args: selectCount.args,
+          resolve: selectCount.resolver
+        };
+        inputs[tableFilters.name] = tableFilters;
+        inputs[tableOrder.name] = tableOrder;
+        outputs[selectSingleOutput.name] = selectSingleOutput;
+      }
+      if (generateMutations) {
+        const insertArr = this.createInsertResolver(tableName, insertInput);
+        mutations[insertArr.name] = {
+          type: arrTableItemOutput,
+          args: insertArr.args,
+          resolve: insertArr.resolver
+        };
+        const insertSingle = this.createInsertSingleResolver(tableName, insertInput);
+        mutations[insertSingle.name] = {
+          type: singleTableItemOutput,
+          args: insertSingle.args,
+          resolve: insertSingle.resolver
+        };
+        const update = this.createUpdateResolver(tableName, updateInput, tableFilters);
+        mutations[update.name] = {
+          type: arrTableItemOutput,
+          args: update.args,
+          resolve: update.resolver
+        };
+        const del = this.createDeleteResolver(tableName, tableFilters);
+        mutations[del.name] = {
+          type: arrTableItemOutput,
+          args: del.args,
+          resolve: del.resolver
+        };
+        inputs[insertInput.name] = insertInput;
+        inputs[updateInput.name] = updateInput;
+        inputs[tableFilters.name] = tableFilters;
+        inputs[tableOrder.name] = tableOrder;
+        outputs[singleTableItemOutput.name] = singleTableItemOutput;
+      }
+    }
+    return { queries, mutations, inputs, types: outputs };
+  }
+  build() {
+    const entities = this.buildEntities();
+    const { queries, mutations, inputs, types: outputs } = entities;
+    const graphQLSchemaConfig = {
+      types: [...Object.values(inputs), ...Object.values(outputs)],
+      query: new GraphQLObjectType2({
+        name: "Query",
+        fields: queries
+      })
+    };
+    if (this.config.mutations !== false) {
+      graphQLSchemaConfig.mutation = new GraphQLObjectType2({
+        name: "Mutation",
+        fields: mutations
+      });
+    }
+    const schema = new GraphQLSchema(graphQLSchemaConfig);
+    this.logDebugInfo(schema);
+    return { schema, entities };
+  }
+  logDebugInfo(schema) {
+    const debug = this.config.debug;
+    if (!debug)
+      return;
+    const showSize = debug === true || typeof debug === "object" && debug.schemaSize !== false;
+    const showTree = typeof debug === "object" && debug.relationTree === true;
+    if (showSize) {
+      const sdl = printSchema(schema);
+      const typeCount = Object.keys(schema.getTypeMap()).filter((t) => !t.startsWith("__")).length;
+      console.info(`[drizzle-graphql] Schema: ${sdl.length} bytes, ${typeCount} types`);
+    }
+    if (showTree) {
+      for (const [tableName, relations] of Object.entries(this.relationMap)) {
+        const relNames = Object.keys(relations);
+        if (relNames.length) {
+          console.info(`[drizzle-graphql] ${tableName}: ${relNames.join(", ")}`);
+        }
+      }
+    }
+  }
+  extractTables(schema) {
+    const entries = Object.entries(schema).filter(([_, value]) => is3(value, PgTable2));
+    if (!entries.length) {
+      throw new Error("Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?");
+    }
+    return Object.fromEntries(entries);
+  }
+  getTable(tableName) {
+    const table = this.tables[tableName];
+    if (!table) {
+      throw new Error(`Drizzle-GraphQL Error: Table '${tableName}' not found.`);
+    }
+    return table;
+  }
+  buildRelationMap(schema) {
+    const schemaEntries = Object.entries(schema);
+    const tableEntries = Object.entries(this.tables);
+    const rawRelations = schemaEntries.filter(([_, value]) => is3(value, Relations)).map(([_, value]) => {
+      const entry = tableEntries.find(([__, tableValue]) => tableValue === value.table);
+      if (!entry)
+        return null;
+      return [entry[0], value];
+    }).filter((entry) => entry !== null).map(([tableName, relValue]) => [
+      tableName,
+      relValue.config(createTableRelationsHelpers(this.getTable(tableName)))
+    ]);
+    return Object.fromEntries(rawRelations.map(([relName, config]) => {
+      const namedConfig = Object.fromEntries(Object.entries(config).map(([innerRelName, innerRelValue]) => {
+        const targetEntry = tableEntries.find(([_, tableValue]) => tableValue === innerRelValue.referencedTable);
+        if (!targetEntry)
+          return null;
+        return [
+          innerRelName,
+          { relation: innerRelValue, targetTableName: targetEntry[0] }
+        ];
+      }).filter((entry) => entry !== null));
+      return [relName, namedConfig];
+    }));
+  }
+  getFilterType(tableName) {
+    const cached = this.filterTypes.get(tableName);
+    if (cached)
+      return cached;
+    const filters = new GraphQLInputObjectType2({
+      name: `${capitalize(tableName)}Filters`,
+      fields: () => {
+        const filterColumns = this.getFilterValues(tableName);
+        const relationFilterFields = this.buildRelationFilterFields(tableName);
+        return {
+          ...filterColumns,
+          ...relationFilterFields,
+          OR: {
+            type: new GraphQLList2(new GraphQLNonNull2(new GraphQLInputObjectType2({
+              name: `${capitalize(tableName)}FiltersOr`,
+              fields: () => ({
+                ...filterColumns,
+                ...relationFilterFields
+              })
+            })))
+          }
+        };
+      }
+    });
+    this.filterTypes.set(tableName, filters);
+    return filters;
+  }
+  getOrderByType(tableName) {
+    const cached = this.orderByTypes.get(tableName);
+    if (cached)
+      return cached;
+    const table = this.getTable(tableName);
+    const columns = getTableColumns2(table);
+    const orderColumns = Object.fromEntries(Object.entries(columns).map(([columnName]) => [columnName, { type: this.innerOrder }]));
+    const order = new GraphQLInputObjectType2({
+      name: `${capitalize(tableName)}OrderBy`,
+      fields: orderColumns
+    });
+    this.orderByTypes.set(tableName, order);
+    return order;
+  }
+  getFilterValues(tableName) {
+    const cached = this.filterValueTypes.get(tableName);
+    if (cached)
+      return cached;
+    const table = this.getTable(tableName);
+    const columns = getTableColumns2(table);
+    const result = Object.fromEntries(Object.entries(columns).map(([columnName, col]) => [
+      columnName,
+      { type: this.generateColumnFilterValues(col, tableName, columnName) }
+    ]));
+    this.filterValueTypes.set(tableName, result);
+    return result;
+  }
+  getSelectFields(tableName) {
+    const cached = this.selectFieldTypes.get(tableName);
+    if (cached)
+      return cached;
+    const table = this.getTable(tableName);
+    const columns = getTableColumns2(table);
+    const result = Object.fromEntries(Object.entries(columns).map(([columnName, col]) => [
+      columnName,
+      drizzleColumnToGraphQLType(col, columnName, tableName)
+    ]));
+    this.selectFieldTypes.set(tableName, result);
+    return result;
+  }
+  generateColumnFilterValues(column, tableName, columnName) {
+    const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+    const columnArr = new GraphQLList2(new GraphQLNonNull2(columnGraphQLType.type));
+    const baseFields = {
+      eq: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      ne: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      lt: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      lte: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      gt: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      gte: { type: columnGraphQLType.type, description: columnGraphQLType.description },
+      like: { type: GraphQLString2 },
+      notLike: { type: GraphQLString2 },
+      ilike: { type: GraphQLString2 },
+      notIlike: { type: GraphQLString2 },
+      inArray: { type: columnArr, description: `Array<${columnGraphQLType.description}>` },
+      notInArray: { type: columnArr, description: `Array<${columnGraphQLType.description}>` },
+      isNull: { type: GraphQLBoolean2 },
+      isNotNull: { type: GraphQLBoolean2 }
+    };
+    return new GraphQLInputObjectType2({
+      name: `${capitalize(tableName)}${capitalize(columnName)}Filters`,
+      fields: {
+        ...baseFields,
+        OR: {
+          type: new GraphQLList2(new GraphQLNonNull2(new GraphQLInputObjectType2({
+            name: `${capitalize(tableName)}${capitalize(columnName)}FiltersOr`,
+            fields: baseFields
+          })))
+        }
+      }
+    });
+  }
+  generateSelectFields(tableName, typeName, withOrder, currentDepth = 0, usedTables = new Set, currentSelfDepth = 0, forceLeaf, allowedRelations) {
+    const relations = this.relationMap[tableName];
+    const relationEntries = relations ? Object.entries(relations) : [];
+    const order = withOrder ? this.getOrderByType(tableName) : undefined;
+    const filters = this.getFilterType(tableName);
+    const tableFields = this.getSelectFields(tableName);
+    if (forceLeaf || typeof this.limitRelationDepth !== "number" && usedTables.has(tableName) || typeof this.limitRelationDepth === "number" && currentDepth >= this.limitRelationDepth || !relationEntries.length) {
+      return { order, filters, tableFields, relationFields: {} };
+    }
+    const rawRelationFields = [];
+    const updatedUsedTables = new Set(usedTables).add(tableName);
+    const newDepth = currentDepth + 1;
+    for (const [relationName, { targetTableName, relation }] of relationEntries) {
+      if (allowedRelations && !allowedRelations.includes(relationName))
+        continue;
+      const pruneRule = this.pruneRelations.get(`${tableName}.${relationName}`);
+      if (pruneRule === false)
+        continue;
+      const relTypeName = `${typeName}${capitalize(relationName)}Relation`;
+      const isOne = is3(relation, One);
+      const isSelfRelation = targetTableName === tableName;
+      if (isSelfRelation && currentSelfDepth + 1 >= this.limitSelfRelationDepth) {
+        continue;
+      }
+      const isCrossCycle = !isSelfRelation && usedTables.has(targetTableName);
+      const effectiveDepth = isCrossCycle && typeof this.limitRelationDepth === "number" ? Math.max(newDepth, this.limitRelationDepth - 1) : newDepth;
+      const isLeaf = pruneRule === "leaf";
+      const onlyRels = pruneRule && typeof pruneRule === "object" ? pruneRule.only : undefined;
+      const relData = this.generateSelectFields(targetTableName, relTypeName, !isOne, effectiveDepth, updatedUsedTables, isSelfRelation ? currentSelfDepth + 1 : 0, isLeaf, onlyRels);
+      const relType = new GraphQLObjectType2({
+        name: relTypeName,
+        fields: this.toFieldMap(relData.tableFields, relData.relationFields)
+      });
+      if (isOne) {
+        rawRelationFields.push([
+          relationName,
+          {
+            type: relType,
+            args: {
+              where: { type: relData.filters }
+            }
+          }
+        ]);
+        continue;
+      }
+      rawRelationFields.push([
+        relationName,
+        {
+          type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(relType))),
+          args: {
+            where: { type: relData.filters },
+            orderBy: { type: relData.order },
+            offset: { type: GraphQLInt2 },
+            limit: { type: GraphQLInt2 }
+          }
+        }
+      ]);
+    }
+    const relationFields = Object.fromEntries(rawRelationFields);
+    return { order, filters, tableFields, relationFields };
+  }
+  generateTableTypes(tableName) {
+    const stylizedName = capitalize(tableName);
+    const { tableFields, relationFields, filters, order } = this.generateSelectFields(tableName, stylizedName, true);
+    const table = this.getTable(tableName);
+    const columns = getTableColumns2(table);
+    const columnEntries = Object.entries(columns);
+    const insertFields = Object.fromEntries(columnEntries.map(([columnName, col]) => [
+      columnName,
+      drizzleColumnToGraphQLType(col, columnName, tableName, false, true, true)
+    ]));
+    const updateFields = Object.fromEntries(columnEntries.map(([columnName, col]) => [
+      columnName,
+      drizzleColumnToGraphQLType(col, columnName, tableName, true, false, true)
+    ]));
+    const insertInput = new GraphQLInputObjectType2({
+      name: `${stylizedName}InsertInput`,
+      fields: insertFields
+    });
+    const updateInput = new GraphQLInputObjectType2({
+      name: `${stylizedName}UpdateInput`,
+      fields: updateFields
+    });
+    const selectSingleOutput = new GraphQLObjectType2({
+      name: `${stylizedName}SelectItem`,
+      fields: this.toFieldMap(tableFields, relationFields)
+    });
+    const selectArrOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)));
+    const singleTableItemOutput = new GraphQLObjectType2({
+      name: `${stylizedName}Item`,
+      fields: this.toFieldMap(tableFields)
+    });
+    const arrTableItemOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(singleTableItemOutput)));
+    return {
+      inputs: {
+        insertInput,
+        updateInput,
+        tableOrder: order,
+        tableFilters: filters
+      },
+      outputs: {
+        selectSingleOutput,
+        selectArrOutput,
+        singleTableItemOutput,
+        arrTableItemOutput
+      }
+    };
+  }
+  buildRelationFilterFields(tableName) {
+    const relations = this.relationMap[tableName];
+    if (!relations)
+      return {};
+    const fields = {};
+    for (const [relationName, { targetTableName, relation }] of Object.entries(relations)) {
+      if (is3(relation, One)) {
+        fields[relationName] = {
+          type: this.getFilterType(targetTableName)
+        };
+      } else {
+        fields[relationName] = {
+          type: new GraphQLInputObjectType2({
+            name: `${capitalize(tableName)}${capitalize(relationName)}RelFilter`,
+            fields: () => ({
+              some: { type: this.getFilterType(targetTableName) },
+              every: { type: this.getFilterType(targetTableName) },
+              none: { type: this.getFilterType(targetTableName) }
+            })
+          })
+        };
+      }
+    }
+    return fields;
+  }
+  createQueryResolver(tableName, orderArgs, filterArgs) {
+    const queryName = `${uncapitalize(tableName)}${this.suffixes.list}`;
+    const typeName = `${capitalize(tableName)}SelectItem`;
+    const table = this.getTable(tableName);
+    const queryBase = this.db.query[tableName];
+    if (!queryBase) {
+      throw new Error(`Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`);
+    }
+    const args = {
+      offset: { type: GraphQLInt2 },
+      limit: { type: GraphQLInt2 },
+      orderBy: { type: orderArgs },
+      where: { type: filterArgs }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "query", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const { offset, limit, orderBy, where } = finalArgs;
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const query = queryBase.findMany({
+            columns: this.extractColumns(this.getFieldsByTypeName(parsedInfo, typeName), table),
+            offset,
+            limit,
+            orderBy: orderBy ? this.extractOrderBy(table, orderBy) : undefined,
+            where: where ? this.extractAllFilters(table, tableName, where) : undefined,
+            with: this.relationMap[tableName] ? this.extractRelationsParams(tableName, parsedInfo, typeName) : undefined
+          });
+          const result = await query;
+          return remapToGraphQLArrayOutput(result, tableName, table, this.relationMap);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createSingleQueryResolver(tableName, orderArgs, filterArgs) {
+    const queryName = `${uncapitalize(tableName)}${this.suffixes.single}`;
+    const typeName = `${capitalize(tableName)}SelectItem`;
+    const table = this.getTable(tableName);
+    const queryBase = this.db.query[tableName];
+    if (!queryBase) {
+      throw new Error(`Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`);
+    }
+    const args = {
+      offset: { type: GraphQLInt2 },
+      orderBy: { type: orderArgs },
+      where: { type: filterArgs }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "querySingle", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const { offset, orderBy, where } = finalArgs;
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const query = queryBase.findFirst({
+            columns: this.extractColumns(this.getFieldsByTypeName(parsedInfo, typeName), table),
+            offset,
+            orderBy: orderBy ? this.extractOrderBy(table, orderBy) : undefined,
+            where: where ? this.extractAllFilters(table, tableName, where) : undefined,
+            with: this.relationMap[tableName] ? this.extractRelationsParams(tableName, parsedInfo, typeName) : undefined
+          });
+          const result = await query;
+          if (!result)
+            return;
+          return remapToGraphQLSingleOutput(result, tableName, table, this.relationMap);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createCountResolver(tableName, filterArgs) {
+    const queryName = `${uncapitalize(tableName)}Count`;
+    const table = this.getTable(tableName);
+    const args = {
+      where: { type: filterArgs }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "count", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const { where } = finalArgs;
+          const whereClause = where ? this.extractAllFilters(table, tableName, where) : undefined;
+          return await this.executeCountQuery(table, whereClause);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createInsertResolver(tableName, baseType) {
+    const queryName = `insertInto${capitalize(tableName)}`;
+    const typeName = `${capitalize(tableName)}Item`;
+    const table = this.getTable(tableName);
+    const args = {
+      values: { type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(baseType))) }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "insert", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const input = remapFromGraphQLArrayInput(finalArgs.values, table);
+          if (!input.length)
+            throw new GraphQLError2("No values were provided!");
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const columns = this.extractColumnsSQLFormat(this.getFieldsByTypeName(parsedInfo, typeName), table);
+          const result = await this.adapter.executeInsert(this.db, table, input, columns);
+          return remapToGraphQLArrayOutput(result, tableName, table);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createInsertSingleResolver(tableName, baseType) {
+    const queryName = `insertInto${capitalize(tableName)}Single`;
+    const typeName = `${capitalize(tableName)}Item`;
+    const table = this.getTable(tableName);
+    const args = {
+      values: { type: new GraphQLNonNull2(baseType) }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "insertSingle", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const input = remapFromGraphQLSingleInput(finalArgs.values, table);
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const columns = this.extractColumnsSQLFormat(this.getFieldsByTypeName(parsedInfo, typeName), table);
+          const result = await this.adapter.executeInsert(this.db, table, [input], columns);
+          if (!result[0])
+            return;
+          return remapToGraphQLSingleOutput(result[0], tableName, table);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createUpdateResolver(tableName, setArgs, filterArgs) {
+    const queryName = `update${capitalize(tableName)}`;
+    const typeName = `${capitalize(tableName)}Item`;
+    const table = this.getTable(tableName);
+    const args = {
+      set: { type: new GraphQLNonNull2(setArgs) },
+      where: { type: filterArgs }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "update", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const { where, set } = finalArgs;
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const columns = this.extractColumnsSQLFormat(this.getFieldsByTypeName(parsedInfo, typeName), table);
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length)
+            throw new GraphQLError2("Unable to update with no values specified!");
+          const whereClause = where ? this.extractAllFilters(table, tableName, where) : undefined;
+          const result = await this.adapter.executeUpdate(this.db, table, input, whereClause, columns);
+          return remapToGraphQLArrayOutput(result, tableName, table);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  createDeleteResolver(tableName, filterArgs) {
+    const queryName = `deleteFrom${capitalize(tableName)}`;
+    const typeName = `${capitalize(tableName)}Item`;
+    const table = this.getTable(tableName);
+    const args = {
+      where: { type: filterArgs }
+    };
+    const resolver = async (_source, resolverArgs, context, info) => {
+      return this.executeWithHooks(tableName, "delete", resolverArgs, context, info, async (finalArgs) => {
+        try {
+          const { where } = finalArgs;
+          const parsedInfo = parseResolveInfo(info, { deep: true });
+          const columns = this.extractColumnsSQLFormat(this.getFieldsByTypeName(parsedInfo, typeName), table);
+          const whereClause = where ? this.extractAllFilters(table, tableName, where) : undefined;
+          const result = await this.adapter.executeDelete(this.db, table, whereClause, columns);
+          return remapToGraphQLArrayOutput(result, tableName, table);
+        } catch (e) {
+          if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") {
+            throw new GraphQLError2(e.message);
+          }
+          throw e;
+        }
+      });
+    };
+    return { name: queryName, resolver, args };
+  }
+  extractColumnFilters(column, columnName, operators) {
+    if (!operators.OR?.length)
+      delete operators.OR;
+    const entries = Object.entries(operators);
+    if (operators.OR) {
+      if (entries.length > 1) {
+        throw new GraphQLError2(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+      }
+      const variants2 = [];
+      for (const variant of operators.OR) {
+        const extracted = this.extractColumnFilters(column, columnName, variant);
+        if (extracted)
+          variants2.push(extracted);
+      }
+      return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : undefined;
+    }
+    const comparisonOps = { eq, ne, gt, gte, lt, lte };
+    const stringOps = { like, notLike, ilike, notIlike };
+    const arrayOps = {
+      inArray,
+      notInArray
+    };
+    const nullOps = { isNull, isNotNull };
+    const variants = [];
+    for (const [operatorName, operatorValue] of entries) {
+      if (operatorValue === null || operatorValue === false)
+        continue;
+      if (operatorName in comparisonOps) {
+        const op = comparisonOps[operatorName];
+        if (op) {
+          const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
+          variants.push(op(column, singleValue));
+        }
+      } else if (operatorName in stringOps) {
+        const op = stringOps[operatorName];
+        if (op)
+          variants.push(op(column, operatorValue));
+      } else if (operatorName in arrayOps) {
+        const op = arrayOps[operatorName];
+        if (op) {
+          if (!operatorValue.length) {
+            throw new GraphQLError2(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+          }
+          const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
+          variants.push(op(column, arrayValue));
+        }
+      } else if (operatorName in nullOps) {
+        const op = nullOps[operatorName];
+        if (op)
+          variants.push(op(column));
+      }
+    }
+    return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : undefined;
+  }
+  extractTableColumnFilters(table, tableName, filters) {
+    if (!filters.OR?.length)
+      delete filters.OR;
+    const tableColumns = getTableColumns2(table);
+    const columnEntries = [];
+    const relationEntries = [];
+    for (const [key, value] of Object.entries(filters)) {
+      if (key === "OR")
+        continue;
+      if (value === null)
+        continue;
+      if (tableColumns[key]) {
+        columnEntries.push([key, value]);
+      } else {
+        relationEntries.push([key, value]);
+      }
+    }
+    if (filters.OR) {
+      if (columnEntries.length > 0 || relationEntries.length > 0) {
+        throw new GraphQLError2(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
+      }
+      const variants2 = [];
+      for (const variant of filters.OR) {
+        const extracted = this.extractAllFilters(table, tableName, variant);
+        if (extracted)
+          variants2.push(extracted);
+      }
+      return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : undefined;
+    }
+    const variants = [];
+    for (const [columnName, operators] of columnEntries) {
+      const column = tableColumns[columnName];
+      if (!column)
+        continue;
+      const result = this.extractColumnFilters(column, columnName, operators);
+      if (result)
+        variants.push(result);
+    }
+    for (const [relationName, filterValue] of relationEntries) {
+      const result = this.extractRelationFilters(table, tableName, relationName, filterValue);
+      if (result)
+        variants.push(result);
+    }
+    return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : undefined;
+  }
+  extractAllFilters(table, tableName, filters) {
+    return this.extractTableColumnFilters(table, tableName, filters);
+  }
+  extractRelationFilters(table, tableName, relationName, filterValue) {
+    const rel = this.relationMap[tableName]?.[relationName];
+    if (!rel)
+      return;
+    const { targetTableName, relation } = rel;
+    const targetTable = this.getTable(targetTableName);
+    const isOne = is3(relation, One);
+    if (isOne) {
+      return this.buildExistsSubquery(table, targetTable, relation, targetTableName, filterValue, "some");
+    } else {
+      const variants = [];
+      if (filterValue.some) {
+        const result = this.buildExistsSubquery(table, targetTable, relation, targetTableName, filterValue.some, "some");
+        if (result)
+          variants.push(result);
+      }
+      if (filterValue.every) {
+        const result = this.buildExistsSubquery(table, targetTable, relation, targetTableName, filterValue.every, "every");
+        if (result)
+          variants.push(result);
+      }
+      if (filterValue.none) {
+        const result = this.buildExistsSubquery(table, targetTable, relation, targetTableName, filterValue.none, "none");
+        if (result)
+          variants.push(result);
+      }
+      return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : undefined;
+    }
+  }
+  buildExistsSubquery(parentTable, targetTable, relation, targetTableName, filterValue, quantifier) {
+    const joinCondition = this.buildJoinCondition(parentTable, targetTable, relation);
+    if (!joinCondition)
+      return;
+    const innerFilter = this.extractAllFilters(targetTable, targetTableName, filterValue);
+    const whereClause = innerFilter ? and(joinCondition, innerFilter) : joinCondition;
+    if (!whereClause)
+      return;
+    const subquery = this.db.select({ _: sql`1` }).from(targetTable).where(whereClause);
+    switch (quantifier) {
+      case "some":
+        return exists(subquery);
+      case "none":
+        return not(exists(subquery));
+      case "every": {
+        if (!innerFilter)
+          return;
+        const negatedFilter = not(innerFilter);
+        const everyWhereClause = and(joinCondition, negatedFilter);
+        if (!everyWhereClause)
+          return;
+        const everySubquery = this.db.select({ _: sql`1` }).from(targetTable).where(everyWhereClause);
+        return not(exists(everySubquery));
+      }
+    }
+  }
+  buildJoinCondition(parentTable, _targetTable, relation) {
+    try {
+      const { fields, references } = normalizeRelation(this.relationalSchema, this.tableNamesMap, relation);
+      if (!fields?.length || !references?.length)
+        return;
+      const parentName = getTableName(parentTable);
+      const conditions = [];
+      for (let i = 0;i < fields.length; i++) {
+        const field = fields[i];
+        const ref = references[i];
+        if (!field || !ref)
+          continue;
+        if (getTableName(field.table) === parentName) {
+          conditions.push(sql`${sql.identifier(parentName)}.${sql.identifier(field.name)} = ${ref}`);
+        } else if (getTableName(ref.table) === parentName) {
+          conditions.push(sql`${field} = ${sql.identifier(parentName)}.${sql.identifier(ref.name)}`);
+        } else {
+          conditions.push(eq(field, ref));
+        }
+      }
+      return conditions.length > 1 ? and(...conditions) : conditions[0];
+    } catch {
+      return;
+    }
+  }
+  extractOrderBy(table, orderArgs) {
+    const res = [];
+    for (const [column, config] of Object.entries(orderArgs).sort((a, b) => {
+      const ap = a[1]?.priority ?? 0;
+      const bp = b[1]?.priority ?? 0;
+      return bp - ap;
+    })) {
+      if (!config)
+        continue;
+      const { direction } = config;
+      const col = getTableColumns2(table)[column];
+      if (!col)
+        continue;
+      res.push(direction === "asc" ? asc(col) : desc(col));
+    }
+    return res;
+  }
+  extractColumns(tree, table) {
+    const tableColumns = getTableColumns2(table);
+    const selectedColumns = [];
+    for (const [_, fieldData] of Object.entries(tree)) {
+      if (!tableColumns[fieldData.name])
+        continue;
+      selectedColumns.push([fieldData.name, true]);
+    }
+    if (!selectedColumns.length) {
+      const columnKeys = Object.entries(tableColumns);
+      const columnName = columnKeys.find((e) => !rqbCrashTypes.includes(e[1].columnType))?.[0] ?? columnKeys[0]?.[0] ?? "";
+      selectedColumns.push([columnName, true]);
+    }
+    return Object.fromEntries(selectedColumns);
+  }
+  extractColumnsSQLFormat(tree, table) {
+    const tableColumns = getTableColumns2(table);
+    const selectedColumns = [];
+    for (const [_, fieldData] of Object.entries(tree)) {
+      const col = tableColumns[fieldData.name];
+      if (!col)
+        continue;
+      selectedColumns.push([fieldData.name, col]);
+    }
+    if (!selectedColumns.length) {
+      const columnKeys = Object.entries(tableColumns);
+      const columnName = columnKeys.find((e) => !rqbCrashTypes.includes(e[1].columnType))?.[0] ?? columnKeys[0]?.[0] ?? "";
+      const fallbackCol = tableColumns[columnName];
+      if (fallbackCol)
+        selectedColumns.push([columnName, fallbackCol]);
+    }
+    return Object.fromEntries(selectedColumns);
+  }
+  getFieldsByTypeName(info, typeName) {
+    return info.fieldsByTypeName[typeName] ?? {};
+  }
+  extractRelationsParams(tableName, info, typeName) {
+    return this.extractRelationsParamsInner(tableName, typeName, info, true);
+  }
+  extractRelationsParamsInner(tableName, typeName, originField, isInitial = false) {
+    const relations = this.relationMap[tableName];
+    if (!relations)
+      return;
+    const baseField = Object.entries(originField.fieldsByTypeName).find(([key]) => key === typeName)?.[1];
+    if (!baseField)
+      return;
+    const args = {};
+    for (const [relName, { targetTableName }] of Object.entries(relations)) {
+      const relTypeName = `${isInitial ? capitalize(tableName) : typeName}${capitalize(relName)}Relation`;
+      const relFieldSelection = Object.values(baseField).find((field) => field.name === relName)?.fieldsByTypeName[relTypeName];
+      if (!relFieldSelection)
+        continue;
+      const targetTable = this.getTable(targetTableName);
+      const columns = this.extractColumns(relFieldSelection, targetTable);
+      const thisRecord = { columns };
+      const relationField = Object.values(baseField).find((e) => e.name === relName);
+      const relationArgs = relationField?.args;
+      thisRecord.orderBy = relationArgs?.orderBy ? this.extractOrderBy(targetTable, relationArgs.orderBy) : undefined;
+      thisRecord.where = relationArgs?.where ? this.extractAllFilters(targetTable, relName, relationArgs.where) : undefined;
+      thisRecord.offset = relationArgs?.offset ?? undefined;
+      thisRecord.limit = relationArgs?.limit ?? undefined;
+      thisRecord.with = relationField ? this.extractRelationsParamsInner(targetTableName, relTypeName, relationField) : undefined;
+      args[relName] = thisRecord;
+    }
+    return args;
+  }
+  async executeWithHooks(tableName, operation, args, context, info, execute) {
+    const tableHooks = this.hooks[tableName];
+    if (!tableHooks)
+      return execute(args);
+    const opHooks = tableHooks[operation];
+    if (!opHooks)
+      return execute(args);
+    if ("resolve" in opHooks && opHooks.resolve) {
+      const resolveFn = opHooks.resolve;
+      const defaultResolve = (overrideArgs) => execute(overrideArgs ?? args);
+      return resolveFn({ args, context, info, defaultResolve });
+    }
+    let finalArgs = args;
+    let beforeData;
+    if ("before" in opHooks && opHooks.before) {
+      const beforeResult = await opHooks.before({
+        args,
+        context,
+        info
+      });
+      if (beforeResult) {
+        if (beforeResult.args)
+          finalArgs = beforeResult.args;
+        if (beforeResult.data)
+          beforeData = beforeResult.data;
+      }
+    }
+    const result = await execute(finalArgs);
+    if ("after" in opHooks && opHooks.after) {
+      return opHooks.after({ result, beforeData, context, info });
+    }
+    return result;
+  }
+  async executeCountQuery(table, where) {
+    const db = this.db;
+    if (db.$count && typeof db.$count === "function") {
+      try {
+        const result2 = where ? await db.$count(table, where) : await db.$count(table);
+        return Number(result2) || 0;
+      } catch (_) {}
+    }
+    const query = this.db.select({ count: count() }).from(table);
+    const result = await (where ? query.where(where) : query);
+    const value = result[0]?.count || 0;
+    return Number(value);
+  }
+}
+var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
+// src/codegen.ts
+import {
+  isEnumType,
+  isInputObjectType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  printSchema as printSchema2
+} from "graphql";
+function getEntitiesFromSchema(schema) {
+  const queryType = schema.getQueryType();
+  const mutationType = schema.getMutationType();
+  const entities = new Map;
+  if (!queryType)
+    return entities;
+  const queryFields = queryType.getFields();
+  const mutationFields = mutationType?.getFields() ?? {};
+  for (const [fieldName] of Object.entries(queryFields)) {
+    if (!fieldName.endsWith("Count"))
+      continue;
+    const tableName = fieldName.slice(0, -5);
+    const listName = queryFields[`${tableName}s`] ? `${tableName}s` : queryFields[tableName] ? tableName : undefined;
+    const singleName = queryFields[tableName] ? tableName : undefined;
+    if (!listName)
+      continue;
+    const listField = queryFields[listName];
+    if (!listField)
+      continue;
+    const selectItemType = unwrapToObjectType(listField.type);
+    if (!selectItemType)
+      continue;
+    const selectFields = selectItemType.getFields();
+    const scalarFields = [];
+    const relations = {};
+    for (const [sfName, sfField] of Object.entries(selectFields)) {
+      const unwrapped = unwrapType(sfField.type);
+      if (isObjectType(unwrapped.type)) {
+        const isList = unwrapped.isList;
+        relations[sfName] = {
+          entity: sfName,
+          type: isList ? "many" : "one",
+          _graphqlType: unwrapped.type
+        };
+      } else {
+        scalarFields.push(sfName);
+      }
+    }
+    const capitalName = capitalize(tableName);
+    const insertName = mutationFields[`insertInto${capitalName}`] ? `insertInto${capitalName}` : undefined;
+    const insertSingleName = mutationFields[`insertInto${capitalName}Single`] ? `insertInto${capitalName}Single` : undefined;
+    const updateName = mutationFields[`update${capitalName}`] ? `update${capitalName}` : undefined;
+    const deleteName = mutationFields[`deleteFrom${capitalName}`] ? `deleteFrom${capitalName}` : undefined;
+    const typeMap = schema.getTypeMap();
+    const hasFilters = `${capitalName}Filters` in typeMap;
+    const hasInsertInput = `${capitalName}InsertInput` in typeMap;
+    const hasUpdateInput = `${capitalName}UpdateInput` in typeMap;
+    const hasOrderBy = `${capitalName}OrderBy` in typeMap;
+    entities.set(tableName, {
+      tableName,
+      typeName: capitalName,
+      fields: scalarFields,
+      relations,
+      queryName: singleName,
+      queryListName: listName,
+      countName: fieldName,
+      insertName,
+      insertSingleName,
+      updateName,
+      deleteName,
+      hasFilters,
+      hasInsertInput,
+      hasUpdateInput,
+      hasOrderBy
+    });
+  }
+  const entityFieldSets = new Map;
+  for (const [name, info] of entities) {
+    entityFieldSets.set(name, new Set(info.fields));
+  }
+  for (const entity of entities.values()) {
+    for (const [, rel] of Object.entries(entity.relations)) {
+      const graphqlType = rel._graphqlType;
+      delete rel._graphqlType;
+      if (!graphqlType)
+        continue;
+      const relFields = graphqlType.getFields();
+      const relScalarNames = new Set;
+      for (const [fname, ffield] of Object.entries(relFields)) {
+        const unwrapped = unwrapType(ffield.type);
+        if (!isObjectType(unwrapped.type)) {
+          relScalarNames.add(fname);
+        }
+      }
+      let bestMatch;
+      let bestOverlap = 0;
+      for (const [entityName, entityFields] of entityFieldSets) {
+        let overlap = 0;
+        for (const f of relScalarNames) {
+          if (entityFields.has(f))
+            overlap++;
+        }
+        if (overlap === relScalarNames.size && overlap > bestOverlap) {
+          bestOverlap = overlap;
+          bestMatch = entityName;
+        }
+      }
+      if (bestMatch) {
+        rel.entity = bestMatch;
+      }
+    }
+  }
+  return entities;
+}
+function unwrapToObjectType(type) {
+  if (isNonNullType(type))
+    return unwrapToObjectType(type.ofType);
+  if (isListType(type))
+    return unwrapToObjectType(type.ofType);
+  if (isObjectType(type))
+    return type;
+  return null;
+}
+function unwrapType(type) {
+  let isList = false;
+  let isNonNull = false;
+  let current = type;
+  if (isNonNullType(current)) {
+    isNonNull = true;
+    current = current.ofType;
+  }
+  if (isListType(current)) {
+    isList = true;
+    current = current.ofType;
+    if (isNonNullType(current)) {
+      current = current.ofType;
+    }
+  }
+  return { type: current, isList, isNonNull };
+}
+function generateFilterTypeCode(schema, typeName, entities) {
+  const typeMap = schema.getTypeMap();
+  const filterType = typeMap[`${typeName}Filters`];
+  if (!filterType || !isInputObjectType(filterType))
+    return "";
+  const lines = [];
+  const fields = filterType.getFields();
+  lines.push(`export type ${typeName}Filters = {`);
+  for (const [fieldName, field] of Object.entries(fields)) {
+    if (fieldName === "OR") {
+      lines.push(`  OR?: ${typeName}Filters[]`);
+      continue;
+    }
+    const entity = entities.get(uncapitalize(typeName));
+    const isRelation = entity?.relations[fieldName];
+    if (isRelation) {
+      const relType = capitalize(isRelation.entity);
+      if (isRelation.type === "one") {
+        lines.push(`  ${fieldName}?: ${relType}Filters`);
+      } else {
+        lines.push(`  ${fieldName}?: { some?: ${relType}Filters; every?: ${relType}Filters; none?: ${relType}Filters }`);
+      }
+      continue;
+    }
+    const filterInputType = field.type;
+    const unwrapped = isNonNullType(filterInputType) ? filterInputType.ofType : filterInputType;
+    if (isInputObjectType(unwrapped)) {
+      const opFields = unwrapped.getFields();
+      const columnType = inferColumnTsType(opFields);
+      lines.push(`  ${fieldName}?: {`);
+      lines.push(`    eq?: ${columnType} | null`);
+      lines.push(`    ne?: ${columnType} | null`);
+      lines.push(`    lt?: ${columnType} | null`);
+      lines.push(`    lte?: ${columnType} | null`);
+      lines.push(`    gt?: ${columnType} | null`);
+      lines.push(`    gte?: ${columnType} | null`);
+      lines.push(`    like?: string | null`);
+      lines.push(`    notLike?: string | null`);
+      lines.push(`    ilike?: string | null`);
+      lines.push(`    notIlike?: string | null`);
+      lines.push(`    inArray?: ${columnType}[] | null`);
+      lines.push(`    notInArray?: ${columnType}[] | null`);
+      lines.push(`    isNull?: boolean | null`);
+      lines.push(`    isNotNull?: boolean | null`);
+      lines.push(`    OR?: Array<Omit<${typeName}Filters['${fieldName}'], 'OR'>> | null`);
+      lines.push(`  }`);
+    }
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function inferColumnTsType(opFields) {
+  const eqField = opFields.eq;
+  if (!eqField)
+    return "unknown";
+  return graphqlTypeToTs(eqField.type);
+}
+function graphqlTypeToTs(type) {
+  if (isNonNullType(type))
+    return graphqlTypeToTs(type.ofType);
+  if (isListType(type))
+    return `${graphqlTypeToTs(type.ofType)}[]`;
+  if (isScalarType(type)) {
+    switch (type.name) {
+      case "String":
+        return "string";
+      case "Int":
+      case "Float":
+        return "number";
+      case "Boolean":
+        return "boolean";
+      case "JSON":
+        return "unknown";
+      default:
+        return "unknown";
+    }
+  }
+  if (isEnumType(type)) {
+    return type.getValues().map((v) => `'${v.value}'`).join(" | ");
+  }
+  return "unknown";
+}
+function generateInputTypeCode(schema, inputTypeName, exportName) {
+  const typeMap = schema.getTypeMap();
+  const inputType = typeMap[inputTypeName];
+  if (!inputType || !isInputObjectType(inputType))
+    return "";
+  const lines = [];
+  const fields = inputType.getFields();
+  lines.push(`export type ${exportName} = {`);
+  for (const [fieldName, field] of Object.entries(fields)) {
+    const isRequired = isNonNullType(field.type);
+    const tsType = graphqlTypeToTs(field.type);
+    const opt = isRequired ? "" : "?";
+    const nullUnion = isRequired ? "" : " | null";
+    lines.push(`  ${fieldName}${opt}: ${tsType}${nullUnion}`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function generateOrderByTypeCode(schema, typeName) {
+  const typeMap = schema.getTypeMap();
+  const orderByType = typeMap[`${typeName}OrderBy`];
+  if (!orderByType || !isInputObjectType(orderByType))
+    return "";
+  const fields = orderByType.getFields();
+  const fieldNames = Object.keys(fields);
+  const lines = [];
+  lines.push(`export type ${typeName}OrderBy = {`);
+  for (const name of fieldNames) {
+    lines.push(`  ${name}?: { direction: 'asc' | 'desc'; priority: number }`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function generateWireFormatType(entity, drizzleImportPath, typeNameOverrides) {
+  const drizzleTypeName = typeNameOverrides[entity.tableName] ?? capitalize(entity.tableName);
+  if (drizzleImportPath) {
+    return `export type ${entity.typeName}Wire = Omit<Drizzle${drizzleTypeName}, DateKeys<Drizzle${drizzleTypeName}>>
+  & { [K in DateKeys<Drizzle${drizzleTypeName}>]: string }`;
+  }
+  return `// Wire format for ${entity.tableName} (no Drizzle import configured)
+export type ${entity.typeName}Wire = Record<string, unknown>`;
+}
+function generateSDL(schema) {
+  return printSchema2(schema);
+}
+function generateTypes(schema, options) {
+  const entities = getEntitiesFromSchema(schema);
+  const drizzlePath = options?.drizzle?.importPath;
+  const typeOverrides = options?.drizzle?.typeNames ?? {};
+  const lines = [];
+  lines.push("// ─── Auto-generated by drizzle-graphql-pg codegen ────────");
+  lines.push("// Do not edit manually. Re-run the codegen script to update.");
+  lines.push("");
+  lines.push("// biome-ignore lint/suspicious/noExplicitAny: utility type for date key extraction");
+  lines.push("type DateKeys<T> = { [K in keyof T]: T[K] extends Date | null ? K : T[K] extends Date ? K : never }[keyof T]");
+  lines.push("");
+  if (drizzlePath) {
+    const imports = [];
+    for (const entity of entities.values()) {
+      const drizzleTypeName = typeOverrides[entity.tableName] ?? capitalize(entity.tableName);
+      imports.push(`  type ${drizzleTypeName} as Drizzle${drizzleTypeName}`);
+    }
+    lines.push(`import {`);
+    lines.push(imports.join(`,
+`));
+    lines.push(`} from '${drizzlePath}'`);
+    lines.push("");
+  }
+  lines.push("// ─── Wire Format Types ──────────────────────────────────");
+  lines.push("// Drizzle types with Date fields converted to string (GraphQL serialization)");
+  lines.push("");
+  for (const entity of entities.values()) {
+    lines.push(generateWireFormatType(entity, drizzlePath, typeOverrides));
+    lines.push("");
+  }
+  lines.push("// ─── Filter Types ──────────────────────────────────────");
+  lines.push("");
+  for (const entity of entities.values()) {
+    if (!entity.hasFilters)
+      continue;
+    const code = generateFilterTypeCode(schema, entity.typeName, entities);
+    if (code) {
+      lines.push(code);
+      lines.push("");
+    }
+  }
+  lines.push("// ─── Input Types ──────────────────────────────────────");
+  lines.push("");
+  for (const entity of entities.values()) {
+    if (entity.hasInsertInput) {
+      const code = generateInputTypeCode(schema, `${entity.typeName}InsertInput`, `${entity.typeName}InsertInput`);
+      if (code) {
+        lines.push(code);
+        lines.push("");
+      }
+    }
+    if (entity.hasUpdateInput) {
+      const code = generateInputTypeCode(schema, `${entity.typeName}UpdateInput`, `${entity.typeName}UpdateInput`);
+      if (code) {
+        lines.push(code);
+        lines.push("");
+      }
+    }
+  }
+  lines.push("// ─── OrderBy Types ──────────────────────────────────────");
+  lines.push("");
+  for (const entity of entities.values()) {
+    if (!entity.hasOrderBy)
+      continue;
+    const code = generateOrderByTypeCode(schema, entity.typeName);
+    if (code) {
+      lines.push(code);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+function generateEntityDefs(schema, options) {
+  const entities = getEntitiesFromSchema(schema);
+  const typeOverrides = options?.drizzle?.typeNames ?? {};
+  const lines = [];
+  lines.push("// ─── Auto-generated by drizzle-graphql-pg codegen ────────");
+  lines.push("// Do not edit manually. Re-run the codegen script to update.");
+  lines.push("");
+  lines.push("import type {");
+  const typeImports = [];
+  for (const entity of entities.values()) {
+    typeImports.push(`  ${entity.typeName}Wire`);
+    if (entity.hasFilters)
+      typeImports.push(`  ${entity.typeName}Filters`);
+    if (entity.hasInsertInput)
+      typeImports.push(`  ${entity.typeName}InsertInput`);
+    if (entity.hasUpdateInput)
+      typeImports.push(`  ${entity.typeName}UpdateInput`);
+    if (entity.hasOrderBy)
+      typeImports.push(`  ${entity.typeName}OrderBy`);
+  }
+  lines.push(typeImports.join(`,
+`));
+  lines.push("} from './types'");
+  lines.push("");
+  lines.push("export const schema = {");
+  for (const entity of entities.values()) {
+    lines.push(`  ${entity.tableName}: {`);
+    if (entity.queryName)
+      lines.push(`    queryName: '${entity.queryName}',`);
+    if (entity.queryListName)
+      lines.push(`    queryListName: '${entity.queryListName}',`);
+    if (entity.countName)
+      lines.push(`    countName: '${entity.countName}',`);
+    if (entity.insertName)
+      lines.push(`    insertName: '${entity.insertName}',`);
+    if (entity.insertSingleName)
+      lines.push(`    insertSingleName: '${entity.insertSingleName}',`);
+    if (entity.updateName)
+      lines.push(`    updateName: '${entity.updateName}',`);
+    if (entity.deleteName)
+      lines.push(`    deleteName: '${entity.deleteName}',`);
+    lines.push(`    fields: [${entity.fields.map((f) => `'${f}'`).join(", ")}],`);
+    lines.push(`    relations: {`);
+    for (const [relName, rel] of Object.entries(entity.relations)) {
+      lines.push(`      ${relName}: { entity: '${rel.entity}', type: '${rel.type}' },`);
+    }
+    lines.push(`    },`);
+    lines.push(`  },`);
+  }
+  lines.push("} as const");
+  lines.push("");
+  lines.push("export type EntityDefs = {");
+  for (const entity of entities.values()) {
+    lines.push(`  ${entity.tableName}: {`);
+    lines.push(`    fields: ${entity.typeName}Wire`);
+    lines.push(`    relations: {`);
+    for (const [relName, rel] of Object.entries(entity.relations)) {
+      lines.push(`      ${relName}: { entity: '${rel.entity}'; type: '${rel.type}' }`);
+    }
+    lines.push(`    }`);
+    if (entity.hasFilters)
+      lines.push(`    filters: ${entity.typeName}Filters`);
+    if (entity.hasInsertInput)
+      lines.push(`    insertInput: ${entity.typeName}InsertInput`);
+    if (entity.hasUpdateInput)
+      lines.push(`    updateInput: ${entity.typeName}UpdateInput`);
+    if (entity.hasOrderBy)
+      lines.push(`    orderBy: ${entity.typeName}OrderBy`);
+    lines.push(`  }`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("export type TableNameMap = {");
+  for (const entity of entities.values()) {
+    const drizzleTypeName = typeOverrides[entity.tableName] ?? capitalize(entity.tableName);
+    lines.push(`  ${drizzleTypeName}: '${entity.tableName}'`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/index.ts
+var buildSchema = (db, config) => {
+  const builder = new SchemaBuilder(db, config);
+  return builder.build();
+};
+var buildEntities = (db, config) => {
+  const builder = new SchemaBuilder(db, config);
+  return builder.buildEntities();
+};
+var buildSchemaFromDrizzle = (drizzleSchema, config) => {
+  const { tables, tableNamesMap } = extractTablesRelationalConfig(drizzleSchema, createTableRelationsHelpers2);
+  const schemaKeys = Object.keys(tables);
+  const findStub = {
+    findMany: () => Promise.resolve([]),
+    findFirst: () => Promise.resolve(null)
+  };
+  const query = Object.fromEntries(schemaKeys.map((name) => [name, findStub]));
+  const mockDb = {
+    _: { fullSchema: drizzleSchema, schema: tables, tableNamesMap },
+    query,
+    select: () => ({ from: () => ({ where: () => ({}) }) })
+  };
+  const builder = new SchemaBuilder(mockDb, config);
+  return builder.build();
+};
+export {
+  generateTypes,
+  generateSDL,
+  generateEntityDefs,
+  buildSchemaFromDrizzle,
+  buildSchema,
+  buildEntities,
+  SchemaBuilder,
+  GraphQLJSON
+};