@@ -0,0 +1,12 @@
+---
+'@graphql-codegen/plugin-helpers': patch
+'@graphql-codegen/cli': patch
+---
+
+Widen `Types.SchemaWithLoaderOptions['loader']` to accept a custom loader function (`CustomSchemaLoaderFn`) in addition to a path string.
+
+A per-entry `schema` custom loader (`{ '<pointer>': { loader, ...options } }`) is resolved by `@graphql-tools/load`'s `useCustomLoader`, which already accepts either a path string (resolved via `require()`) or a function value at runtime (`typeof loaderPointer === 'function'`). Only the TypeScript type restricted `loader` to `string`, forcing consumers who pass an imported loader function (or a class instance exposing a bound `loader` property) to cast the `schema` array to bypass the type error, even though it worked correctly at runtime.
+
+This is additive and backward compatible — `loader: string` continues to type-check exactly as before.
+
+Also fixes a schema-cache collision for function loaders in `@graphql-codegen/cli`: the cache key is `JSON.stringify(schemaPointerMap)`, and `JSON.stringify` drops functions, so two `generates` targets using different loader functions for the same pointer (`{ 'schema.graphql': { loader: fnA } }` vs `{ loader: fnB }`) both keyed as `{"schema.graphql":{}}` and the second silently reused the first's schema. Function values are now keyed by object identity (via the existing `getJsObjectId`), so distinct loaders load separately while one function reused across targets still loads once.
@@ -87,17 +87,18 @@ export async function executeCodegen(
 
   const cache = createCache();
 
-  // We need a simple string to uniqually identify the provided GraphQLSchema objects for the above cache.
+  // We need a simple string to uniqually identify the provided objects (e.g. GraphQLSchema
+  // instances passed inline, or custom loader functions) for the above cache.
   // Because JavaScript does not provide access to its internal object ids, we need a workaround.
   // Below is a common way to get unique ids for objects in JavaScript,
   // by using a WeakMap and autoincrementing the id.
-  const jsObjectIds = new WeakMap<GraphQLSchema, number>();
+  const jsObjectIds = new WeakMap<object, number>();
   let jsObjectIdCounter = 0;
-  function getJsObjectId(schema: GraphQLSchema): number {
-    if (!jsObjectIds.has(schema)) {
-      jsObjectIds.set(schema, jsObjectIdCounter++);
+  function getJsObjectId(obj: object): number {
+    if (!jsObjectIds.has(obj)) {
+      jsObjectIds.set(obj, jsObjectIdCounter++);
     }
-    return jsObjectIds.get(schema)!;
+    return jsObjectIds.get(obj)!;
   }
 
   function wrapTask(task: () => void | Promise<void>, source: string, taskName: string, ctx: Ctx) {
@@ -290,8 +291,12 @@ export async function executeCodegen(
                           }
 
                           const hash =
-                            JSON.stringify(schemaPointerMap) +
-                            parsedSchemas.map(getJsObjectId).join(',');
+                            // `JSON.stringify` drops functions, so custom loader functions
+                            // would all serialize to the same key and collide in the cache.
+                            // Key them by object identity instead, like `parsedSchemas` below.
+                            JSON.stringify(schemaPointerMap, (_key, value) =>
+                              typeof value === 'function' ? `[fn:${getJsObjectId(value)}]` : value,
+                            ) + parsedSchemas.map(getJsObjectId).join(',');
                           const result = await cache('schema', hash, async () => {
                             // collect parsed schemas
                             const schemasToMerge: GraphQLSchema[] = [...parsedSchemas];
 
@@ -990,6 +990,66 @@ describe('Codegen Executor', () => {
       expect(error.message).toContain('Failed to load schema');
       expect(error.message).toContain('Failed to load custom loader');
     });
+
+    it('Should allow a loader to be a function passed directly', async () => {
+      const { result } = await executeCodegen({
+        schema: [
+          {
+            'schema.graphql': {
+              loader: () => buildSchema(`type Query { fromFunctionLoader: String }`),
+            },
+          },
+        ],
+        generates: {
+          'out1.ts': { plugins: ['typescript'] },
+        },
+      });
+
+      expect(result[0].content).toContain('fromFunctionLoader');
+    });
+
+    it('Should not collide distinct function loaders using the same pointer across outputs', async () => {
+      const { result } = await executeCodegen({
+        generates: {
+          'a.ts': {
+            schema: [
+              { 'schema.graphql': { loader: () => buildSchema(`type Query { fromA: String }`) } },
+            ],
+            plugins: ['typescript'],
+          },
+          'b.ts': {
+            schema: [
+              { 'schema.graphql': { loader: () => buildSchema(`type Query { fromB: String }`) } },
+            ],
+            plugins: ['typescript'],
+          },
+        },
+      });
+
+      const a = result.find(f => f.filename === 'a.ts').content;
+      const b = result.find(f => f.filename === 'b.ts').content;
+      expect(a).toContain('fromA');
+      expect(a).not.toContain('fromB');
+      expect(b).toContain('fromB');
+      expect(b).not.toContain('fromA');
+    });
+
+    it('Should call a function loader reused across outputs only once (cached by identity)', async () => {
+      let calls = 0;
+      const loader = () => {
+        calls++;
+        return buildSchema(`type Query { shared: String }`);
+      };
+
+      await executeCodegen({
+        generates: {
+          'a.ts': { schema: [{ 'schema.graphql': { loader } }], plugins: ['typescript'] },
+          'b.ts': { schema: [{ 'schema.graphql': { loader } }], plugins: ['typescript'] },
+        },
+      });
+
+      expect(calls).toBe(1);
+    });
   });
 
   describe('Custom documents loader', () => {
 
@@ -74,15 +74,22 @@ export namespace Types {
   export type Promisable<T> = T | Promise<T>;
   export type InstanceOrArray<T> = T | T[];
 
+  export type CustomSchemaLoaderFn = (
+    pointer: string,
+    config: any,
+    pointerOptionMap?: Record<string, any>,
+  ) => Promisable<GraphQLSchema | DocumentNode | Source | void>;
+
   /**
    * @additionalProperties false
-   * @description Loads schema using a pointer, with a custom loader (code file).
+   * @description Loads schema using a pointer, with a custom loader (code file or function).
    */
   export interface SchemaWithLoaderOptions {
     /**
-     * @description Specify a path to a custom code file (local or module) that will handle the schema loading.
+     * @description Specify a path to a custom code file (local or module), or a
+     * custom loader function directly, that will handle the schema loading.
      */
-    loader: string;
+    loader: string | CustomSchemaLoaderFn;
   }
   export interface SchemaWithLoader {
     [pointer: string]: SchemaWithLoaderOptions;
 
@@ -567,6 +567,35 @@ module.exports = (schemaString, config) => {
   plugins.
 </Callout>
 
+### Passing a Loader Function Directly
+
+Instead of a path string, `loader` can also be a function defined directly in your config,
+typed with the `Types.CustomSchemaLoaderFn` type. This skips the file-path/`require()`
+resolution step, so there's no need for `ts-node/register` to transpile a loader file at
+runtime (see the note at the end of the previous section).
+
+```ts
+import { CodegenConfig } from '@graphql-codegen/cli';
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { buildSchema } from 'graphql';
+
+const loader: Types.CustomSchemaLoaderFn = async (pointer, config) => {
+  // Your logic for loading your GraphQLSchema
+  return buildSchema(/* ... */);
+};
+
+const config: CodegenConfig = {
+  schema: [
+    {
+      'schema.graphql': {
+        loader,
+      },
+    },
+  ],
+};
+export default config;
+```
+
 ### Loading API URL from TypeScript file example:
 
 If you store your API config in a file, and don't want to repeat the URL in the codegen config. You can follow the following example: