@vantreeseba/drizzle-graphql 7.4.0 → 7.6.0

package/dist/index.cjs

@@ -40,16 +40,21 @@ __export(index_exports, {
   createRelationResolverFactory: () => createRelationResolverFactory,
   defaultErrorMapper: () => defaultErrorMapper,
   drizzleExecutorKey: () => drizzleExecutorKey,
+  drizzleExtension: () => drizzleExtension,
   extractFilters: () => extractFilters,
   extractOrderBy: () => extractOrderBy,
   extractRelationJoinColumns: () => extractRelationJoinColumns,
+  identifyRows: () => identifyRows,
+  isDrizzleFieldExtension: () => isDrizzleFieldExtension,
+  resolveSelection: () => resolveSelection,
+  selectionToWith: () => selectionToWith,
   singularizeMapper: () => singularizeMapper
 });
 module.exports = __toCommonJS(index_exports);
-var import_drizzle_orm10 = require("drizzle-orm");
-var import_mysql_core3 = require("drizzle-orm/mysql-core");
-var import_pg_core3 = require("drizzle-orm/pg-core");
-var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
+var import_drizzle_orm11 = require("drizzle-orm");
+var import_mysql_core4 = require("drizzle-orm/mysql-core");
+var import_pg_core4 = require("drizzle-orm/pg-core");
+var import_sqlite_core4 = require("drizzle-orm/sqlite-core");
 var import_graphql11 = require("graphql");
 
 // src/util/builders/common.ts
@@ -598,6 +603,123 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
+// src/util/extensions.ts
+var drizzleExtension = (target) => {
+  const value = target?.extensions?.drizzle;
+  return value && typeof value === "object" ? value : void 0;
+};
+var isDrizzleFieldExtension = (value) => !!value && value.kind !== "type";
+var tableFieldExtensions = (table, primaryKey) => (meta) => ({
+  table,
+  primaryKey,
+  ...meta
+});
+var tableTypeExtension = (table, primaryKey) => ({
+  table,
+  kind: "type",
+  primaryKey
+});
+var relationFieldExtension = (params) => ({
+  table: params.targetTable,
+  kind: params.aggregate ? "aggregate" : "relation",
+  operation: params.aggregate ? "relationAggregate" : "relation",
+  // An aggregate over a to-many relation still resolves to a single aggregate object.
+  single: params.aggregate ? true : params.single,
+  targetArg: "where",
+  primaryKey: params.primaryKey,
+  relation: params.relation,
+  parentTable: params.parentTable
+});
+var keyFromValues = (entry, primaryKey) => {
+  if (!entry || typeof entry !== "object") {
+    return void 0;
+  }
+  const row = {};
+  for (const column of primaryKey) {
+    const value = entry[column];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    row[column] = value;
+  }
+  return row;
+};
+var keysFromWhere = (where, primaryKey) => {
+  const none = { rows: [], complete: false };
+  if (!where || typeof where !== "object" || Array.isArray(where)) {
+    return none;
+  }
+  const filters = where;
+  if (filters.OR || filters.AND || filters.NOT) {
+    return none;
+  }
+  if (primaryKey.length > 1) {
+    const row = {};
+    for (const column2 of primaryKey) {
+      const operators2 = filters[column2];
+      if (!operators2 || typeof operators2 !== "object" || operators2.eq === void 0) {
+        return none;
+      }
+      row[column2] = operators2.eq;
+    }
+    return { rows: [row], complete: Object.keys(filters).length === primaryKey.length };
+  }
+  const column = primaryKey[0];
+  if (!column) {
+    return none;
+  }
+  const operators = filters[column];
+  if (!operators || typeof operators !== "object") {
+    return none;
+  }
+  const exact = Object.keys(filters).length === 1 && Object.keys(operators).length === 1;
+  if (operators.eq !== void 0) {
+    return { rows: [{ [column]: operators.eq }], complete: exact };
+  }
+  if (Array.isArray(operators.inArray)) {
+    return { rows: operators.inArray.map((value) => ({ [column]: value })), complete: exact };
+  }
+  return none;
+};
+var identifyRows = (field, args) => {
+  const meta = drizzleExtension(field);
+  if (!isDrizzleFieldExtension(meta)) {
+    return void 0;
+  }
+  const { table, primaryKey, targetArg } = meta;
+  const empty = { table, primaryKey, rows: [], complete: false };
+  if (!primaryKey.length || !targetArg) {
+    return empty;
+  }
+  const target = args?.[targetArg];
+  if (targetArg === "values") {
+    const entries = Array.isArray(target) ? target : target === void 0 ? [] : [target];
+    const rows = entries.map((entry) => keyFromValues(entry, primaryKey));
+    return {
+      table,
+      primaryKey,
+      rows: rows.filter((row) => !!row),
+      // A row whose key the database generates is not identifiable before the write.
+      complete: entries.length > 0 && rows.every(Boolean)
+    };
+  }
+  if (targetArg === "updates") {
+    if (!Array.isArray(target)) {
+      return empty;
+    }
+    const perEntry = target.map(
+      (entry) => keysFromWhere(entry?.where, primaryKey)
+    );
+    return {
+      table,
+      primaryKey,
+      rows: perEntry.flatMap((entry) => entry.rows),
+      complete: target.length > 0 && perEntry.every((entry) => entry.complete)
+    };
+  }
+  return { table, primaryKey, ...keysFromWhere(target, primaryKey) };
+};
+
 // src/util/builders/field-updates.ts
 var import_drizzle_orm3 = require("drizzle-orm");
 var import_graphql4 = require("graphql");
@@ -1022,7 +1144,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits, scopes) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -1083,10 +1205,16 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
     const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
       const executor = resolveExecutor(db, context);
       const uniqueIds = [...new Set(parentIds)];
-      let whereCondition = (0, import_drizzle_orm4.and)(
-        (0, import_drizzle_orm4.inArray)(foreignCol, uniqueIds),
-        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0,
-        cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0
+      const scope = resolveScope(scopes, context, filterCtx);
+      let whereCondition = withScope(
+        scope,
+        targetTableName,
+        targetTable,
+        (0, import_drizzle_orm4.and)(
+          (0, import_drizzle_orm4.inArray)(foreignCol, uniqueIds),
+          whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0,
+          cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0
+        )
       );
       if (distinct) {
         const keys = await selectDistinctKeys({
@@ -1144,6 +1272,14 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
     return loader.load(localValue);
   };
 };
+var relationExtensionFor = (relEntry, parentTable, relationName, isOne, aggregate) => relationFieldExtension({
+  targetTable: relEntry.targetTableName,
+  parentTable,
+  relation: relationName,
+  single: isOne,
+  primaryKey: relEntry.targetPkNames ?? [],
+  aggregate
+});
 var columnDocs = (docs, column, tableName, columnName) => {
   const description = docs.describeColumn?.(column, { tableName, columnName });
   const deprecationReason = docs.deprecateColumn?.(column, { tableName, columnName });
@@ -1823,7 +1959,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     const shell = new import_graphql5.GraphQLObjectType({
       name: typeName,
       description: cacheCtx.docs.describeTable?.(tableName),
-      fields: () => ({ ...tableFields, ...container.fields })
+      fields: () => ({ ...tableFields, ...container.fields }),
+      extensions: { drizzle: tableTypeExtension(tableName, cacheCtx.primaryKeyOf?.(tableName) ?? []) }
     });
     cacheCtx.objectTypeCache.set(tableName, shell);
   }
@@ -1865,7 +2002,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         relType = new import_graphql5.GraphQLObjectType({
           name: resolveTypeName(targetTableName, typeNameMapper),
           description: cacheCtx.docs.describeTable?.(targetTableName),
-          fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
+          fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields }),
+          extensions: {
+            drizzle: tableTypeExtension(targetTableName, cacheCtx.primaryKeyOf?.(targetTableName) ?? [])
+          }
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
@@ -1882,7 +2022,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
               where: { type: relSelectData.filters }
             },
             resolve,
-            ...relationDocs
+            ...relationDocs,
+            extensions: { drizzle: relationExtensionFor(relEntry, tableName, relationName, true) }
           }
         ]);
         continue;
@@ -1905,11 +2046,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           },
           resolve,
           ...relationDocs,
-          ...cacheCtx.complexity ? {
-            extensions: {
-              complexity: listFieldComplexity(cacheCtx.complexity, cacheCtx.limits?.(targetTableName))
-            }
-          } : {}
+          extensions: {
+            drizzle: relationExtensionFor(relEntry, tableName, relationName, false),
+            ...cacheCtx.complexity ? { complexity: listFieldComplexity(cacheCtx.complexity, cacheCtx.limits?.(targetTableName)) } : {}
+          }
         }
       ]);
       const aggregateFieldName = `${relationName}Aggregate`;
@@ -1928,7 +2068,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
                 where: { type: relSelectData.filters }
               },
               resolve: relationAggregate.resolve,
-              ...cacheCtx.complexity ? { extensions: { complexity: aggregateFieldComplexity(cacheCtx.complexity) } } : {}
+              extensions: {
+                drizzle: relationExtensionFor(relEntry, tableName, relationName, isOne, true),
+                ...cacheCtx.complexity ? { complexity: aggregateFieldComplexity(cacheCtx.complexity) } : {}
+              }
             }
           ]);
         }
@@ -1977,9 +2120,11 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const table = tables[tableName];
   const columns = visibleColumns(table);
   const columnEntries = Object.entries(columns);
+  const contextColumns = cacheCtx.contextValuesOf?.(tableName);
+  const writableEntries = contextColumns ? columnEntries.filter(([columnName]) => !(columnName in contextColumns)) : columnEntries;
   const relaxedColumns = nestedWrites?.relaxedColumns(tableName);
   const insertFields = Object.fromEntries(
-    columnEntries.map(([columnName, column]) => {
+    writableEntries.map(([columnName, column]) => {
       const converted = drizzleColumnToGraphQLType(
         column,
         columnName,
@@ -1995,7 +2140,7 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     })
   );
   const updateFields = Object.fromEntries(
-    columnEntries.map(([columnName, column]) => {
+    writableEntries.map(([columnName, column]) => {
       const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
       const operations = cacheCtx.featureOf(tableName).fieldUpdateOperations ? fieldUpdateInputType(column, columnName, tableName) : void 0;
       const field = operations ? { ...converted, type: operations } : converted;
@@ -2014,7 +2159,8 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql5.GraphQLObjectType({
     name: resolveTypeName(tableName, typeNameMapper),
     description: cacheCtx.docs.describeTable?.(tableName),
-    fields: { ...tableFields, ...relationFields }
+    fields: { ...tableFields, ...relationFields },
+    extensions: { drizzle: tableTypeExtension(tableName, cacheCtx.primaryKeyOf?.(tableName) ?? []) }
   });
   const selectArrOutput = new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
@@ -2517,7 +2663,69 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
   }
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
 };
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx, limits) => {
+var resolveScope = (scopes, context, filterCtx) => {
+  if (!scopes) {
+    return void 0;
+  }
+  return {
+    has: (tableName) => !!scopes(tableName),
+    on: (tableName, table) => {
+      const hook = scopes(tableName);
+      if (!hook) {
+        return void 0;
+      }
+      const predicate = hook(context, table);
+      if (predicate === void 0 || predicate === null) {
+        return void 0;
+      }
+      if ((0, import_drizzle_orm4.is)(predicate, import_drizzle_orm4.SQL)) {
+        return predicate;
+      }
+      if (typeof predicate !== "object") {
+        throw new import_graphql5.GraphQLError(
+          `Drizzle-GraphQL Error: the scope for '${tableName}' returned a ${typeof predicate}. A scope returns a filter object, a Drizzle SQL expression, or undefined.`
+        );
+      }
+      return extractFilters(table, tableName, predicate, relationFilterCtx(filterCtx, tableName));
+    }
+  };
+};
+var withScope = (scope, tableName, table, condition) => {
+  const predicate = scope?.on(tableName, table);
+  return predicate ? (0, import_drizzle_orm4.and)(condition, predicate) : condition;
+};
+var bindPolicies = (policies, filterCtx) => policies?.scope || policies?.contextValues ? {
+  scope: policies.scope ? (context) => resolveScope(policies.scope, context, filterCtx) : void 0,
+  contextValues: policies.contextValues
+} : void 0;
+var applyContextValues = (values, hooks, context) => {
+  if (!hooks) {
+    return values;
+  }
+  for (const [columnName, hook] of Object.entries(hooks)) {
+    values[columnName] = hook(context);
+  }
+  return values;
+};
+var applyContextValuesAll = (rows, hooks, context) => {
+  if (!hooks) {
+    return rows;
+  }
+  for (const row of rows) {
+    applyContextValues(row, hooks, context);
+  }
+  return rows;
+};
+var stripContextValues = (values, hooks) => {
+  if (!hooks) {
+    return values;
+  }
+  for (const columnName of Object.keys(hooks)) {
+    delete values[columnName];
+  }
+  return values;
+};
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx, limits, scope) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -2563,8 +2771,13 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const offset = relationArgs?.offset ?? void 0;
     const limit = (0, import_drizzle_orm4.is)(relEntry.relation, import_drizzle_orm4.One) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), `${tableName}.${relName}`);
     const relWhere = relationArgs?.where;
-    thisRecord.where = relWhere ? {
-      RAW: (aliasedTable2) => extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName))
+    thisRecord.where = relWhere || scope?.has(targetTableName) ? {
+      RAW: (aliasedTable2) => withScope(
+        scope,
+        targetTableName,
+        aliasedTable2,
+        relWhere ? extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName)) : void 0
+      )
     } : void 0;
     const hasPagination = offset != null || limit != null;
     const pkNames = targetPkNames ?? [];
@@ -2580,14 +2793,15 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
       typeNameMapper,
       false,
       filterCtx,
-      limits
+      limits,
+      scope
     ) : void 0;
     thisRecord.with = relWith;
     args[relName] = thisRecord;
   }
   return args;
 };
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx, limits) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx, limits, scope) => {
   if (!info) {
     return void 0;
   }
@@ -2600,7 +2814,8 @@ var extractRelationsParams = (relationMap, tables, tableName, info, typeName, ty
     typeNameMapper,
     true,
     filterCtx,
-    limits
+    limits,
+    scope
   );
 };
 var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
@@ -3010,7 +3225,8 @@ var prepareMutationRelationColumns = (params) => {
     typeName,
     typeNameMapper,
     void 0,
-    params.limits
+    params.limits,
+    params.scope
   ) : void 0;
   const hasRelations = !!(withParams && Object.keys(withParams).length);
   const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
@@ -3244,7 +3460,8 @@ var runRelationalSelect = async (opts) => {
     single,
     filterCtx,
     pkNames,
-    after
+    after,
+    scope
   } = opts;
   const distinct = opts.distinct?.length ? opts.distinct : void 0;
   const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
@@ -3276,7 +3493,12 @@ var runRelationalSelect = async (opts) => {
       tableName,
       distinct,
       pkNames: pkNames ?? [],
-      where: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+      where: withScope(
+        scope,
+        tableName,
+        table,
+        where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+      ),
       orderBy,
       limit: single ? 1 : opts.limit,
       offset
@@ -3303,15 +3525,23 @@ var runRelationalSelect = async (opts) => {
       // exactly the ordering the cursor encodes and the keyset predicate compares against.
       (aliasedTable2) => cursorOrderExprs(aliasedTable2, cursorEntries)
     ) : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName), where) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
-    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where || cursorValues ? {
-      RAW: (aliasedTable2) => (0, import_drizzle_orm4.and)(
-        where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
-        cursorValues ? buildCursorCondition(
-          aliasedTable2,
-          cursorEntries,
-          cursorValues,
-          opts.nullOrdering ?? "nulls-smallest"
-        ) : void 0
+    where: distinctKeys ? (
+      // The distinct pass already ran inside the scope, so the keys it picked are in it.
+      { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) }
+    ) : where || cursorValues || scope?.has(tableName) ? {
+      RAW: (aliasedTable2) => withScope(
+        scope,
+        tableName,
+        aliasedTable2,
+        (0, import_drizzle_orm4.and)(
+          where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+          cursorValues ? buildCursorCondition(
+            aliasedTable2,
+            cursorEntries,
+            cursorValues,
+            opts.nullOrdering ?? "nulls-smallest"
+          ) : void 0
+        )
       )
     } : void 0,
     with: relationMap[tableName] ? extractRelationsParams(
@@ -3322,7 +3552,8 @@ var runRelationalSelect = async (opts) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      opts.limits
+      opts.limits,
+      scope
     ) : void 0
   };
   if (single) {
@@ -3627,7 +3858,7 @@ var assembleAggregateRow = (row, request, target) => {
   }
   return result;
 };
-var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx) => {
+var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx, scopes) => {
   const target = aggregateTarget(table, tableName, typeName);
   const queryArgs = {
     where: { type: filterArgs }
@@ -3641,8 +3872,14 @@ var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs,
           return {};
         }
         let query = resolveExecutor(db, context).select(request.selection).from(table);
-        if (args.where) {
-          query = query.where(extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)));
+        const where = withScope(
+          resolveScope(scopes, context, filterCtx),
+          tableName,
+          table,
+          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0
+        );
+        if (where) {
+          query = query.where(where);
         }
         const rows = await query;
         return assembleAggregateRow(rows[0] ?? {}, request, target);
@@ -3654,7 +3891,7 @@ var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs,
   };
 };
 var GROUP_KEY = "__dgql_group_key";
-var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx) => {
+var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) => {
   return ({ tableName, relationName, relEntry }) => {
     const parentTable = tables[tableName];
     const targetTableName = relEntry.targetTableName;
@@ -3689,9 +3926,14 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
         const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
           const executor = resolveExecutor(db, context);
           const uniqueIds = [...new Set(parentIds)];
-          const whereCondition = (0, import_drizzle_orm5.and)(
-            (0, import_drizzle_orm5.inArray)(foreignCol, uniqueIds),
-            whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+          const whereCondition = withScope(
+            resolveScope(scopes, context, filterCtx),
+            targetTableName,
+            targetTable,
+            (0, import_drizzle_orm5.and)(
+              (0, import_drizzle_orm5.inArray)(foreignCol, uniqueIds),
+              whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+            )
           );
           const rows = await executor.select({ [GROUP_KEY]: foreignCol, ...request.selection }).from(targetTable).where(whereCondition).groupBy(foreignCol);
           const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
@@ -3824,7 +4066,7 @@ var buildHavingCondition = (having, columns) => {
   }
   return conditions.length ? (0, import_drizzle_orm5.and)(...conditions) : void 0;
 };
-var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx) => {
+var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx, scopes) => {
   const target = aggregateTarget(table, tableName, typeName);
   const groupable = groupableColumns(table, tableName);
   const columns = (0, import_drizzle_orm5.getColumns)(table);
@@ -3858,8 +4100,14 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
           ...request.selection
         };
         let query = resolveExecutor(db, context).select(selection).from(table);
-        if (args.where) {
-          query = query.where(extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)));
+        const where = withScope(
+          resolveScope(scopes, context, filterCtx),
+          tableName,
+          table,
+          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0
+        );
+        if (where) {
+          query = query.where(where);
         }
         query = query.groupBy(...keyColumns.map(([, column]) => column));
         const havingCondition = buildHavingCondition(args.having, columns);
@@ -3885,7 +4133,7 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
 };
 
 // src/util/builders/mysql.ts
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
+var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits, policies) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -3920,6 +4168,7 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
           single: false,
           filterCtx,
           limits,
+          scope: policies?.scope?.(context),
           pkNames,
           db: executor,
           // MySQL sorts NULLs as the smallest values (first in ASC).
@@ -3932,7 +4181,7 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
     args: queryArgs
   };
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
+var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -3961,6 +4210,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
           single: true,
           filterCtx,
           limits,
+          scope: policies?.scope?.(context),
           pkNames,
           db: executor
         });
@@ -3971,7 +4221,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
+var generateInsertArray = (db, tableName, table, baseType, fieldName, txCtx, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
@@ -3982,7 +4232,11 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLArrayInput(args.values, table);
+          const input = applyContextValuesAll(
+            remapFromGraphQLArrayInput(args.values, table),
+            policies?.contextValues?.(tableName),
+            context
+          );
           if (!input.length) {
             throw new import_graphql7.GraphQLError("No values were provided!");
           }
@@ -3996,7 +4250,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
     args: queryArgs
   };
 };
-var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
+var generateInsertSingle = (db, tableName, table, baseType, fieldName, txCtx, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql7.GraphQLNonNull(baseType)
@@ -4007,7 +4261,11 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) =
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLSingleInput(args.values, table);
+          const input = applyContextValues(
+            remapFromGraphQLSingleInput(args.values, table),
+            policies?.contextValues?.(tableName),
+            context
+          );
           await executor.insert(table).values(input);
           return { isSuccess: true };
         });
@@ -4018,7 +4276,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) =
     args: queryArgs
   };
 };
-var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
+var generateUpsert = (db, tableName, table, baseType, onConflictType, fieldName, single, txCtx, policies) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
@@ -4034,7 +4292,11 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          const input = applyContextValuesAll(
+            single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table),
+            policies?.contextValues?.(tableName),
+            context
+          );
           if (!input.length) {
             throw new import_graphql7.GraphQLError("No values were provided!");
           }
@@ -4061,7 +4323,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies) => {
   const queryArgs = {
     set: {
       type: new import_graphql7.GraphQLNonNull(setArgs)
@@ -4076,12 +4338,21 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where, set } = args;
-          const input = remapUpdateInput(set, table, tableName);
+          const scope = policies?.scope?.(context);
+          const input = stripContextValues(
+            remapUpdateInput(set, table, tableName),
+            policies?.contextValues?.(tableName)
+          );
           if (!Object.keys(input).length) {
             throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -4099,7 +4370,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
     args: queryArgs
   };
 };
-var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
+var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx, policies) => {
   const queryArgs = {
     updates: {
       type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
@@ -4114,14 +4385,21 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
           if (!updates.length) {
             throw new import_graphql7.GraphQLError("No updates were provided!");
           }
+          const scope = policies?.scope?.(context);
+          const contextColumns = policies?.contextValues?.(tableName);
           const entries = updates.map(({ where, set }) => {
-            const input = remapUpdateInput(set, table, tableName);
+            const input = stripContextValues(remapUpdateInput(set, table, tableName), contextColumns);
             if (!Object.keys(input).length) {
               throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
-              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              filters: withScope(
+                scope,
+                tableName,
+                table,
+                where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              )
             };
           });
           await executor.transaction(async (tx) => {
@@ -4142,7 +4420,7 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
@@ -4154,8 +4432,14 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requi
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where } = args;
+          const scope = policies?.scope?.(context);
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -4203,12 +4487,16 @@ var generateSchemaData = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
+  const scopes = options.policies?.scope;
+  const contextValuesOf = options.policies?.contextValues;
+  const policies = bindPolicies(options.policies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-smallest",
     filterCtx,
-    limits
+    limits,
+    scopes
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -4225,9 +4513,11 @@ var generateSchemaData = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? mysqlPrimaryKeyPropNames(tables[name]) : [],
+    contextValuesOf,
     featureOf
   };
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -4264,6 +4554,7 @@ var generateSchemaData = (db, schema, relations, options) => {
   }
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
     const {
@@ -4296,7 +4587,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       tableFeatures.distinct,
-      limits
+      limits,
+      policies
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
@@ -4309,7 +4601,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      limits
+      limits,
+      policies
     );
     const insertArrGenerated = tableFeatures.insert ? generateInsertArray(
       db,
@@ -4317,7 +4610,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       schema[tableName],
       insertInput,
       createArrayFieldName,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(
       db,
@@ -4325,7 +4619,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       schema[tableName],
       insertInput,
       createSingleFieldName,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
@@ -4336,21 +4631,25 @@ var generateSchemaData = (db, schema, relations, options) => {
     }) : void 0;
     const upsertArrGenerated = onConflictInput ? generateUpsert(
       db,
+      tableName,
       schema[tableName],
       insertInput,
       onConflictInput,
       upsertArrayFieldName,
       false,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert(
       db,
+      tableName,
       schema[tableName],
       insertInput,
       onConflictInput,
       upsertSingleFieldName,
       true,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateGenerated = tableFeatures.update ? generateUpdate(
       db,
@@ -4362,7 +4661,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       false,
       tableFeatures.requireWhere,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateSingleGenerated = tableFeatures.update ? generateUpdate(
       db,
@@ -4374,7 +4674,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       true,
       tableFeatures.requireWhere,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany(
@@ -4384,7 +4685,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateManyInput,
       updateManyFieldName,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const deleteGenerated = tableFeatures.delete ? generateDelete(
       db,
@@ -4395,7 +4697,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       false,
       tableFeatures.requireWhere,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const deleteSingleGenerated = tableFeatures.delete ? generateDelete(
       db,
@@ -4406,7 +4709,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       true,
       tableFeatures.requireWhere,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
@@ -4439,7 +4743,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeName,
       aggregateFieldName,
       tableFilters,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -4453,25 +4758,35 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       groupByEnum,
       havingInput,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql7.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -4479,25 +4794,30 @@ var generateSchemaData = (db, schema, relations, options) => {
         type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
-    for (const generated of [
-      insertArrGenerated,
-      insertSingleGenerated,
-      upsertArrGenerated,
-      upsertSingleGenerated,
-      updateGenerated,
-      updateManyGenerated,
-      updateSingleGenerated,
-      deleteGenerated,
-      deleteSingleGenerated
-    ]) {
+    const generatedMutations = [
+      [insertArrGenerated, { operation: "insert", single: false, targetArg: "values" }],
+      [insertSingleGenerated, { operation: "insert", single: true, targetArg: "values" }],
+      [upsertArrGenerated, { operation: "upsert", single: false, targetArg: "values" }],
+      [upsertSingleGenerated, { operation: "upsert", single: true, targetArg: "values" }],
+      [updateGenerated, { operation: "update", single: false, targetArg: "where" }],
+      [updateManyGenerated, { operation: "updateMany", single: false, targetArg: "updates" }],
+      [updateSingleGenerated, { operation: "update", single: true, targetArg: "where" }],
+      [deleteGenerated, { operation: "delete", single: false, targetArg: "where" }],
+      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where" }]
+    ];
+    for (const [generated, meta] of generatedMutations) {
       if (generated) {
         mutations[generated.name] = {
           type: mutationReturnType,
           args: generated.args,
-          resolve: generated.resolver
+          resolve: generated.resolver,
+          extensions: { drizzle: drizzleMeta({ kind: "mutation", ...meta }) }
         };
       }
     }
@@ -4667,8 +4987,9 @@ var createNestedWriteTypes = (params) => {
       return cached;
     }
     const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
+    const contextColumns = cacheCtx.contextValuesOf?.(plan.targetTableName);
     const fields = Object.fromEntries(
-      Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+      Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted && !contextColumns?.[columnName]).map(([columnName, column]) => [
         columnName,
         drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
       ])
@@ -4767,8 +5088,8 @@ var createNestedWriteTypes = (params) => {
 var mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
 var asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
 var createNestedWriteRuntime = (params) => {
-  const { plans, filterCtx } = params;
-  const conditionOf = (plan, filter, operation) => {
+  const { plans, filterCtx, scopes, contextValues } = params;
+  const conditionOf = (plan, filter, operation, scope) => {
     const condition = extractFilters(
       plan.targetTable,
       plan.targetTableName,
@@ -4780,7 +5101,7 @@ var createNestedWriteRuntime = (params) => {
         `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`
       );
     }
-    return condition;
+    return withScope(scope, plan.targetTableName, plan.targetTable, condition);
   };
   const assertSingleOperation = (plan, op) => {
     const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
@@ -4790,7 +5111,7 @@ var createNestedWriteRuntime = (params) => {
       );
     }
   };
-  const detachAll = async (executor, plan, key) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm7.eq)(plan.foreignCol, key));
+  const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, (0, import_drizzle_orm7.eq)(plan.foreignCol, key)));
   return {
     enabled: (tableName) => !!plans[tableName],
     split: (tableName, values) => {
@@ -4824,12 +5145,13 @@ var createNestedWriteRuntime = (params) => {
       }
       return columns;
     },
-    applyParentSide: async (executor, tableName, ops) => {
+    applyParentSide: async (executor, tableName, ops, context) => {
       const tablePlans = plans[tableName];
       const patch = {};
       if (!tablePlans) {
         return patch;
       }
+      const scope = resolveScope(scopes, context, filterCtx);
       for (const [relationName, op] of Object.entries(ops)) {
         const plan = tablePlans[relationName];
         if (!plan || plan.fkSide !== "parent") {
@@ -4837,7 +5159,11 @@ var createNestedWriteRuntime = (params) => {
         }
         assertSingleOperation(plan, op);
         if (op["create"] !== void 0) {
-          const values = remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable);
+          const values = applyContextValues(
+            remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable),
+            contextValues?.(plan.targetTableName),
+            context
+          );
           const inserted = await executor.insert(plan.targetTable).values(values).returning();
           const created = inserted[0];
           if (!created) {
@@ -4847,7 +5173,7 @@ var createNestedWriteRuntime = (params) => {
           }
           patch[plan.localColPropName] = created[plan.foreignColPropName];
         } else if (op["connect"] !== void 0) {
-          const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect"));
+          const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
           if (rows.length !== 1) {
             throw new import_graphql8.GraphQLError(
               `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`
@@ -4860,11 +5186,12 @@ var createNestedWriteRuntime = (params) => {
       }
       return patch;
     },
-    applyChildSide: async (executor, tableName, ops, parentRows) => {
+    applyChildSide: async (executor, tableName, ops, parentRows, context) => {
       const tablePlans = plans[tableName];
       if (!tablePlans) {
         return;
       }
+      const scope = resolveScope(scopes, context, filterCtx);
       for (const [relationName, op] of Object.entries(ops)) {
         const plan = tablePlans[relationName];
         if (!plan || plan.fkSide !== "child") {
@@ -4881,34 +5208,38 @@ var createNestedWriteRuntime = (params) => {
             );
           }
           if (op["set"] !== void 0) {
-            await detachAll(executor, plan, key);
+            await detachAll(executor, plan, key, scope);
             for (const filter of asArray(op["set"])) {
-              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set"));
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope));
             }
           }
           if (op["disconnect"] !== void 0) {
             if (plan.isOne) {
               if (op["disconnect"] === true) {
-                await detachAll(executor, plan, key);
+                await detachAll(executor, plan, key, scope);
               }
             } else {
               for (const filter of asArray(op["disconnect"])) {
-                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(plan.foreignCol, key), conditionOf(plan, filter, "disconnect")));
+                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope)));
               }
             }
           }
           const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
           if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) {
-            await detachAll(executor, plan, key);
+            await detachAll(executor, plan, key, scope);
           }
           if (op["connect"] !== void 0) {
             for (const filter of asArray(op["connect"])) {
-              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect"));
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope));
             }
           }
           if (op["create"] !== void 0) {
             const rows = asArray(op["create"]).map((row) => ({
-              ...remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
+              ...applyContextValues(
+                remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
+                contextValues?.(plan.targetTableName),
+                context
+              ),
               [plan.foreignColPropName]: key
             }));
             if (rows.length) {
@@ -4921,30 +5252,30 @@ var createNestedWriteRuntime = (params) => {
   };
 };
 var writeWithNestedOps = async (params) => {
-  const { executor, runtime, tableName, entries, remapValues, write } = params;
+  const { executor, runtime, tableName, entries, remapValues, write, context } = params;
   return executor.transaction(async (tx) => {
     const rows = [];
     for (const entry of entries) {
-      const patch = await runtime.applyParentSide(tx, tableName, entry.ops);
+      const patch = await runtime.applyParentSide(tx, tableName, entry.ops, context);
       const written = await write(tx, { ...remapValues(entry.columns), ...patch });
-      await runtime.applyChildSide(tx, tableName, entry.ops, written);
+      await runtime.applyChildSide(tx, tableName, entry.ops, written, context);
       rows.push(...written);
     }
     return rows;
   });
 };
 var updateWithNestedOps = async (params) => {
-  const { executor, runtime, tableName, columns, ops, remapValues, write } = params;
+  const { executor, runtime, tableName, columns, ops, remapValues, write, context } = params;
   return executor.transaction(async (tx) => {
-    const patch = await runtime.applyParentSide(tx, tableName, ops);
+    const patch = await runtime.applyParentSide(tx, tableName, ops, context);
     const rows = await write(tx, { ...remapValues(columns), ...patch });
-    await runtime.applyChildSide(tx, tableName, ops, rows);
+    await runtime.applyChildSide(tx, tableName, ops, rows, context);
     return rows;
   });
 };
 
 // src/util/builders/pg.ts
-var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
+var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits, policies) => {
   const queryBase = db.query[tableName];
   const table = tables[tableName];
   const limitPolicy = limits?.(tableName);
@@ -4960,6 +5291,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
       try {
         const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
         const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        const scope = policies?.scope?.(context);
         const limit = applyLimitPolicy(args.limit, limitPolicy, fieldName);
         if (requestQueryBase) {
           return await runRelationalSelect({
@@ -4978,6 +5310,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             limits,
             pkNames,
             db: executor,
+            scope,
             // PostgreSQL sorts NULLs as the largest values (last in ASC).
             nullOrdering: "nulls-largest"
           });
@@ -5016,7 +5349,12 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
           }
         }
         const cursorCondition = after != null && cursorEntries ? buildCursorCondition(table, cursorEntries, decodeCursor(after, cursorEntries), "nulls-largest") : void 0;
-        const baseWhereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        const baseWhereSql = withScope(
+          scope,
+          tableName,
+          table,
+          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+        );
         const whereSql = cursorCondition ? (0, import_drizzle_orm8.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
@@ -5071,7 +5409,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies) => {
   const queryBase = db.query[tableName];
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
@@ -5082,6 +5420,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
       try {
         const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
         const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        const scope = policies?.scope?.(context);
         if (requestQueryBase) {
           return await runRelationalSelect({
             queryBase: requestQueryBase,
@@ -5097,7 +5436,8 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
             filterCtx,
             limits,
             pkNames,
-            db: executor
+            db: executor,
+            scope
           });
         }
         const { offset, orderBy, where } = args;
@@ -5107,8 +5447,14 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
           { tableName, relationMap, tables }
         );
         let q = executor.select(selectedColumnsSql).from(table);
-        if (where) {
-          q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
+        const whereSql = withScope(
+          scope,
+          tableName,
+          table,
+          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+        );
+        if (whereSql) {
+          q = q.where(whereSql);
         }
         if (orderBy) {
           q = q.orderBy(...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName), where));
@@ -5129,7 +5475,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_pg_core2.getTableConfig);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
@@ -5146,7 +5492,13 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
           }
           const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntries ? [] : applyContextValuesAll(
+            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -5159,7 +5511,8 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -5174,8 +5527,9 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
             runtime: nested,
             tableName,
             entries: nestedEntries,
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: (tx, values) => runInsert(tx, [values])
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: (tx, values) => runInsert(tx, [values]),
+            context
           }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
@@ -5187,7 +5541,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql9.GraphQLNonNull(baseType)
@@ -5201,7 +5555,13 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
           const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntry ? {} : applyContextValues(
+            remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -5214,7 +5574,8 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -5229,8 +5590,9 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             runtime: nested,
             tableName,
             entries: [nestedEntry],
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: runInsert
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: runInsert,
+            context
           }) : await runInsert(executor, input);
           if (!result[0]) {
             if (!conflictDoNothing) {
@@ -5248,7 +5610,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql9.GraphQLNonNull(baseType) : new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
@@ -5270,7 +5632,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
           }
           const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntries ? [] : applyContextValuesAll(
+            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -5281,7 +5649,8 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runUpsert = async (target, values) => {
@@ -5296,7 +5665,8 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
               buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
             });
             let query = target.insert(table).values(values).returning(returning);
-            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            const setWhere = withScope(scope, tableName, table, plan.setWhere);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
             return await query;
           };
           const result = nestedEntries ? await writeWithNestedOps({
@@ -5304,8 +5674,9 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
             runtime: nested,
             tableName,
             entries: nestedEntries,
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: (tx, values) => runUpsert(tx, [values])
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: (tx, values) => runUpsert(tx, [values]),
+            context
           }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
@@ -5320,7 +5691,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     set: {
       type: new import_graphql9.GraphQLNonNull(setArgs)
@@ -5336,6 +5707,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where, set } = args;
+          const scope = policies?.scope?.(context);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -5348,16 +5720,25 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+          const input = stripContextValues(
+            remapUpdateInput(entry ? entry.columns : set, table, tableName),
+            policies?.contextValues?.(tableName)
+          );
           if (!Object.keys(input).length && !nestedOps) {
             throw new import_graphql9.GraphQLError("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -5377,7 +5758,8 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             columns: input,
             ops: nestedOps,
             remapValues: (values) => values,
-            write: runUpdate
+            write: runUpdate,
+            context
           }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
             throw new import_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
@@ -5395,7 +5777,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     updates: {
       type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(updateManyInput)))
@@ -5411,6 +5793,8 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
           if (!updates.length) {
             throw new import_graphql9.GraphQLError("No updates were provided!");
           }
+          const scope = policies?.scope?.(context);
+          const contextColumns = policies?.contextValues?.(tableName);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -5423,19 +5807,28 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
+            const input = stripContextValues(
+              remapUpdateInput(split ? split.columns : set, table, tableName),
+              contextColumns
+            );
             if (!Object.keys(input).length && !ops) {
               throw new import_graphql9.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
               ops,
-              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              filters: withScope(
+                scope,
+                tableName,
+                table,
+                where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              )
             };
           });
           const returning = entries.some((entry) => entry.ops) ? nested.withJoinColumns(
@@ -5449,7 +5842,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
           const perEntry = await executor.transaction(async (tx) => {
             const results = [];
             for (const entry of entries) {
-              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
               const writes = Object.keys(values).length > 0;
               let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
               if (entry.filters) {
@@ -5457,7 +5850,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
               }
               const rows = await (writes ? query.returning(returning) : query);
               if (entry.ops) {
-                await nested.applyChildSide(tx, tableName, entry.ops, rows);
+                await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
               }
               results.push(rows);
             }
@@ -5486,7 +5879,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
@@ -5498,6 +5891,7 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where } = args;
+          const scope = policies?.scope?.(context);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -5507,7 +5901,12 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
             selectionCtx
           );
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -5565,12 +5964,16 @@ function generateSchemaData2(db, schema, relations, options) {
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
+  const scopes = options.policies?.scope;
+  const contextValuesOf = options.policies?.contextValues;
+  const policies = bindPolicies(options.policies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-largest",
     filterCtx,
-    limits
+    limits,
+    scopes
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -5587,6 +5990,8 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? pgPrimaryKeyPropNames(tables[name]) : [],
+    contextValuesOf,
     featureOf
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
@@ -5597,8 +6002,8 @@ function generateSchemaData2(db, schema, relations, options) {
     extractRelationJoinColumns
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
-  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx, scopes, contextValues: contextValuesOf }) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -5625,6 +6030,7 @@ function generateSchemaData2(db, schema, relations, options) {
   const outputs = {};
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, pgPrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
     const {
@@ -5657,7 +6063,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       tableFeatures.distinct,
-      limits
+      limits,
+      policies
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
@@ -5670,7 +6077,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      limits
+      limits,
+      policies
     );
     const insertArrGenerated = tableFeatures.insert ? generateInsertArray2(
       db,
@@ -5685,7 +6093,8 @@ function generateSchemaData2(db, schema, relations, options) {
       conflictDoNothing,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle2(
       db,
@@ -5700,7 +6109,8 @@ function generateSchemaData2(db, schema, relations, options) {
       conflictDoNothing,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
     const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
@@ -5726,7 +6136,8 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -5744,7 +6155,8 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateGenerated = tableFeatures.update ? generateUpdate2(
       db,
@@ -5762,7 +6174,8 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateSingleGenerated = tableFeatures.update ? generateUpdate2(
       db,
@@ -5780,7 +6193,8 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
@@ -5796,7 +6210,8 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const deleteGenerated = tableFeatures.delete ? generateDelete2(
       db,
@@ -5809,7 +6224,8 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const deleteSingleGenerated = tableFeatures.delete ? generateDelete2(
       db,
@@ -5822,7 +6238,8 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
@@ -5856,7 +6273,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       aggregateFieldName,
       tableFilters,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -5870,25 +6288,35 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFilters,
       groupByEnum,
       havingInput,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql9.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -5896,14 +6324,20 @@ function generateSchemaData2(db, schema, relations, options) {
         type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (insertArrGenerated) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: insertArrGenerated.args,
-        resolve: insertArrGenerated.resolver
+        resolve: insertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: false, targetArg: "values" })
+        }
       };
     }
     if (insertSingleGenerated) {
@@ -5912,28 +6346,40 @@ function generateSchemaData2(db, schema, relations, options) {
         // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
         type: conflictDoNothing ? singleTableItemOutput : new import_graphql9.GraphQLNonNull(singleTableItemOutput),
         args: insertSingleGenerated.args,
-        resolve: insertSingleGenerated.resolver
+        resolve: insertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: true, targetArg: "values" })
+        }
       };
     }
     if (upsertArrGenerated) {
       mutations[upsertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: upsertArrGenerated.args,
-        resolve: upsertArrGenerated.resolver
+        resolve: upsertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: false, targetArg: "values" })
+        }
       };
     }
     if (upsertSingleGenerated) {
       mutations[upsertSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: upsertSingleGenerated.args,
-        resolve: upsertSingleGenerated.resolver
+        resolve: upsertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: true, targetArg: "values" })
+        }
       };
     }
     if (updateGenerated) {
       mutations[updateGenerated.name] = {
         type: arrTableItemOutput,
         args: updateGenerated.args,
-        resolve: updateGenerated.resolver
+        resolve: updateGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: false, targetArg: "where" })
+        }
       };
     }
     if (updateManyGenerated) {
@@ -5941,6 +6387,9 @@ function generateSchemaData2(db, schema, relations, options) {
         type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "updateMany", single: false, targetArg: "updates" })
+        },
         // The nullable element is deliberate, and the reason this mutation's return type
         // differs from every sibling's: the result is aligned with the input, one slot per
         // entry, so an entry that matched nothing has to be able to say so.
@@ -5951,21 +6400,30 @@ function generateSchemaData2(db, schema, relations, options) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: updateSingleGenerated.args,
-        resolve: updateSingleGenerated.resolver
+        resolve: updateSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: true, targetArg: "where" })
+        }
       };
     }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
         args: deleteGenerated.args,
-        resolve: deleteGenerated.resolver
+        resolve: deleteGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: false, targetArg: "where" })
+        }
       };
     }
     if (deleteSingleGenerated) {
       mutations[deleteSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: deleteSingleGenerated.args,
-        resolve: deleteSingleGenerated.resolver
+        resolve: deleteSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: true, targetArg: "where" })
+        }
       };
     }
     if (updateCountGenerated) {
@@ -6033,7 +6491,7 @@ var import_drizzle_orm9 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
 var import_graphql10 = require("graphql");
 var import_graphql_parse_resolve_info4 = require("graphql-parse-resolve-info");
-var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
+var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits, policies) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -6070,6 +6528,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           limits,
           pkNames,
           db: executor,
+          scope: policies?.scope?.(context),
           // SQLite sorts NULLs as the smallest values (first in ASC).
           nullOrdering: "nulls-smallest"
         });
@@ -6080,7 +6539,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
+var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -6110,7 +6569,8 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
           filterCtx,
           limits,
           pkNames,
-          db: executor
+          db: executor,
+          scope: policies?.scope?.(context)
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -6120,7 +6580,7 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_sqlite_core2.getTableConfig);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(baseType)))
@@ -6137,7 +6597,13 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
           }
           const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntries ? [] : applyContextValuesAll(
+            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -6150,7 +6616,8 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -6165,8 +6632,9 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
             runtime: nested,
             tableName,
             entries: nestedEntries,
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: (tx, values) => runInsert(tx, [values])
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: (tx, values) => runInsert(tx, [values]),
+            context
           }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
@@ -6178,7 +6646,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: new import_graphql10.GraphQLNonNull(baseType)
@@ -6192,7 +6660,13 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
           const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntry ? {} : applyContextValues(
+            remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -6205,7 +6679,8 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -6220,8 +6695,9 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             runtime: nested,
             tableName,
             entries: [nestedEntry],
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: runInsert
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: runInsert,
+            context
           }) : await runInsert(executor, input);
           if (!result[0]) {
             if (!conflictDoNothing) {
@@ -6239,7 +6715,7 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql10.GraphQLNonNull(baseType) : new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(baseType)))
@@ -6261,7 +6737,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
           }
           const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
+          const contextColumns = policies?.contextValues?.(tableName);
+          const scope = policies?.scope?.(context);
+          const input = nestedEntries ? [] : applyContextValuesAll(
+            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
+            contextColumns,
+            context
+          );
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -6272,7 +6754,8 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runUpsert = async (target, values) => {
@@ -6287,7 +6770,8 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
               buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
             });
             let query = target.insert(table).values(values).returning(returning);
-            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            const setWhere = withScope(scope, tableName, table, plan.setWhere);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
             return await query;
           };
           const result = nestedEntries ? await writeWithNestedOps({
@@ -6295,8 +6779,9 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
             runtime: nested,
             tableName,
             entries: nestedEntries,
-            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
-            write: (tx, values) => runUpsert(tx, [values])
+            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+            write: (tx, values) => runUpsert(tx, [values]),
+            context
           }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
@@ -6311,7 +6796,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     set: {
       type: new import_graphql10.GraphQLNonNull(setArgs)
@@ -6327,6 +6812,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where, set } = args;
+          const scope = policies?.scope?.(context);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -6339,16 +6825,25 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+          const input = stripContextValues(
+            remapUpdateInput(entry ? entry.columns : set, table, tableName),
+            policies?.contextValues?.(tableName)
+          );
           if (!Object.keys(input).length && !nestedOps) {
             throw new import_graphql10.GraphQLError("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -6368,7 +6863,8 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             columns: input,
             ops: nestedOps,
             remapValues: (values) => values,
-            write: runUpdate
+            write: runUpdate,
+            context
           }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
             throw new import_graphql10.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
@@ -6386,7 +6882,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits) => {
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits, policies) => {
   const queryArgs = {
     updates: {
       type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(updateManyInput)))
@@ -6402,6 +6898,8 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
           if (!updates.length) {
             throw new import_graphql10.GraphQLError("No updates were provided!");
           }
+          const scope = policies?.scope?.(context);
+          const contextColumns = policies?.contextValues?.(tableName);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -6414,19 +6912,28 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             table,
             pkNames,
             parsedInfo,
-            limits
+            limits,
+            scope
           });
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
+            const input = stripContextValues(
+              remapUpdateInput(split ? split.columns : set, table, tableName),
+              contextColumns
+            );
             if (!Object.keys(input).length && !ops) {
               throw new import_graphql10.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
               ops,
-              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              filters: withScope(
+                scope,
+                tableName,
+                table,
+                where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+              )
             };
           });
           const anyNested = entries.some((entry) => entry.ops);
@@ -6444,7 +6951,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             return query.returning(returning).all();
           };
           const runNestedEntry = async (tx, entry) => {
-            const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+            const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
             const writes = Object.keys(values).length > 0;
             let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
             if (entry.filters) {
@@ -6452,7 +6959,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             }
             const rows = await (writes ? query.returning(returning) : query);
             if (entry.ops) {
-              await nested.applyChildSide(tx, tableName, entry.ops, rows);
+              await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
             }
             return rows;
           };
@@ -6505,7 +7012,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql10.GraphQLNonNull(filterArgs) : filterArgs
@@ -6517,6 +7024,7 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where } = args;
+          const scope = policies?.scope?.(context);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -6526,7 +7034,12 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
             selectionCtx
           );
           const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          const filters = withScope(
+            scope,
+            tableName,
+            table,
+            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+          );
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
@@ -6585,12 +7098,16 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
+  const scopes = options.policies?.scope;
+  const contextValuesOf = options.policies?.contextValues;
+  const policies = bindPolicies(options.policies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-smallest",
     filterCtx,
-    limits
+    limits,
+    scopes
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -6607,6 +7124,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? sqlitePrimaryKeyPropNames(tables[name]) : [],
+    contextValuesOf,
     featureOf
   };
   if (features.nestedWrites && db.resultKind === "sync") {
@@ -6622,8 +7141,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     extractRelationJoinColumns
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
-  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx, scopes, contextValues: contextValuesOf }) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
   const queries = {};
   const mutations = {};
   if (options.transactions && db.resultKind === "sync") {
@@ -6655,6 +7174,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const outputs = {};
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, sqlitePrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
     const {
@@ -6687,7 +7207,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       tableFeatures.distinct,
-      limits
+      limits,
+      policies
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
@@ -6700,7 +7221,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      limits
+      limits,
+      policies
     );
     const insertArrGenerated = tableFeatures.insert ? generateInsertArray3(
       db,
@@ -6715,7 +7237,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       conflictDoNothing,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle3(
       db,
@@ -6730,7 +7253,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       conflictDoNothing,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
     const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
@@ -6756,7 +7280,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -6774,7 +7299,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateGenerated = tableFeatures.update ? generateUpdate3(
       db,
@@ -6792,7 +7318,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateSingleGenerated = tableFeatures.update ? generateUpdate3(
       db,
@@ -6810,7 +7337,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
@@ -6826,7 +7354,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
-      limits
+      limits,
+      policies
     ) : void 0;
     const deleteGenerated = tableFeatures.delete ? generateDelete3(
       db,
@@ -6839,7 +7368,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const deleteSingleGenerated = tableFeatures.delete ? generateDelete3(
       db,
@@ -6852,7 +7382,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
-      mutationTxCtx
+      mutationTxCtx,
+      policies
     ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
@@ -6886,7 +7417,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       aggregateFieldName,
       tableFilters,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -6900,25 +7432,35 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFilters,
       groupByEnum,
       havingInput,
-      filterCtx
+      filterCtx,
+      scopes
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql10.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -6926,14 +7468,20 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (insertArrGenerated) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: insertArrGenerated.args,
-        resolve: insertArrGenerated.resolver
+        resolve: insertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: false, targetArg: "values" })
+        }
       };
     }
     if (insertSingleGenerated) {
@@ -6942,28 +7490,40 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
         type: conflictDoNothing ? singleTableItemOutput : new import_graphql10.GraphQLNonNull(singleTableItemOutput),
         args: insertSingleGenerated.args,
-        resolve: insertSingleGenerated.resolver
+        resolve: insertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: true, targetArg: "values" })
+        }
       };
     }
     if (upsertArrGenerated) {
       mutations[upsertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: upsertArrGenerated.args,
-        resolve: upsertArrGenerated.resolver
+        resolve: upsertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: false, targetArg: "values" })
+        }
       };
     }
     if (upsertSingleGenerated) {
       mutations[upsertSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: upsertSingleGenerated.args,
-        resolve: upsertSingleGenerated.resolver
+        resolve: upsertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: true, targetArg: "values" })
+        }
       };
     }
     if (updateGenerated) {
       mutations[updateGenerated.name] = {
         type: arrTableItemOutput,
         args: updateGenerated.args,
-        resolve: updateGenerated.resolver
+        resolve: updateGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: false, targetArg: "where" })
+        }
       };
     }
     if (updateManyGenerated) {
@@ -6971,6 +7531,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "updateMany", single: false, targetArg: "updates" })
+        },
         // The nullable element is deliberate, and the reason this mutation's return type
         // differs from every sibling's: the result is aligned with the input, one slot per
         // entry, so an entry that matched nothing has to be able to say so.
@@ -6981,21 +7544,30 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: updateSingleGenerated.args,
-        resolve: updateSingleGenerated.resolver
+        resolve: updateSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: true, targetArg: "where" })
+        }
       };
     }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
         args: deleteGenerated.args,
-        resolve: deleteGenerated.resolver
+        resolve: deleteGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: false, targetArg: "where" })
+        }
       };
     }
     if (deleteSingleGenerated) {
       mutations[deleteSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: deleteSingleGenerated.args,
-        resolve: deleteSingleGenerated.resolver
+        resolve: deleteSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: true, targetArg: "where" })
+        }
       };
     }
     if (updateCountGenerated) {
@@ -7058,6 +7630,141 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
+// src/util/selection.ts
+var import_drizzle_orm10 = require("drizzle-orm");
+var import_mysql_core3 = require("drizzle-orm/mysql-core");
+var import_pg_core3 = require("drizzle-orm/pg-core");
+var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
+var import_graphql_parse_resolve_info5 = require("graphql-parse-resolve-info");
+var contextCache = /* @__PURE__ */ new WeakMap();
+var tableConfigFor = (db) => {
+  if ((0, import_drizzle_orm10.is)(db, import_mysql_core3.MySqlDatabase)) {
+    return import_mysql_core3.getTableConfig;
+  }
+  if ((0, import_drizzle_orm10.is)(db, import_pg_core3.PgAsyncDatabase)) {
+    return import_pg_core3.getTableConfig;
+  }
+  if ((0, import_drizzle_orm10.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+    return import_sqlite_core3.getTableConfig;
+  }
+  throw new Error("Drizzle-GraphQL Error: unsupported database instance \u2014 expected a PostgreSQL, MySQL or SQLite one.");
+};
+var contextFor = (db) => {
+  const cached = contextCache.get(db);
+  if (cached) {
+    return cached;
+  }
+  const relations = db._.relations ?? {};
+  const schema = db._.fullSchema ?? Object.fromEntries(
+    Object.entries(relations).filter(([, config]) => config?.table != null).map(([key, config]) => [key, config.table])
+  );
+  const tableEntries = Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm10.is)(value, import_drizzle_orm10.Table));
+  if (!tableEntries.length) {
+    throw new Error(
+      "Drizzle-GraphQL Error: Schema not found in drizzle instance. Pass relations (from buildRelations/defineRelations) to the drizzle constructor so drizzle-graphql can read your tables."
+    );
+  }
+  const tables = Object.fromEntries(tableEntries);
+  const getTableConfig4 = tableConfigFor(db);
+  const primaryKeyCache = /* @__PURE__ */ new Map();
+  const primaryKeyOf = (tableName) => {
+    let pk = primaryKeyCache.get(tableName);
+    if (!pk) {
+      const table = tables[tableName];
+      pk = table ? getPrimaryKeyPropNamesFromConfig(table, getTableConfig4) : [];
+      primaryKeyCache.set(tableName, pk);
+    }
+    return pk;
+  };
+  const relationMap = buildNamedRelations(relations, tableEntries);
+  attachTargetPrimaryKeys(relationMap, tables, (table) => [...primaryKeyOf(tableNameOf(tables, table))]);
+  const context = {
+    tables,
+    relationMap,
+    filterCtx: { tables, relationMap },
+    primaryKeyOf
+  };
+  contextCache.set(db, context);
+  return context;
+};
+var tableNameOf = (tables, table) => Object.keys(tables).find((name) => tables[name] === table) ?? "";
+var parseInfo = (info) => {
+  if ("fieldsByTypeName" in info) {
+    return info;
+  }
+  return (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, { deep: true });
+};
+var selectionToWith = (info, options) => {
+  const { db, table, typeNameMapper } = options;
+  const { tables, relationMap, filterCtx } = contextFor(db);
+  if (!tables[table]) {
+    throw new Error(`Drizzle-GraphQL Error: '${table}' is not a table in the Drizzle schema.`);
+  }
+  if (!relationMap[table]) {
+    return void 0;
+  }
+  const parsed = parseInfo(info);
+  const params = extractRelationsParams(
+    relationMap,
+    tables,
+    table,
+    parsed,
+    resolveTypeName(table, typeNameMapper),
+    typeNameMapper,
+    filterCtx
+  );
+  return params && Object.keys(params).length ? params : void 0;
+};
+var resolveSelection = async (info, options) => {
+  const {
+    db,
+    table: tableName,
+    typeNameMapper,
+    executor,
+    single = false,
+    where,
+    orderBy,
+    limit,
+    offset,
+    after
+  } = options;
+  const { tables, relationMap, filterCtx, primaryKeyOf } = contextFor(db);
+  const table = tables[tableName];
+  if (!table) {
+    throw new Error(`Drizzle-GraphQL Error: '${tableName}' is not a table in the Drizzle schema.`);
+  }
+  const parsedInfo = parseInfo(info);
+  if (!parsedInfo) {
+    throw new Error("Drizzle-GraphQL Error: resolveSelection could not read a selection set from the resolve info.");
+  }
+  const source = executor ?? db;
+  const queryBase = source.query?.[tableName];
+  if (!queryBase) {
+    throw new Error(
+      `Drizzle-GraphQL Error: the executor passed to resolveSelection has no relational query builder for '${tableName}'.`
+    );
+  }
+  return runRelationalSelect({
+    queryBase,
+    tables,
+    tableName,
+    table,
+    relationMap,
+    typeName: resolveTypeName(tableName, typeNameMapper),
+    typeNameMapper,
+    parsedInfo,
+    single,
+    where,
+    orderBy,
+    limit,
+    offset,
+    after,
+    filterCtx,
+    pkNames: primaryKeyOf(tableName),
+    db: source
+  });
+};
+
 // src/index.ts
 var buildSchema = (db, config) => {
   const relations = db._.relations;
@@ -7080,7 +7787,7 @@ var buildSchema = (db, config) => {
     single: config?.suffixes?.single ?? "Single"
   };
   const typeNameMapper = config?.typeNameMapper === "singularize" ? singularizeMapper : config?.typeNameMapper;
-  const tableKeys = Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm10.is)(value, import_drizzle_orm10.Table)).map(([key]) => key);
+  const tableKeys = Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm11.is)(value, import_drizzle_orm11.Table)).map(([key]) => key);
   const excludedTableNames = new Set(config?.exclude?.tables ?? []);
   const featureTables = tableKeys.filter((key) => !excludedTableNames.has(key));
   const forTable = resolveTableFeatures(config?.features);
@@ -7118,6 +7825,43 @@ var buildSchema = (db, config) => {
     limitPolicyCache.set(tableName, resolved);
     return resolved;
   } : void 0;
+  const scopeConfig = config?.scope;
+  const contextValuesConfig = config?.contextValues;
+  if (scopeConfig || contextValuesConfig) {
+    const tableNames = new Set(tableKeys);
+    for (const [tableName, hook] of Object.entries(scopeConfig ?? {})) {
+      if (!tableNames.has(tableName)) {
+        throw new Error(
+          `Drizzle-GraphQL Error: config.scope names '${tableName}', which is not a table in the Drizzle schema.`
+        );
+      }
+      if (typeof hook !== "function") {
+        throw new Error(`Drizzle-GraphQL Error: config.scope.${tableName} must be a function.`);
+      }
+    }
+    for (const [tableName, columnHooks] of Object.entries(contextValuesConfig ?? {})) {
+      if (!tableNames.has(tableName)) {
+        throw new Error(
+          `Drizzle-GraphQL Error: config.contextValues names '${tableName}', which is not a table in the Drizzle schema.`
+        );
+      }
+      const columns = (0, import_drizzle_orm11.getColumns)(schema[tableName]);
+      for (const [columnName, hook] of Object.entries(columnHooks)) {
+        if (!columns[columnName]) {
+          throw new Error(
+            `Drizzle-GraphQL Error: config.contextValues names '${tableName}.${columnName}', which is not a column of that table.`
+          );
+        }
+        if (typeof hook !== "function") {
+          throw new Error(`Drizzle-GraphQL Error: config.contextValues.${tableName}.${columnName} must be a function.`);
+        }
+      }
+    }
+  }
+  const policies = scopeConfig || contextValuesConfig ? {
+    scope: scopeConfig ? (tableName) => scopeConfig[tableName] : void 0,
+    contextValues: contextValuesConfig ? (tableName) => contextValuesConfig[tableName] : void 0
+  } : void 0;
   const exclude = config?.exclude;
   if (exclude) {
     const tableNames = new Set(tableKeys);
@@ -7143,7 +7887,7 @@ var buildSchema = (db, config) => {
       if (excludedTables.has(tableName)) {
         continue;
       }
-      const columns = (0, import_drizzle_orm10.getColumns)(schema[tableName]);
+      const columns = (0, import_drizzle_orm11.getColumns)(schema[tableName]);
       for (const columnName of columnNames) {
         const column = columns[columnName];
         if (!column) {
@@ -7235,6 +7979,7 @@ var buildSchema = (db, config) => {
     enumNameMapper: config?.enumNameMapper,
     transactions,
     limits,
+    policies,
     exclude,
     docs: {
       describeColumn: config?.describeColumn,
@@ -7244,11 +7989,11 @@ var buildSchema = (db, config) => {
     }
   };
   let generatorOutput;
-  if ((0, import_drizzle_orm10.is)(db, import_mysql_core3.MySqlDatabase)) {
+  if ((0, import_drizzle_orm11.is)(db, import_mysql_core4.MySqlDatabase)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm10.is)(db, import_pg_core3.PgAsyncDatabase)) {
+  } else if ((0, import_drizzle_orm11.is)(db, import_pg_core4.PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm10.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+  } else if ((0, import_drizzle_orm11.is)(db, import_sqlite_core4.BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -7288,9 +8033,14 @@ var buildSchema = (db, config) => {
   createRelationResolverFactory,
   defaultErrorMapper,
   drizzleExecutorKey,
+  drizzleExtension,
   extractFilters,
   extractOrderBy,
   extractRelationJoinColumns,
+  identifyRows,
+  isDrizzleFieldExtension,
+  resolveSelection,
+  selectionToWith,
   singularizeMapper
 });
 //# sourceMappingURL=index.cjs.map