@drizzle-graphql-suite/schema 0.8.2 → 0.9.0

package/index.js

@@ -1,2054 +1 @@
-// 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/permissions.ts
-var readOnly = () => ({
-  query: true,
-  insert: false,
-  update: false,
-  delete: false
-});
-var permissive = (id, tables) => ({
-  id,
-  mode: "permissive",
-  tables
-});
-var restricted = (id, tables) => ({
-  id,
-  mode: "restricted",
-  tables
-});
-function mergePermissionsIntoConfig(baseConfig, permissions, allTableNames) {
-  const excluded = [...baseConfig.tables?.exclude ?? []];
-  const tableConfig = {
-    ...baseConfig.tables?.config ?? {}
-  };
-  const mutationFilter = {};
-  for (const tableName of allTableNames) {
-    if (excluded.includes(tableName))
-      continue;
-    const access = resolveTableAccess(permissions, tableName);
-    if (access === false) {
-      excluded.push(tableName);
-      continue;
-    }
-    if (access === true) {
-      continue;
-    }
-    const defaultAllow = permissions.mode === "permissive";
-    const queryAllowed = access.query ?? defaultAllow;
-    const insertAllowed = access.insert ?? defaultAllow;
-    const updateAllowed = access.update ?? defaultAllow;
-    const deleteAllowed = access.delete ?? defaultAllow;
-    if (!queryAllowed && !insertAllowed && !updateAllowed && !deleteAllowed) {
-      excluded.push(tableName);
-      continue;
-    }
-    tableConfig[tableName] = {
-      ...tableConfig[tableName],
-      queries: queryAllowed
-    };
-    const anyMutation = insertAllowed || updateAllowed || deleteAllowed;
-    if (!anyMutation) {
-      tableConfig[tableName] = { ...tableConfig[tableName], mutations: false };
-    } else {
-      tableConfig[tableName] = { ...tableConfig[tableName], mutations: true };
-      if (!insertAllowed || !updateAllowed || !deleteAllowed) {
-        mutationFilter[tableName] = {
-          insert: insertAllowed,
-          update: updateAllowed,
-          delete: deleteAllowed
-        };
-      }
-    }
-  }
-  const config = {
-    ...baseConfig,
-    tables: {
-      exclude: excluded.length ? excluded : undefined,
-      config: Object.keys(tableConfig).length ? tableConfig : undefined
-    }
-  };
-  return { config, mutationFilter };
-}
-function resolveTableAccess(permissions, tableName) {
-  const override = permissions.tables?.[tableName];
-  if (permissions.mode === "permissive") {
-    if (override === undefined)
-      return true;
-    return override;
-  }
-  if (override === undefined)
-    return false;
-  return override;
-}
-function postFilterMutations(mutations, mutationFilter) {
-  for (const [tableName, flags] of Object.entries(mutationFilter)) {
-    const cap = capitalize(tableName);
-    if (!flags.insert) {
-      delete mutations[`insertInto${cap}`];
-      delete mutations[`insertInto${cap}Single`];
-    }
-    if (!flags.update) {
-      delete mutations[`update${cap}`];
-    }
-    if (!flags.delete) {
-      delete mutations[`deleteFrom${cap}`];
-    }
-  }
-}
-
-// src/schema-builder.ts
-class SchemaBuilder {
-  db;
-  tables;
-  relationMap;
-  relationalSchema;
-  tableNamesMap;
-  config;
-  hooks;
-  adapter;
-  suffixes;
-  limitRelationDepth;
-  limitSelfRelationDepth;
-  allTableNames;
-  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.allTableNames = Object.keys(this.tables);
-    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);
-    const cache = new Map;
-    const db = this.db;
-    const baseConfig = this.config;
-    const allTableNames = this.allTableNames;
-    const withPermissions = (permissions) => {
-      const cached = cache.get(permissions.id);
-      if (cached)
-        return cached;
-      const { config: mergedConfig, mutationFilter } = mergePermissionsIntoConfig(baseConfig, permissions, allTableNames);
-      const excludedSet = new Set(mergedConfig.tables?.exclude ?? []);
-      const hasAnyTable = allTableNames.some((t) => !excludedSet.has(t));
-      if (!hasAnyTable) {
-        const emptySchema = new GraphQLSchema({
-          query: new GraphQLObjectType2({
-            name: "Query",
-            fields: {
-              _empty: { type: GraphQLBoolean2 }
-            }
-          })
-        });
-        cache.set(permissions.id, emptySchema);
-        return emptySchema;
-      }
-      const permBuilder = new SchemaBuilder(db, mergedConfig);
-      const permEntities = permBuilder.buildEntities();
-      if (Object.keys(mutationFilter).length) {
-        postFilterMutations(permEntities.mutations, mutationFilter);
-      }
-      const permSchemaConfig = {
-        types: [...Object.values(permEntities.inputs), ...Object.values(permEntities.types)],
-        query: new GraphQLObjectType2({
-          name: "Query",
-          fields: Object.keys(permEntities.queries).length ? permEntities.queries : { _empty: { type: GraphQLBoolean2 } }
-        })
-      };
-      if (mergedConfig.mutations !== false && Object.keys(permEntities.mutations).length) {
-        permSchemaConfig.mutation = new GraphQLObjectType2({
-          name: "Mutation",
-          fields: permEntities.mutations
-        });
-      }
-      const permSchema = new GraphQLSchema(permSchemaConfig);
-      cache.set(permissions.id, permSchema);
-      return permSchema;
-    };
-    const clearPermissionCache = (id) => {
-      if (id)
-        cache.delete(id);
-      else
-        cache.clear();
-    };
-    return { schema, entities, withPermissions, clearPermissionCache };
-  }
-  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) {
-      const orVariants = [];
-      for (const variant of operators.OR) {
-        const extracted = this.extractColumnFilters(column, columnName, variant);
-        if (extracted)
-          orVariants.push(extracted);
-      }
-      const orClause = orVariants.length > 1 ? or(...orVariants) : orVariants.length === 1 ? orVariants[0] : undefined;
-      if (entries.length <= 1)
-        return orClause;
-      const { OR: _, ...rest } = operators;
-      const fieldClause = this.extractColumnFilters(column, columnName, rest);
-      if (!fieldClause)
-        return orClause;
-      if (!orClause)
-        return fieldClause;
-      return and(fieldClause, orClause);
-    }
-    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) {
-      const orVariants = [];
-      for (const variant of filters.OR) {
-        const extracted = this.extractAllFilters(table, tableName, variant);
-        if (extracted)
-          orVariants.push(extracted);
-      }
-      const orClause = orVariants.length > 1 ? or(...orVariants) : orVariants.length === 1 ? orVariants[0] : undefined;
-      if (columnEntries.length === 0 && relationEntries.length === 0)
-        return orClause;
-      const { OR: _, ...rest } = filters;
-      const fieldClause = this.extractAllFilters(table, tableName, rest);
-      if (!fieldClause)
-        return orClause;
-      if (!orClause)
-        return fieldClause;
-      return and(fieldClause, orClause);
-    }
-    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/row-security.ts
-function withRowSecurity(rules) {
-  const hooks = {};
-  for (const [tableName, rule] of Object.entries(rules)) {
-    const before = (ctx) => {
-      const whereClause = rule(ctx.context);
-      const existingWhere = ctx.args?.where;
-      const mergedWhere = existingWhere ? { ...existingWhere, ...whereClause } : whereClause;
-      return { args: { ...ctx.args, where: mergedWhere } };
-    };
-    const ops = ["query", "querySingle", "count", "update", "delete"];
-    const tableHooks = {};
-    for (const op of ops) {
-      tableHooks[op] = { before };
-    }
-    hooks[tableName] = tableHooks;
-  }
-  return hooks;
-}
-function mergeHooks(...configs) {
-  const result = {};
-  for (const config of configs) {
-    if (!config)
-      continue;
-    for (const [tableName, tableHooks] of Object.entries(config)) {
-      if (!result[tableName]) {
-        result[tableName] = {};
-      }
-      const existing = result[tableName];
-      for (const [op, hooks] of Object.entries(tableHooks)) {
-        if (!existing[op]) {
-          existing[op] = hooks;
-          continue;
-        }
-        const existingOp = existing[op];
-        if ("resolve" in hooks) {
-          existing[op] = hooks;
-          continue;
-        }
-        if ("resolve" in existingOp) {
-          existing[op] = hooks;
-          continue;
-        }
-        const merged = {};
-        if (hooks.before && existingOp.before) {
-          const first = existingOp.before;
-          const second = hooks.before;
-          merged.before = async (ctx) => {
-            const firstResult = await first(ctx);
-            const nextCtx = firstResult?.args ? { ...ctx, args: firstResult.args } : ctx;
-            const secondResult = await second(nextCtx);
-            return {
-              args: secondResult?.args ?? firstResult?.args ?? undefined,
-              data: secondResult?.data ?? firstResult?.data ?? undefined
-            };
-          };
-        } else {
-          merged.before = hooks.before ?? existingOp.before;
-        }
-        if (hooks.after && existingOp.after) {
-          const first = existingOp.after;
-          const second = hooks.after;
-          merged.after = async (ctx) => {
-            const firstResult = await first(ctx);
-            return second({ ...ctx, result: firstResult });
-          };
-        } else {
-          merged.after = hooks.after ?? existingOp.after;
-        }
-        existing[op] = merged;
-      }
-    }
-  }
-  return result;
-}
-
-// 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 {
-  withRowSecurity,
-  restricted,
-  readOnly,
-  permissive,
-  mergeHooks,
-  generateTypes,
-  generateSDL,
-  generateEntityDefs,
-  buildSchemaFromDrizzle,
-  buildSchema,
-  buildEntities,
-  SchemaBuilder,
-  GraphQLJSON
-};
+export * from '@graphql-suite/schema'