diff --git a/graphql/codegen/.gitignore b/graphql/codegen/.gitignore
index 3046b9746..4dcf19c7e 100644
--- a/graphql/codegen/.gitignore
+++ b/graphql/codegen/.gitignore
@@ -1,14 +1,8 @@
 # Build output
 dist/
 
-# Generated SDK output (for testing)
-output-rq
-output-orm/
-
-examples/output/generated-sdk/
-examples/output/generated-orm/
-examples/output/generated-sdk-schema/
-examples/output/generated-orm-schema/
+# Artifacts of codegen for testing
+examples/output/
 
 # Dependencies
 node_modules/
diff --git a/graphql/codegen/README.md b/graphql/codegen/README.md
index d88cf7ad1..100495d74 100644
--- a/graphql/codegen/README.md
+++ b/graphql/codegen/README.md
@@ -117,6 +117,7 @@ Generate React Query hooks from a PostGraphile endpoint.
 ```bash
 Options:
   -e, --endpoint <url>     GraphQL endpoint URL (overrides config)
+  -t, --target <name>      Target name in config file
   -o, --output <dir>       Output directory (default: ./generated/graphql)
   -c, --config <path>      Path to config file
   -a, --authorization <token>  Authorization header value
@@ -132,6 +133,7 @@ Generate Prisma-like ORM client from a PostGraphile endpoint.
 ```bash
 Options:
   -e, --endpoint <url>           GraphQL endpoint URL
+  -t, --target <name>            Target name in config file
   -o, --output <dir>             Output directory (default: ./generated/orm)
   -c, --config <path>            Path to config file
   -a, --authorization <token>    Authorization header value
@@ -164,9 +166,10 @@ Options:
 ## Configuration
 
 ```typescript
-interface GraphQLSDKConfig {
-  // Required
-  endpoint: string;
+interface GraphQLSDKConfigTarget {
+  // Required (choose one)
+  endpoint?: string;
+  schema?: string;
 
   // Output
   output?: string; // default: './generated/graphql'
@@ -194,25 +197,62 @@ interface GraphQLSDKConfig {
 
   // Code generation options
   codegen?: {
-    maxFieldDepth?: number;    // default: 2
-    skipQueryField?: boolean;  // default: true
+    maxFieldDepth?: number; // default: 2
+    skipQueryField?: boolean; // default: true
   };
 
   // ORM-specific config
   orm?: {
-    output?: string;           // default: './generated/orm'
-    useSharedTypes?: boolean;  // default: true
+    output?: string; // default: './generated/orm'
+    useSharedTypes?: boolean; // default: true
   };
 }
+
+interface GraphQLSDKMultiConfig {
+  defaults?: GraphQLSDKConfigTarget;
+  targets: Record<string, GraphQLSDKConfigTarget>;
+}
+
+type GraphQLSDKConfig = GraphQLSDKConfigTarget | GraphQLSDKMultiConfig;
+```
+
+### Multi-target Configuration
+
+Configure multiple schema sources and outputs in one file:
+
+```typescript
+export default defineConfig({
+  defaults: {
+    headers: { Authorization: 'Bearer <token>' },
+  },
+  targets: {
+    public: {
+      endpoint: 'https://api.example.com/graphql',
+      output: './generated/public',
+    },
+    admin: {
+      schema: './admin.schema.graphql',
+      output: './generated/admin',
+    },
+  },
+});
 ```
 
+CLI behavior:
+
+- `graphql-codegen generate` runs all targets
+- `graphql-codegen generate --target admin` runs a single target
+- `--output` requires `--target` when multiple targets exist
+
 ### Glob Patterns
 
 Filter patterns support wildcards:
+
 - `*` - matches any string
 - `?` - matches single character
 
 Examples:
+
 ```typescript
 {
   tables: {
@@ -308,30 +348,25 @@ Fetches multiple records with pagination, filtering, and ordering:
 import { useCarsQuery } from './generated/hooks';
 
 function CarList() {
-  const { 
-    data, 
-    isLoading, 
-    isError, 
-    error,
-    refetch,
-    isFetching,
-  } = useCarsQuery({
-    // Pagination
-    first: 10,           // First N records
-    // last: 10,         // Last N records
-    // after: 'cursor',  // Cursor-based pagination
-    // before: 'cursor',
-    // offset: 20,       // Offset pagination
-    
-    // Filtering
-    filter: {
-      brand: { equalTo: 'Tesla' },
-      price: { greaterThan: 50000 },
-    },
-    
-    // Ordering
-    orderBy: ['CREATED_AT_DESC', 'NAME_ASC'],
-  });
+  const { data, isLoading, isError, error, refetch, isFetching } = useCarsQuery(
+    {
+      // Pagination
+      first: 10, // First N records
+      // last: 10,         // Last N records
+      // after: 'cursor',  // Cursor-based pagination
+      // before: 'cursor',
+      // offset: 20,       // Offset pagination
+
+      // Filtering
+      filter: {
+        brand: { equalTo: 'Tesla' },
+        price: { greaterThan: 50000 },
+      },
+
+      // Ordering
+      orderBy: ['CREATED_AT_DESC', 'NAME_ASC'],
+    }
+  );
 
   if (isLoading) return <div>Loading...</div>;
   if (isError) return <div>Error: {error.message}</div>;
@@ -340,11 +375,13 @@ function CarList() {
     <div>
       <p>Total: {data?.cars.totalCount}</p>
       <ul>
-        {data?.cars.nodes.map(car => (
-          <li key={car.id}>{car.brand} - ${car.price}</li>
+        {data?.cars.nodes.map((car) => (
+          <li key={car.id}>
+            {car.brand} - ${car.price}
+          </li>
         ))}
       </ul>
-      
+
       {/* Pagination info */}
       {data?.cars.pageInfo.hasNextPage && (
         <button onClick={() => refetch()}>Load More</button>
@@ -411,7 +448,12 @@ function CreateCarForm() {
   };
 
   return (
-    <form onSubmit={(e) => { e.preventDefault(); handleSubmit({ brand: 'Tesla', price: 80000 }); }}>
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        handleSubmit({ brand: 'Tesla', price: 80000 });
+      }}
+    >
       {/* form fields */}
       <button type="submit" disabled={createCar.isPending}>
         {createCar.isPending ? 'Creating...' : 'Create Car'}
@@ -427,7 +469,13 @@ function CreateCarForm() {
 ```tsx
 import { useUpdateCarMutation } from './generated/hooks';
 
-function EditCarForm({ carId, currentBrand }: { carId: string; currentBrand: string }) {
+function EditCarForm({
+  carId,
+  currentBrand,
+}: {
+  carId: string;
+  currentBrand: string;
+}) {
   const updateCar = useUpdateCarMutation({
     onSuccess: (data) => {
       console.log('Updated car:', data.updateCar.car.brand);
@@ -446,7 +494,7 @@ function EditCarForm({ carId, currentBrand }: { carId: string; currentBrand: str
   };
 
   return (
-    <button 
+    <button
       onClick={() => handleUpdate('Updated Brand')}
       disabled={updateCar.isPending}
     >
@@ -470,7 +518,7 @@ function DeleteCarButton({ carId }: { carId: string }) {
   });
 
   return (
-    <button 
+    <button
       onClick={() => deleteCar.mutate({ input: { id: carId } })}
       disabled={deleteCar.isPending}
     >
@@ -517,9 +565,9 @@ function NodeViewer({ nodeId }: { nodeId: string }) {
 Custom mutations (like `login`, `register`, `logout`) get dedicated hooks:
 
 ```tsx
-import { 
-  useLoginMutation, 
-  useRegisterMutation, 
+import {
+  useLoginMutation,
+  useRegisterMutation,
   useLogoutMutation,
   useForgotPasswordMutation,
 } from './generated/hooks';
@@ -550,7 +598,12 @@ function LoginForm() {
   };
 
   return (
-    <form onSubmit={(e) => { e.preventDefault(); handleLogin('user@example.com', 'password'); }}>
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        handleLogin('user@example.com', 'password');
+      }}
+    >
       {/* email and password inputs */}
       <button disabled={login.isPending}>
         {login.isPending ? 'Logging in...' : 'Login'}
@@ -567,7 +620,11 @@ function RegisterForm() {
     },
   });
 
-  const handleRegister = (data: { email: string; password: string; username: string }) => {
+  const handleRegister = (data: {
+    email: string;
+    password: string;
+    username: string;
+  }) => {
     register.mutate({
       input: {
         email: data.email,
@@ -578,7 +635,15 @@ function RegisterForm() {
   };
 
   return (
-    <button onClick={() => handleRegister({ email: 'new@example.com', password: 'secret', username: 'newuser' })}>
+    <button
+      onClick={() =>
+        handleRegister({
+          email: 'new@example.com',
+          password: 'secret',
+          username: 'newuser',
+        })
+      }
+    >
       Register
     </button>
   );
@@ -593,11 +658,7 @@ function LogoutButton() {
     },
   });
 
-  return (
-    <button onClick={() => logout.mutate({ input: {} })}>
-      Logout
-    </button>
-  );
+  return <button onClick={() => logout.mutate({ input: {} })}>Logout</button>;
 }
 
 // Forgot Password
@@ -609,7 +670,11 @@ function ForgotPasswordForm() {
   });
 
   return (
-    <button onClick={() => forgotPassword.mutate({ input: { email: 'user@example.com' } })}>
+    <button
+      onClick={() =>
+        forgotPassword.mutate({ input: { email: 'user@example.com' } })
+      }
+    >
       Reset Password
     </button>
   );
@@ -629,10 +694,10 @@ useCarsQuery({
       notEqualTo: 'Ford',
       in: ['Tesla', 'BMW', 'Mercedes'],
       notIn: ['Unknown'],
-      contains: 'es',           // LIKE '%es%'
-      startsWith: 'Tes',        // LIKE 'Tes%'
-      endsWith: 'la',           // LIKE '%la'
-      includesInsensitive: 'TESLA',  // Case-insensitive
+      contains: 'es', // LIKE '%es%'
+      startsWith: 'Tes', // LIKE 'Tes%'
+      endsWith: 'la', // LIKE '%la'
+      includesInsensitive: 'TESLA', // Case-insensitive
     },
   },
 });
@@ -671,7 +736,7 @@ useOrdersQuery({
 // Null checks
 useUsersQuery({
   filter: {
-    deletedAt: { isNull: true },  // Only non-deleted
+    deletedAt: { isNull: true }, // Only non-deleted
   },
 });
 
@@ -687,10 +752,7 @@ useUsersQuery({
 useUsersQuery({
   filter: {
     // OR
-    or: [
-      { role: { equalTo: 'ADMIN' } },
-      { role: { equalTo: 'MODERATOR' } },
-    ],
+    or: [{ role: { equalTo: 'ADMIN' } }, { role: { equalTo: 'MODERATOR' } }],
   },
 });
 
@@ -746,12 +808,12 @@ useCarsQuery({ first: 10 });
 useCarsQuery({ last: 10 });
 
 // Offset pagination
-useCarsQuery({ first: 10, offset: 20 });  // Skip 20, take 10
+useCarsQuery({ first: 10, offset: 20 }); // Skip 20, take 10
 
 // Cursor-based pagination
 function PaginatedList() {
   const [cursor, setCursor] = useState<string | null>(null);
-  
+
   const { data } = useCarsQuery({
     first: 10,
     after: cursor,
@@ -759,8 +821,10 @@ function PaginatedList() {
 
   return (
     <div>
-      {data?.cars.nodes.map(car => <div key={car.id}>{car.brand}</div>)}
-      
+      {data?.cars.nodes.map((car) => (
+        <div key={car.id}>{car.brand}</div>
+      ))}
+
       {data?.cars.pageInfo.hasNextPage && (
         <button onClick={() => setCursor(data.cars.pageInfo.endCursor)}>
           Load More
@@ -786,18 +850,18 @@ All hooks accept standard React Query options:
 ```tsx
 // Query hooks
 useCarsQuery(
-  { first: 10 },  // Variables
+  { first: 10 }, // Variables
   {
     // React Query options
-    enabled: isAuthenticated,           // Conditional fetching
-    refetchInterval: 30000,             // Poll every 30s
-    refetchOnWindowFocus: true,         // Refetch on tab focus
-    staleTime: 5 * 60 * 1000,           // Consider fresh for 5 min
-    gcTime: 30 * 60 * 1000,             // Keep in cache for 30 min
-    retry: 3,                           // Retry failed requests
+    enabled: isAuthenticated, // Conditional fetching
+    refetchInterval: 30000, // Poll every 30s
+    refetchOnWindowFocus: true, // Refetch on tab focus
+    staleTime: 5 * 60 * 1000, // Consider fresh for 5 min
+    gcTime: 30 * 60 * 1000, // Keep in cache for 30 min
+    retry: 3, // Retry failed requests
     retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-    placeholderData: previousData,      // Show previous data while loading
-    select: (data) => data.cars.nodes,  // Transform data
+    placeholderData: previousData, // Show previous data while loading
+    select: (data) => data.cars.nodes, // Transform data
   }
 );
 
@@ -858,11 +922,11 @@ The codegen generates a centralized query key factory following the [lukemorales
 
 #### Generated Files
 
-| File | Purpose |
-|------|---------|
-| `query-keys.ts` | Query key factories for all entities |
+| File               | Purpose                                                 |
+| ------------------ | ------------------------------------------------------- |
+| `query-keys.ts`    | Query key factories for all entities                    |
 | `mutation-keys.ts` | Mutation key factories for tracking in-flight mutations |
-| `invalidation.ts` | Type-safe cache invalidation helpers |
+| `invalidation.ts`  | Type-safe cache invalidation helpers                    |
 
 #### Using Query Keys
 
@@ -871,11 +935,11 @@ import { userKeys, invalidate } from './generated/hooks';
 import { useQueryClient } from '@tanstack/react-query';
 
 // Query key structure
-userKeys.all                    // ['user']
-userKeys.lists()                // ['user', 'list']
-userKeys.list({ first: 10 })    // ['user', 'list', { first: 10 }]
-userKeys.details()              // ['user', 'detail']
-userKeys.detail('user-123')     // ['user', 'detail', 'user-123']
+userKeys.all; // ['user']
+userKeys.lists(); // ['user', 'list']
+userKeys.list({ first: 10 }); // ['user', 'list', { first: 10 }]
+userKeys.details(); // ['user', 'detail']
+userKeys.detail('user-123'); // ['user', 'detail', 'user-123']
 
 // Granular cache invalidation
 const queryClient = useQueryClient();
@@ -920,7 +984,7 @@ function UserList() {
 
   // Check if a specific user is being deleted
   const isDeleting = useIsMutating({
-    mutationKey: userMutationKeys.delete(userId)
+    mutationKey: userMutationKeys.delete(userId),
   });
 
   return (
@@ -950,7 +1014,7 @@ const createUser = useCreateUserMutation({
       ...old,
       users: {
         ...old.users,
-        nodes: [...old.users.nodes, { id: 'temp', ...newUser.input.user }]
+        nodes: [...old.users.nodes, { id: 'temp', ...newUser.input.user }],
       },
     }));
 
@@ -1032,7 +1096,7 @@ import type {
   User,
   Product,
   Order,
-  
+
   // Filter types
   CarFilter,
   UserFilter,
@@ -1040,17 +1104,17 @@ import type {
   IntFilter,
   UUIDFilter,
   DatetimeFilter,
-  
+
   // OrderBy types
   CarsOrderBy,
   UsersOrderBy,
-  
+
   // Input types
   CreateCarInput,
   UpdateCarInput,
   CarPatch,
   LoginInput,
-  
+
   // Payload types
   LoginPayload,
   CreateCarPayload,
@@ -1131,7 +1195,7 @@ type UseQueryResult<TData> = {
 type UseMutationResult<TData, TVariables> = {
   data: TData | undefined;
   error: Error | null;
-  isLoading: boolean;  // deprecated, use isPending
+  isLoading: boolean; // deprecated, use isPending
   isPending: boolean;
   isError: boolean;
   isSuccess: boolean;
@@ -1196,10 +1260,12 @@ const db = createClient({
 });
 
 // Query users
-const result = await db.user.findMany({
-  select: { id: true, username: true, email: true },
-  first: 20,
-}).execute();
+const result = await db.user
+  .findMany({
+    select: { id: true, username: true, email: true },
+    first: 20,
+  })
+  .execute();
 
 if (result.ok) {
   console.log(result.data.users.nodes);
@@ -1208,28 +1274,36 @@ if (result.ok) {
 }
 
 // Find first matching user
-const user = await db.user.findFirst({
-  select: { id: true, username: true },
-  where: { username: { equalTo: 'john' } },
-}).execute();
+const user = await db.user
+  .findFirst({
+    select: { id: true, username: true },
+    where: { username: { equalTo: 'john' } },
+  })
+  .execute();
 
 // Create a user
-const newUser = await db.user.create({
-  data: { username: 'john', email: 'john@example.com' },
-  select: { id: true, username: true },
-}).execute();
+const newUser = await db.user
+  .create({
+    data: { username: 'john', email: 'john@example.com' },
+    select: { id: true, username: true },
+  })
+  .execute();
 
 // Update a user
-const updated = await db.user.update({
-  where: { id: 'user-id' },
-  data: { displayName: 'John Doe' },
-  select: { id: true, displayName: true },
-}).execute();
+const updated = await db.user
+  .update({
+    where: { id: 'user-id' },
+    data: { displayName: 'John Doe' },
+    select: { id: true, displayName: true },
+  })
+  .execute();
 
 // Delete a user
-const deleted = await db.user.delete({
-  where: { id: 'user-id' },
-}).execute();
+const deleted = await db.user
+  .delete({
+    where: { id: 'user-id' },
+  })
+  .execute();
 ```
 
 ### Select & Type Inference
@@ -1238,9 +1312,11 @@ The ORM uses **const generics** to infer return types based on your select claus
 
 ```typescript
 // Select specific fields - return type is narrowed
-const users = await db.user.findMany({
-  select: { id: true, username: true }  // Only id and username
-}).unwrap();
+const users = await db.user
+  .findMany({
+    select: { id: true, username: true }, // Only id and username
+  })
+  .unwrap();
 
 // TypeScript knows the exact shape:
 // users.users.nodes[0] is { id: string; username: string | null }
@@ -1261,16 +1337,18 @@ Relations are fully typed in Select types. The ORM supports all PostGraphile rel
 
 ```typescript
 // Order.customer is a belongsTo relation to User
-const orders = await db.order.findMany({
-  select: {
-    id: true,
-    orderNumber: true,
-    // Nested select for belongsTo relation
-    customer: {
-      select: { id: true, username: true, displayName: true }
-    }
-  }
-}).unwrap();
+const orders = await db.order
+  .findMany({
+    select: {
+      id: true,
+      orderNumber: true,
+      // Nested select for belongsTo relation
+      customer: {
+        select: { id: true, username: true, displayName: true },
+      },
+    },
+  })
+  .unwrap();
 
 // TypeScript knows:
 // orders.orders.nodes[0].customer is { id: string; username: string | null; displayName: string | null }
@@ -1280,18 +1358,20 @@ const orders = await db.order.findMany({
 
 ```typescript
 // Order.orderItems is a hasMany relation to OrderItem
-const orders = await db.order.findMany({
-  select: {
-    id: true,
-    // HasMany with pagination and filtering
-    orderItems: {
-      select: { id: true, quantity: true, price: true },
-      first: 10,  // Pagination
-      filter: { quantity: { greaterThan: 0 } },  // Filtering
-      orderBy: ['QUANTITY_DESC']  // Ordering
-    }
-  }
-}).unwrap();
+const orders = await db.order
+  .findMany({
+    select: {
+      id: true,
+      // HasMany with pagination and filtering
+      orderItems: {
+        select: { id: true, quantity: true, price: true },
+        first: 10, // Pagination
+        filter: { quantity: { greaterThan: 0 } }, // Filtering
+        orderBy: ['QUANTITY_DESC'], // Ordering
+      },
+    },
+  })
+  .unwrap();
 
 // orders.orders.nodes[0].orderItems is a connection:
 // { nodes: Array<{ id: string; quantity: number | null; price: number | null }>, totalCount: number, pageInfo: PageInfo }
@@ -1301,49 +1381,53 @@ const orders = await db.order.findMany({
 
 ```typescript
 // Order.productsByOrderItemOrderIdAndProductId is a manyToMany through OrderItem
-const orders = await db.order.findMany({
-  select: {
-    id: true,
-    productsByOrderItemOrderIdAndProductId: {
-      select: { id: true, name: true, price: true },
-      first: 5
-    }
-  }
-}).unwrap();
+const orders = await db.order
+  .findMany({
+    select: {
+      id: true,
+      productsByOrderItemOrderIdAndProductId: {
+        select: { id: true, name: true, price: true },
+        first: 5,
+      },
+    },
+  })
+  .unwrap();
 ```
 
 #### Deeply Nested Relations
 
 ```typescript
 // Multiple levels of nesting
-const products = await db.product.findMany({
-  select: {
-    id: true,
-    name: true,
-    // BelongsTo: Product -> User (seller)
-    seller: {
-      select: { 
-        id: true, 
-        username: true,
-        // Even deeper nesting if needed
-      }
-    },
-    // BelongsTo: Product -> Category
-    category: {
-      select: { id: true, name: true }
-    },
-    // HasMany: Product -> Review
-    reviews: {
-      select: { 
-        id: true, 
-        rating: true, 
-        comment: true 
+const products = await db.product
+  .findMany({
+    select: {
+      id: true,
+      name: true,
+      // BelongsTo: Product -> User (seller)
+      seller: {
+        select: {
+          id: true,
+          username: true,
+          // Even deeper nesting if needed
+        },
       },
-      first: 5,
-      orderBy: ['CREATED_AT_DESC']
-    }
-  }
-}).unwrap();
+      // BelongsTo: Product -> Category
+      category: {
+        select: { id: true, name: true },
+      },
+      // HasMany: Product -> Review
+      reviews: {
+        select: {
+          id: true,
+          rating: true,
+          comment: true,
+        },
+        first: 5,
+        orderBy: ['CREATED_AT_DESC'],
+      },
+    },
+  })
+  .unwrap();
 ```
 
 ### Filtering & Ordering
@@ -1462,13 +1546,15 @@ where: {
 #### Ordering
 
 ```typescript
-const users = await db.user.findMany({
-  select: { id: true, username: true, createdAt: true },
-  orderBy: [
-    'CREATED_AT_DESC',  // Newest first
-    'USERNAME_ASC',     // Then alphabetical
-  ]
-}).unwrap();
+const users = await db.user
+  .findMany({
+    select: { id: true, username: true, createdAt: true },
+    orderBy: [
+      'CREATED_AT_DESC', // Newest first
+      'USERNAME_ASC', // Then alphabetical
+    ],
+  })
+  .unwrap();
 
 // Available OrderBy values (generated per entity):
 // - PRIMARY_KEY_ASC / PRIMARY_KEY_DESC
@@ -1482,37 +1568,47 @@ The ORM supports cursor-based and offset pagination:
 
 ```typescript
 // First N records
-const first10 = await db.user.findMany({
-  select: { id: true },
-  first: 10
-}).unwrap();
+const first10 = await db.user
+  .findMany({
+    select: { id: true },
+    first: 10,
+  })
+  .unwrap();
 
 // Last N records
-const last10 = await db.user.findMany({
-  select: { id: true },
-  last: 10
-}).unwrap();
+const last10 = await db.user
+  .findMany({
+    select: { id: true },
+    last: 10,
+  })
+  .unwrap();
 
 // Cursor-based pagination (after/before)
-const page1 = await db.user.findMany({
-  select: { id: true },
-  first: 10
-}).unwrap();
+const page1 = await db.user
+  .findMany({
+    select: { id: true },
+    first: 10,
+  })
+  .unwrap();
 
 const endCursor = page1.users.pageInfo.endCursor;
 
-const page2 = await db.user.findMany({
-  select: { id: true },
-  first: 10,
-  after: endCursor  // Get records after this cursor
-}).unwrap();
+const page2 = await db.user
+  .findMany({
+    select: { id: true },
+    first: 10,
+    after: endCursor, // Get records after this cursor
+  })
+  .unwrap();
 
 // Offset pagination
-const page3 = await db.user.findMany({
-  select: { id: true },
-  first: 10,
-  offset: 20  // Skip first 20 records
-}).unwrap();
+const page3 = await db.user
+  .findMany({
+    select: { id: true },
+    first: 10,
+    offset: 20, // Skip first 20 records
+  })
+  .unwrap();
 
 // PageInfo structure
 // {
@@ -1523,7 +1619,7 @@ const page3 = await db.user.findMany({
 // }
 
 // Total count is always included
-console.log(page1.users.totalCount);  // Total matching records
+console.log(page1.users.totalCount); // Total matching records
 ```
 
 ### Error Handling
@@ -1533,9 +1629,11 @@ The ORM provides multiple ways to handle errors:
 #### Discriminated Union (Recommended)
 
 ```typescript
-const result = await db.user.findMany({
-  select: { id: true }
-}).execute();
+const result = await db.user
+  .findMany({
+    select: { id: true },
+  })
+  .execute();
 
 if (result.ok) {
   // TypeScript knows result.data is non-null
@@ -1555,10 +1653,12 @@ import { GraphQLRequestError } from './generated/orm';
 
 try {
   // Throws GraphQLRequestError if query fails
-  const data = await db.user.findMany({
-    select: { id: true }
-  }).unwrap();
-  
+  const data = await db.user
+    .findMany({
+      select: { id: true },
+    })
+    .unwrap();
+
   console.log(data.users.nodes);
 } catch (error) {
   if (error instanceof GraphQLRequestError) {
@@ -1572,15 +1672,17 @@ try {
 
 ```typescript
 // Returns default value if query fails (no throwing)
-const data = await db.user.findMany({
-  select: { id: true }
-}).unwrapOr({
-  users: {
-    nodes: [],
-    totalCount: 0,
-    pageInfo: { hasNextPage: false, hasPreviousPage: false }
-  }
-});
+const data = await db.user
+  .findMany({
+    select: { id: true },
+  })
+  .unwrapOr({
+    users: {
+      nodes: [],
+      totalCount: 0,
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+    },
+  });
 
 // Always returns data (either real or default)
 console.log(data.users.nodes);
@@ -1590,21 +1692,23 @@ console.log(data.users.nodes);
 
 ```typescript
 // Call a function to handle errors and return fallback
-const data = await db.user.findMany({
-  select: { id: true }
-}).unwrapOrElse((errors) => {
-  // Log errors, send to monitoring, etc.
-  console.error('Query failed:', errors.map(e => e.message).join(', '));
-  
-  // Return fallback data
-  return {
-    users: {
-      nodes: [],
-      totalCount: 0,
-      pageInfo: { hasNextPage: false, hasPreviousPage: false }
-    }
-  };
-});
+const data = await db.user
+  .findMany({
+    select: { id: true },
+  })
+  .unwrapOrElse((errors) => {
+    // Log errors, send to monitoring, etc.
+    console.error('Query failed:', errors.map((e) => e.message).join(', '));
+
+    // Return fallback data
+    return {
+      users: {
+        nodes: [],
+        totalCount: 0,
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      },
+    };
+  });
 ```
 
 #### Error Types
@@ -1619,7 +1723,7 @@ interface GraphQLError {
 
 class GraphQLRequestError extends Error {
   readonly errors: GraphQLError[];
-  readonly data: unknown;  // Partial data if available
+  readonly data: unknown; // Partial data if available
 }
 
 type QueryResult<T> =
@@ -1635,57 +1739,73 @@ Custom queries and mutations (like `login`, `currentUser`, etc.) are available o
 
 ```typescript
 // Query with select
-const currentUser = await db.query.currentUser({
-  select: { id: true, username: true, email: true }
-}).unwrap();
+const currentUser = await db.query
+  .currentUser({
+    select: { id: true, username: true, email: true },
+  })
+  .unwrap();
 
 // Query without select (returns full type)
 const me = await db.query.currentUser({}).unwrap();
 
 // Query with arguments
-const node = await db.query.nodeById({
-  id: 'some-node-id'
-}, {
-  select: { id: true }
-}).unwrap();
+const node = await db.query
+  .nodeById(
+    {
+      id: 'some-node-id',
+    },
+    {
+      select: { id: true },
+    }
+  )
+  .unwrap();
 ```
 
 #### Custom Mutations
 
 ```typescript
 // Login mutation with typed select
-const login = await db.mutation.login({
-  input: {
-    email: 'user@example.com',
-    password: 'secret123'
-  }
-}, {
-  select: {
-    clientMutationId: true,
-    apiToken: {
+const login = await db.mutation
+  .login(
+    {
+      input: {
+        email: 'user@example.com',
+        password: 'secret123',
+      },
+    },
+    {
       select: {
-        accessToken: true,
-        accessTokenExpiresAt: true
-      }
+        clientMutationId: true,
+        apiToken: {
+          select: {
+            accessToken: true,
+            accessTokenExpiresAt: true,
+          },
+        },
+      },
     }
-  }
-}).unwrap();
+  )
+  .unwrap();
 
 console.log(login.login.apiToken?.accessToken);
 
 // Register mutation
-const register = await db.mutation.register({
-  input: {
-    email: 'new@example.com',
-    password: 'secret123',
-    username: 'newuser'
-  }
-}).unwrap();
+const register = await db.mutation
+  .register({
+    input: {
+      email: 'new@example.com',
+      password: 'secret123',
+      username: 'newuser',
+    },
+  })
+  .unwrap();
 
 // Logout mutation
-await db.mutation.logout({
-  input: { clientMutationId: 'optional-id' }
-}).execute();
+await db.mutation
+  .logout({
+    input: { clientMutationId: 'optional-id' },
+  })
+  .execute();
 ```
 
 ### Query Builder API
@@ -1696,7 +1816,7 @@ Every operation returns a `QueryBuilder` that can be inspected before execution:
 const query = db.user.findMany({
   select: { id: true, username: true },
   where: { isActive: { equalTo: true } },
-  first: 10
+  first: 10,
 });
 
 // Inspect the generated GraphQL
@@ -1838,25 +1958,29 @@ export type OrderSelect = {
   id?: boolean;
   orderNumber?: boolean;
   status?: boolean;
-  
+
   // BelongsTo relation
   customer?: boolean | { select?: UserSelect };
-  
+
   // HasMany relation
-  orderItems?: boolean | {
-    select?: OrderItemSelect;
-    first?: number;
-    filter?: OrderItemFilter;
-    orderBy?: OrderItemsOrderBy[];
-  };
-  
+  orderItems?:
+    | boolean
+    | {
+        select?: OrderItemSelect;
+        first?: number;
+        filter?: OrderItemFilter;
+        orderBy?: OrderItemsOrderBy[];
+      };
+
   // ManyToMany relation
-  productsByOrderItemOrderIdAndProductId?: boolean | {
-    select?: ProductSelect;
-    first?: number;
-    filter?: ProductFilter;
-    orderBy?: ProductsOrderBy[];
-  };
+  productsByOrderItemOrderIdAndProductId?:
+    | boolean
+    | {
+        select?: ProductSelect;
+        first?: number;
+        filter?: ProductFilter;
+        orderBy?: ProductsOrderBy[];
+      };
 };
 ```
 
diff --git a/graphql/codegen/examples/multi-target.config.ts b/graphql/codegen/examples/multi-target.config.ts
new file mode 100644
index 000000000..5ca702a42
--- /dev/null
+++ b/graphql/codegen/examples/multi-target.config.ts
@@ -0,0 +1,17 @@
+import { defineConfig } from '../src/types/config';
+
+export default defineConfig({
+  defaults: {
+    endpoint: 'http://api.localhost:3000/graphql',
+  },
+  targets: {
+    public: {
+      output: './examples/output/generated-sdk-public',
+      orm: { output: './examples/output/generated-orm-public' },
+    },
+    admin: {
+      output: './examples/output/generated-sdk-admin',
+      orm: { output: './examples/output/generated-orm-admin' },
+    },
+  },
+});
diff --git a/graphql/codegen/examples/orm-sdk.ts b/graphql/codegen/examples/orm-sdk.ts
index 27a216780..ac88218fd 100644
--- a/graphql/codegen/examples/orm-sdk.ts
+++ b/graphql/codegen/examples/orm-sdk.ts
@@ -2,10 +2,7 @@
  * ORM SDK Example - Prisma-like API for GraphQL
  * Run: pnpm exec tsx examples/orm-sdk.ts
  */
-import {
-  createClient,
-  GraphQLRequestError,
-} from './output/generated-orm';
+import { createClient, GraphQLRequestError } from './output/generated-orm';
 
 const ENDPOINT = 'http://api.localhost:3000/graphql';
 let db = createClient({ endpoint: ENDPOINT });
diff --git a/graphql/codegen/examples/react-hooks-test.tsx b/graphql/codegen/examples/react-hooks-test.tsx
index 379cd5b28..e6a8080bb 100644
--- a/graphql/codegen/examples/react-hooks-test.tsx
+++ b/graphql/codegen/examples/react-hooks-test.tsx
@@ -40,15 +40,26 @@ import { useSignOutMutation } from './output/generated-sdk/mutations/useSignOutM
 import { useSignUpMutation } from './output/generated-sdk/mutations/useSignUpMutation';
 
 // Import types
-import type { UserFilter, DatabaseFilter, TableFilter } from './output/generated-sdk/schema-types';
+import type {
+  UserFilter,
+  DatabaseFilter,
+  TableFilter,
+} from './output/generated-sdk/schema-types';
 import type { User, Database, Table } from './output/generated-sdk/types';
 
 // Import client configuration
 import { configure } from './output/generated-sdk/client';
 
 // Import query/mutation keys for cache invalidation
-import { queryKeys, userKeys, customQueryKeys } from './output/generated-sdk/query-keys';
-import { mutationKeys, customMutationKeys } from './output/generated-sdk/mutation-keys';
+import {
+  queryKeys,
+  userKeys,
+  customQueryKeys,
+} from './output/generated-sdk/query-keys';
+import {
+  mutationKeys,
+  customMutationKeys,
+} from './output/generated-sdk/mutation-keys';
 import { invalidate } from './output/generated-sdk/invalidation';
 
 const queryClient = new QueryClient();
@@ -72,8 +83,10 @@ function UsersListComponent() {
   const users: User[] | undefined = data?.users?.nodes;
   const totalCount: number | undefined = data?.users?.totalCount;
   const hasNextPage: boolean | undefined = data?.users?.pageInfo.hasNextPage;
-  const hasPreviousPage: boolean | undefined = data?.users?.pageInfo.hasPreviousPage;
-  const startCursor: string | null | undefined = data?.users?.pageInfo.startCursor;
+  const hasPreviousPage: boolean | undefined =
+    data?.users?.pageInfo.hasPreviousPage;
+  const startCursor: string | null | undefined =
+    data?.users?.pageInfo.startCursor;
   const endCursor: string | null | undefined = data?.users?.pageInfo.endCursor;
 
   if (isLoading) return <div>Loading...</div>;
diff --git a/graphql/codegen/examples/single-target.config.ts b/graphql/codegen/examples/single-target.config.ts
new file mode 100644
index 000000000..9e7b858b3
--- /dev/null
+++ b/graphql/codegen/examples/single-target.config.ts
@@ -0,0 +1,13 @@
+import { defineConfig } from '../src/types/config';
+
+/**
+ * Single-target config (backward compatible format)
+ * Tests that the old config format without "targets" key still works.
+ */
+export default defineConfig({
+  endpoint: 'http://api.localhost:3000/graphql',
+  output: './examples/output/generated-sdk',
+  orm: {
+    output: './examples/output/generated-orm',
+  },
+});
diff --git a/graphql/codegen/package.json b/graphql/codegen/package.json
index d8d0eb603..9bcef917b 100644
--- a/graphql/codegen/package.json
+++ b/graphql/codegen/package.json
@@ -41,12 +41,13 @@
     "lint": "eslint . --fix",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "example:codegen:sdk": "node dist/cli/index.js generate --endpoint http://api.localhost:3000/graphql --output examples/output/generated-sdk",
-    "example:codegen:orm": "node dist/cli/index.js generate-orm --endpoint http://api.localhost:3000/graphql --output examples/output/generated-orm",
+    "example:codegen:sdk": "tsx src/cli/index.ts generate --config examples/multi-target.config.ts",
+    "example:codegen:orm": "tsx src/cli/index.ts generate-orm --config examples/multi-target.config.ts",
     "example:codegen:sdk:schema": "node dist/cli/index.js generate --schema examples/example.schema.graphql --output examples/output/generated-sdk-schema",
     "example:codegen:orm:schema": "node dist/cli/index.js generate-orm --schema examples/example.schema.graphql --output examples/output/generated-orm-schema",
     "example:sdk": "tsx examples/react-query-sdk.ts",
-    "example:orm": "tsx examples/orm-sdk.ts"
+    "example:orm": "tsx examples/orm-sdk.ts",
+    "example:sdk:typecheck": "tsc --noEmit --jsx react --esModuleInterop --skipLibCheck --moduleResolution node examples/react-hooks-test.tsx"
   },
   "dependencies": {
     "@babel/generator": "^7.28.5",
diff --git a/graphql/codegen/src/__tests__/config/resolve-config.test.ts b/graphql/codegen/src/__tests__/config/resolve-config.test.ts
new file mode 100644
index 000000000..455d8a6f7
--- /dev/null
+++ b/graphql/codegen/src/__tests__/config/resolve-config.test.ts
@@ -0,0 +1,123 @@
+import type {
+  GraphQLSDKConfigTarget,
+  GraphQLSDKMultiConfig,
+} from '../../types/config';
+import {
+  mergeConfig,
+  resolveConfig,
+  resolveConfigTargets,
+  isMultiConfig,
+  DEFAULT_CONFIG,
+} from '../../types/config';
+
+describe('config resolution', () => {
+  it('resolves single-target defaults', () => {
+    const config: GraphQLSDKConfigTarget = {
+      endpoint: 'https://api.example.com/graphql',
+    };
+
+    const resolved = resolveConfig(config);
+
+    expect(resolved.endpoint).toBe('https://api.example.com/graphql');
+    expect(resolved.schema).toBeNull();
+    expect(resolved.output).toBe(DEFAULT_CONFIG.output);
+    expect(resolved.tables.include).toEqual(DEFAULT_CONFIG.tables.include);
+    expect(resolved.queries.exclude).toEqual(DEFAULT_CONFIG.queries.exclude);
+  });
+
+  it('merges nested config values with overrides', () => {
+    const base: GraphQLSDKConfigTarget = {
+      headers: { Authorization: 'Bearer base' },
+      tables: { include: ['User'] },
+      queryKeys: {
+        relationships: {
+          database: { parent: 'organization', foreignKey: 'organizationId' },
+        },
+      },
+    };
+
+    const overrides: GraphQLSDKConfigTarget = {
+      output: './generated/custom',
+      headers: { 'X-Custom': '1' },
+      tables: { exclude: ['_internal'] },
+      queryKeys: {
+        relationships: {
+          table: { parent: 'database', foreignKey: 'databaseId' },
+        },
+      },
+    };
+
+    const merged = mergeConfig(base, overrides);
+
+    expect(merged.output).toBe('./generated/custom');
+    expect(merged.headers).toEqual({
+      Authorization: 'Bearer base',
+      'X-Custom': '1',
+    });
+    expect(merged.tables).toEqual({
+      include: ['User'],
+      exclude: ['_internal'],
+    });
+    expect(merged.queryKeys?.relationships).toEqual({
+      database: { parent: 'organization', foreignKey: 'organizationId' },
+      table: { parent: 'database', foreignKey: 'databaseId' },
+    });
+  });
+
+  it('resolves multi-target configs with defaults', () => {
+    const config: GraphQLSDKMultiConfig = {
+      defaults: {
+        headers: { Authorization: 'Bearer token' },
+        queries: { exclude: ['_meta'] },
+      },
+      targets: {
+        public: {
+          endpoint: 'https://api.example.com/graphql',
+          output: './generated/public',
+        },
+        admin: {
+          schema: './admin.schema.graphql',
+          output: './generated/admin',
+          headers: { 'X-Admin': '1' },
+        },
+      },
+    };
+
+    const resolvedTargets = resolveConfigTargets(config);
+    const publicTarget = resolvedTargets.find(
+      (target) => target.name === 'public'
+    );
+    const adminTarget = resolvedTargets.find(
+      (target) => target.name === 'admin'
+    );
+
+    expect(publicTarget?.config.output).toBe('./generated/public');
+    expect(publicTarget?.config.headers).toEqual({
+      Authorization: 'Bearer token',
+    });
+    expect(publicTarget?.config.queries.exclude).toEqual(['_meta']);
+
+    expect(adminTarget?.config.output).toBe('./generated/admin');
+    expect(adminTarget?.config.headers).toEqual({
+      Authorization: 'Bearer token',
+      'X-Admin': '1',
+    });
+    expect(adminTarget?.config.schema).toBe('./admin.schema.graphql');
+  });
+
+  it('detects multi-target configs', () => {
+    const multiConfig: GraphQLSDKMultiConfig = { targets: {} };
+    const singleConfig: GraphQLSDKConfigTarget = { endpoint: 'x' };
+
+    expect(isMultiConfig(multiConfig)).toBe(true);
+    expect(isMultiConfig(singleConfig)).toBe(false);
+  });
+
+  it('throws when resolving multi-target config with resolveConfig', () => {
+    const multiConfig: GraphQLSDKMultiConfig = { targets: {} };
+
+    expect(() => resolveConfig(multiConfig)).toThrow(
+      'Multi-target config cannot be resolved with resolveConfig(). Use resolveConfigTargets().'
+    );
+  });
+});
diff --git a/graphql/codegen/src/cli/commands/generate-orm.ts b/graphql/codegen/src/cli/commands/generate-orm.ts
index 07df2febc..10178f3f5 100644
--- a/graphql/codegen/src/cli/commands/generate-orm.ts
+++ b/graphql/codegen/src/cli/commands/generate-orm.ts
@@ -7,8 +7,12 @@
  * 3. Generates a Prisma-like ORM client with fluent API
  */
 
-import type { GraphQLSDKConfig, ResolvedConfig } from '../../types/config';
-import { resolveConfig } from '../../types/config';
+import type {
+  GraphQLSDKConfig,
+  GraphQLSDKConfigTarget,
+  ResolvedTargetConfig,
+} from '../../types/config';
+import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
 import {
   createSchemaSource,
   validateSourceOptions,
@@ -21,6 +25,8 @@ import { generateOrm } from '../codegen/orm';
 export interface GenerateOrmOptions {
   /** Path to config file */
   config?: string;
+  /** Named target in a multi-target config */
+  target?: string;
   /** GraphQL endpoint URL (overrides config) */
   endpoint?: string;
   /** Path to GraphQL schema file (.graphql) */
@@ -37,9 +43,22 @@ export interface GenerateOrmOptions {
   skipCustomOperations?: boolean;
 }
 
+export interface GenerateOrmTargetResult {
+  name: string;
+  output: string;
+  success: boolean;
+  message: string;
+  tables?: string[];
+  customQueries?: string[];
+  customMutations?: string[];
+  filesWritten?: string[];
+  errors?: string[];
+}
+
 export interface GenerateOrmResult {
   success: boolean;
   message: string;
+  targets?: GenerateOrmTargetResult[];
   tables?: string[];
   customQueries?: string[];
   customMutations?: string[];
@@ -53,10 +72,10 @@ export interface GenerateOrmResult {
 export async function generateOrmCommand(
   options: GenerateOrmOptions = {}
 ): Promise<GenerateOrmResult> {
-  const log = options.verbose ? console.log : () => {};
+  if (options.verbose) {
+    console.log('Loading configuration...');
+  }
 
-  // 1. Load config
-  log('Loading configuration...');
   const configResult = await loadConfig(options);
   if (!configResult.success) {
     return {
@@ -65,28 +84,88 @@ export async function generateOrmCommand(
     };
   }
 
-  const config = configResult.config!;
+  const targets = configResult.targets ?? [];
+  if (targets.length === 0) {
+    return {
+      success: false,
+      message: 'No targets resolved from configuration.',
+    };
+  }
+
+  const isMultiTarget = configResult.isMulti ?? targets.length > 1;
+  const results: GenerateOrmTargetResult[] = [];
+
+  for (const target of targets) {
+    const result = await generateOrmForTarget(target, options, isMultiTarget);
+    results.push(result);
+  }
+
+  if (!isMultiTarget) {
+    const [result] = results;
+    return {
+      success: result.success,
+      message: result.message,
+      targets: results,
+      tables: result.tables,
+      customQueries: result.customQueries,
+      customMutations: result.customMutations,
+      filesWritten: result.filesWritten,
+      errors: result.errors,
+    };
+  }
+
+  const successCount = results.filter((result) => result.success).length;
+  const failedCount = results.length - successCount;
+  const summaryMessage =
+    failedCount === 0
+      ? `Generated ORM clients for ${results.length} targets.`
+      : `Generated ORM clients for ${successCount} of ${results.length} targets.`;
+
+  return {
+    success: failedCount === 0,
+    message: summaryMessage,
+    targets: results,
+    errors:
+      failedCount > 0
+        ? results.flatMap((result) => result.errors ?? [])
+        : undefined,
+  };
+}
 
-  // Use ORM output directory if specified, otherwise default
+async function generateOrmForTarget(
+  target: ResolvedTargetConfig,
+  options: GenerateOrmOptions,
+  isMultiTarget: boolean
+): Promise<GenerateOrmTargetResult> {
+  const config = target.config;
   const outputDir = options.output || config.orm?.output || './generated/orm';
+  const prefix = isMultiTarget ? `[${target.name}] ` : '';
+  const log = options.verbose
+    ? (message: string) => console.log(`${prefix}${message}`)
+    : () => {};
+  const formatMessage = (message: string) =>
+    isMultiTarget ? `Target "${target.name}": ${message}` : message;
 
-  // Log source
-  if (config.schema) {
-    log(`  Schema: ${config.schema}`);
-  } else {
-    log(`  Endpoint: ${config.endpoint}`);
+  if (isMultiTarget) {
+    console.log(`\nTarget "${target.name}"`);
+    const sourceLabel = config.schema
+      ? `schema: ${config.schema}`
+      : `endpoint: ${config.endpoint}`;
+    console.log(`  Source: ${sourceLabel}`);
+    console.log(`  Output: ${outputDir}`);
   }
-  log(`  Output: ${outputDir}`);
 
-  // 2. Create schema source
+  // 1. Validate source
   const sourceValidation = validateSourceOptions({
     endpoint: config.endpoint || undefined,
     schema: config.schema || undefined,
   });
   if (!sourceValidation.valid) {
     return {
+      name: target.name,
+      output: outputDir,
       success: false,
-      message: sourceValidation.error!,
+      message: formatMessage(sourceValidation.error!),
     };
   }
 
@@ -97,7 +176,7 @@ export async function generateOrmCommand(
     headers: config.headers,
   });
 
-  // 3. Run the codegen pipeline
+  // 2. Run the codegen pipeline
   let pipelineResult;
   try {
     pipelineResult = await runCodegenPipeline({
@@ -108,24 +187,30 @@ export async function generateOrmCommand(
     });
   } catch (err) {
     return {
+      name: target.name,
+      output: outputDir,
       success: false,
-      message: `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
+      message: formatMessage(
+        `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`
+      ),
     };
   }
 
   const { tables, customOperations, stats } = pipelineResult;
 
-  // 4. Validate tables found
+  // 3. Validate tables found
   const tablesValidation = validateTablesFound(tables);
   if (!tablesValidation.valid) {
     return {
+      name: target.name,
+      output: outputDir,
       success: false,
-      message: tablesValidation.error!,
+      message: formatMessage(tablesValidation.error!),
     };
   }
 
-  // 5. Generate ORM code
-  console.log('Generating code...');
+  // 4. Generate ORM code
+  console.log(`${prefix}Generating code...`);
   const { files: generatedFiles, stats: genStats } = generateOrm({
     tables,
     customOperations: {
@@ -135,7 +220,7 @@ export async function generateOrmCommand(
     },
     config,
   });
-  console.log(`Generated ${genStats.totalFiles} files`);
+  console.log(`${prefix}Generated ${genStats.totalFiles} files`);
 
   log(`  ${genStats.tables} table models`);
   log(`  ${genStats.customQueries} custom query operations`);
@@ -146,8 +231,12 @@ export async function generateOrmCommand(
 
   if (options.dryRun) {
     return {
+      name: target.name,
+      output: outputDir,
       success: true,
-      message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`,
+      message: formatMessage(
+        `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`
+      ),
       tables: tables.map((t) => t.name),
       customQueries,
       customMutations,
@@ -155,7 +244,7 @@ export async function generateOrmCommand(
     };
   }
 
-  // 6. Write files
+  // 5. Write files
   log('Writing files...');
   const writeResult = await writeGeneratedFiles(generatedFiles, outputDir, [
     'models',
@@ -165,8 +254,12 @@ export async function generateOrmCommand(
 
   if (!writeResult.success) {
     return {
+      name: target.name,
+      output: outputDir,
       success: false,
-      message: `Failed to write files: ${writeResult.errors?.join(', ')}`,
+      message: formatMessage(
+        `Failed to write files: ${writeResult.errors?.join(', ')}`
+      ),
       errors: writeResult.errors,
     };
   }
@@ -175,8 +268,12 @@ export async function generateOrmCommand(
   const customOpsMsg = totalOps > 0 ? ` and ${totalOps} custom operations` : '';
 
   return {
+    name: target.name,
+    output: outputDir,
     success: true,
-    message: `Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`,
+    message: formatMessage(
+      `Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`
+    ),
     tables: tables.map((t) => t.name),
     customQueries,
     customMutations,
@@ -186,20 +283,46 @@ export async function generateOrmCommand(
 
 interface LoadConfigResult {
   success: boolean;
-  config?: ResolvedConfig;
+  targets?: ResolvedTargetConfig[];
+  isMulti?: boolean;
   error?: string;
 }
 
+function buildTargetOverrides(
+  options: GenerateOrmOptions
+): GraphQLSDKConfigTarget {
+  const overrides: GraphQLSDKConfigTarget = {};
+
+  if (options.endpoint) {
+    overrides.endpoint = options.endpoint;
+    overrides.schema = undefined;
+  }
+
+  if (options.schema) {
+    overrides.schema = options.schema;
+    overrides.endpoint = undefined;
+  }
+
+  return overrides;
+}
+
 async function loadConfig(
   options: GenerateOrmOptions
 ): Promise<LoadConfigResult> {
+  if (options.endpoint && options.schema) {
+    return {
+      success: false,
+      error: 'Cannot use both --endpoint and --schema. Choose one source.',
+    };
+  }
+
   // Find config file
   let configPath = options.config;
   if (!configPath) {
     configPath = findConfigFile() ?? undefined;
   }
 
-  let baseConfig: Partial<GraphQLSDKConfig> = {};
+  let baseConfig: GraphQLSDKConfig = {};
 
   if (configPath) {
     const loadResult = await loadConfigFile(configPath);
@@ -209,23 +332,76 @@ async function loadConfig(
     baseConfig = loadResult.config;
   }
 
-  // Override with CLI options
-  const mergedConfig: GraphQLSDKConfig = {
-    endpoint: options.endpoint || baseConfig.endpoint,
-    schema: options.schema || baseConfig.schema,
-    output: options.output || baseConfig.output,
-    headers: baseConfig.headers,
-    tables: baseConfig.tables,
-    queries: baseConfig.queries,
-    mutations: baseConfig.mutations,
-    excludeFields: baseConfig.excludeFields,
-    hooks: baseConfig.hooks,
-    postgraphile: baseConfig.postgraphile,
-    codegen: baseConfig.codegen,
-    orm: baseConfig.orm,
-  };
+  const overrides = buildTargetOverrides(options);
+
+  if (isMultiConfig(baseConfig)) {
+    if (Object.keys(baseConfig.targets).length === 0) {
+      return {
+        success: false,
+        error: 'Config file defines no targets.',
+      };
+    }
+
+    if (
+      !options.target &&
+      (options.endpoint || options.schema || options.output)
+    ) {
+      return {
+        success: false,
+        error:
+          'Multiple targets configured. Use --target with --endpoint, --schema, or --output.',
+      };
+    }
+
+    if (options.target && !baseConfig.targets[options.target]) {
+      return {
+        success: false,
+        error: `Target "${options.target}" not found in config file.`,
+      };
+    }
+
+    const selectedTargets = options.target
+      ? { [options.target]: baseConfig.targets[options.target] }
+      : baseConfig.targets;
+    const defaults = baseConfig.defaults ?? {};
+    const resolvedTargets: ResolvedTargetConfig[] = [];
+
+    for (const [name, target] of Object.entries(selectedTargets)) {
+      let mergedTarget = mergeConfig(defaults, target);
+      if (options.target && name === options.target) {
+        mergedTarget = mergeConfig(mergedTarget, overrides);
+      }
+
+      if (!mergedTarget.endpoint && !mergedTarget.schema) {
+        return {
+          success: false,
+          error: `Target "${name}" is missing an endpoint or schema.`,
+        };
+      }
+
+      resolvedTargets.push({
+        name,
+        config: resolveConfig(mergedTarget),
+      });
+    }
+
+    return {
+      success: true,
+      targets: resolvedTargets,
+      isMulti: true,
+    };
+  }
+
+  if (options.target) {
+    return {
+      success: false,
+      error:
+        'Config file does not define targets. Remove --target to continue.',
+    };
+  }
+
+  const mergedConfig = mergeConfig(baseConfig, overrides);
 
-  // Validate at least one source is provided
   if (!mergedConfig.endpoint && !mergedConfig.schema) {
     return {
       success: false,
@@ -234,8 +410,9 @@ async function loadConfig(
     };
   }
 
-  // Resolve with defaults
-  const config = resolveConfig(mergedConfig);
-
-  return { success: true, config };
+  return {
+    success: true,
+    targets: [{ name: 'default', config: resolveConfig(mergedConfig) }],
+    isMulti: false,
+  };
 }
diff --git a/graphql/codegen/src/cli/commands/generate.ts b/graphql/codegen/src/cli/commands/generate.ts
index 911465612..eb40ede6b 100644
--- a/graphql/codegen/src/cli/commands/generate.ts
+++ b/graphql/codegen/src/cli/commands/generate.ts
@@ -10,8 +10,12 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as prettier from 'prettier';
 
-import type { GraphQLSDKConfig, ResolvedConfig } from '../../types/config';
-import { resolveConfig } from '../../types/config';
+import type {
+  GraphQLSDKConfig,
+  GraphQLSDKConfigTarget,
+  ResolvedTargetConfig,
+} from '../../types/config';
+import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
 import {
   createSchemaSource,
   validateSourceOptions,
@@ -23,6 +27,8 @@ import { generate } from '../codegen';
 export interface GenerateOptions {
   /** Path to config file */
   config?: string;
+  /** Named target in a multi-target config */
+  target?: string;
   /** GraphQL endpoint URL (overrides config) */
   endpoint?: string;
   /** Path to GraphQL schema file (.graphql) */
@@ -39,9 +45,22 @@ export interface GenerateOptions {
   skipCustomOperations?: boolean;
 }
 
+export interface GenerateTargetResult {
+  name: string;
+  output: string;
+  success: boolean;
+  message: string;
+  tables?: string[];
+  customQueries?: string[];
+  customMutations?: string[];
+  filesWritten?: string[];
+  errors?: string[];
+}
+
 export interface GenerateResult {
   success: boolean;
   message: string;
+  targets?: GenerateTargetResult[];
   tables?: string[];
   customQueries?: string[];
   customMutations?: string[];
@@ -55,10 +74,10 @@ export interface GenerateResult {
 export async function generateCommand(
   options: GenerateOptions = {}
 ): Promise<GenerateResult> {
-  const log = options.verbose ? console.log : () => {};
+  if (options.verbose) {
+    console.log('Loading configuration...');
+  }
 
-  // 1. Load config
-  log('Loading configuration...');
   const configResult = await loadConfig(options);
   if (!configResult.success) {
     return {
@@ -67,25 +86,87 @@ export async function generateCommand(
     };
   }
 
-  const config = configResult.config!;
+  const targets = configResult.targets ?? [];
+  if (targets.length === 0) {
+    return {
+      success: false,
+      message: 'No targets resolved from configuration.',
+    };
+  }
 
-  // Log source
-  if (config.schema) {
-    log(`  Schema: ${config.schema}`);
-  } else {
-    log(`  Endpoint: ${config.endpoint}`);
+  const isMultiTarget = configResult.isMulti ?? targets.length > 1;
+  const results: GenerateTargetResult[] = [];
+
+  for (const target of targets) {
+    const result = await generateForTarget(target, options, isMultiTarget);
+    results.push(result);
   }
-  log(`  Output: ${config.output}`);
 
-  // 2. Create schema source
+  if (!isMultiTarget) {
+    const [result] = results;
+    return {
+      success: result.success,
+      message: result.message,
+      targets: results,
+      tables: result.tables,
+      customQueries: result.customQueries,
+      customMutations: result.customMutations,
+      filesWritten: result.filesWritten,
+      errors: result.errors,
+    };
+  }
+
+  const successCount = results.filter((result) => result.success).length;
+  const failedCount = results.length - successCount;
+  const summaryMessage =
+    failedCount === 0
+      ? `Generated SDK for ${results.length} targets.`
+      : `Generated SDK for ${successCount} of ${results.length} targets.`;
+
+  return {
+    success: failedCount === 0,
+    message: summaryMessage,
+    targets: results,
+    errors:
+      failedCount > 0
+        ? results.flatMap((result) => result.errors ?? [])
+        : undefined,
+  };
+}
+
+async function generateForTarget(
+  target: ResolvedTargetConfig,
+  options: GenerateOptions,
+  isMultiTarget: boolean
+): Promise<GenerateTargetResult> {
+  const config = target.config;
+  const prefix = isMultiTarget ? `[${target.name}] ` : '';
+  const log = options.verbose
+    ? (message: string) => console.log(`${prefix}${message}`)
+    : () => {};
+  const formatMessage = (message: string) =>
+    isMultiTarget ? `Target "${target.name}": ${message}` : message;
+
+  if (isMultiTarget) {
+    console.log(`\nTarget "${target.name}"`);
+    const sourceLabel = config.schema
+      ? `schema: ${config.schema}`
+      : `endpoint: ${config.endpoint}`;
+    console.log(`  Source: ${sourceLabel}`);
+    console.log(`  Output: ${config.output}`);
+  }
+
+  // 1. Validate source
   const sourceValidation = validateSourceOptions({
     endpoint: config.endpoint || undefined,
     schema: config.schema || undefined,
   });
   if (!sourceValidation.valid) {
     return {
+      name: target.name,
+      output: config.output,
       success: false,
-      message: sourceValidation.error!,
+      message: formatMessage(sourceValidation.error!),
     };
   }
 
@@ -96,7 +177,7 @@ export async function generateCommand(
     headers: config.headers,
   });
 
-  // 3. Run the codegen pipeline
+  // 2. Run the codegen pipeline
   let pipelineResult;
   try {
     pipelineResult = await runCodegenPipeline({
@@ -107,24 +188,30 @@ export async function generateCommand(
     });
   } catch (err) {
     return {
+      name: target.name,
+      output: config.output,
       success: false,
-      message: `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
+      message: formatMessage(
+        `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`
+      ),
     };
   }
 
   const { tables, customOperations, stats } = pipelineResult;
 
-  // 4. Validate tables found
+  // 3. Validate tables found
   const tablesValidation = validateTablesFound(tables);
   if (!tablesValidation.valid) {
     return {
+      name: target.name,
+      output: config.output,
       success: false,
-      message: tablesValidation.error!,
+      message: formatMessage(tablesValidation.error!),
     };
   }
 
-  // 5. Generate code
-  console.log('Generating code...');
+  // 4. Generate code
+  console.log(`${prefix}Generating code...`);
   const { files: generatedFiles, stats: genStats } = generate({
     tables,
     customOperations: {
@@ -134,7 +221,7 @@ export async function generateCommand(
     },
     config,
   });
-  console.log(`Generated ${genStats.totalFiles} files`);
+  console.log(`${prefix}Generated ${genStats.totalFiles} files`);
 
   log(`  ${genStats.queryHooks} table query hooks`);
   log(`  ${genStats.mutationHooks} table mutation hooks`);
@@ -146,8 +233,12 @@ export async function generateCommand(
 
   if (options.dryRun) {
     return {
+      name: target.name,
+      output: config.output,
       success: true,
-      message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`,
+      message: formatMessage(
+        `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`
+      ),
       tables: tables.map((t) => t.name),
       customQueries,
       customMutations,
@@ -155,7 +246,7 @@ export async function generateCommand(
     };
   }
 
-  // 6. Write files
+  // 5. Write files
   log('Writing files...');
   const writeResult = await writeGeneratedFiles(generatedFiles, config.output, [
     'queries',
@@ -164,8 +255,12 @@ export async function generateCommand(
 
   if (!writeResult.success) {
     return {
+      name: target.name,
+      output: config.output,
       success: false,
-      message: `Failed to write files: ${writeResult.errors?.join(', ')}`,
+      message: formatMessage(
+        `Failed to write files: ${writeResult.errors?.join(', ')}`
+      ),
       errors: writeResult.errors,
     };
   }
@@ -174,8 +269,12 @@ export async function generateCommand(
   const customOpsMsg = totalOps > 0 ? ` and ${totalOps} custom operations` : '';
 
   return {
+    name: target.name,
+    output: config.output,
     success: true,
-    message: `Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`,
+    message: formatMessage(
+      `Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`
+    ),
     tables: tables.map((t) => t.name),
     customQueries,
     customMutations,
@@ -185,18 +284,48 @@ export async function generateCommand(
 
 interface LoadConfigResult {
   success: boolean;
-  config?: ResolvedConfig;
+  targets?: ResolvedTargetConfig[];
+  isMulti?: boolean;
   error?: string;
 }
 
+function buildTargetOverrides(
+  options: GenerateOptions
+): GraphQLSDKConfigTarget {
+  const overrides: GraphQLSDKConfigTarget = {};
+
+  if (options.endpoint) {
+    overrides.endpoint = options.endpoint;
+    overrides.schema = undefined;
+  }
+
+  if (options.schema) {
+    overrides.schema = options.schema;
+    overrides.endpoint = undefined;
+  }
+
+  if (options.output) {
+    overrides.output = options.output;
+  }
+
+  return overrides;
+}
+
 async function loadConfig(options: GenerateOptions): Promise<LoadConfigResult> {
+  if (options.endpoint && options.schema) {
+    return {
+      success: false,
+      error: 'Cannot use both --endpoint and --schema. Choose one source.',
+    };
+  }
+
   // Find config file
   let configPath = options.config;
   if (!configPath) {
     configPath = findConfigFile() ?? undefined;
   }
 
-  let baseConfig: Partial<GraphQLSDKConfig> = {};
+  let baseConfig: GraphQLSDKConfig = {};
 
   if (configPath) {
     const loadResult = await loadConfigFile(configPath);
@@ -206,23 +335,76 @@ async function loadConfig(options: GenerateOptions): Promise<LoadConfigResult> {
     baseConfig = loadResult.config;
   }
 
-  // Override with CLI options
-  const mergedConfig: GraphQLSDKConfig = {
-    endpoint: options.endpoint || baseConfig.endpoint,
-    schema: options.schema || baseConfig.schema,
-    output: options.output || baseConfig.output,
-    headers: baseConfig.headers,
-    tables: baseConfig.tables,
-    queries: baseConfig.queries,
-    mutations: baseConfig.mutations,
-    excludeFields: baseConfig.excludeFields,
-    hooks: baseConfig.hooks,
-    postgraphile: baseConfig.postgraphile,
-    codegen: baseConfig.codegen,
-    reactQuery: baseConfig.reactQuery,
-  };
+  const overrides = buildTargetOverrides(options);
+
+  if (isMultiConfig(baseConfig)) {
+    if (Object.keys(baseConfig.targets).length === 0) {
+      return {
+        success: false,
+        error: 'Config file defines no targets.',
+      };
+    }
+
+    if (
+      !options.target &&
+      (options.endpoint || options.schema || options.output)
+    ) {
+      return {
+        success: false,
+        error:
+          'Multiple targets configured. Use --target with --endpoint, --schema, or --output.',
+      };
+    }
+
+    if (options.target && !baseConfig.targets[options.target]) {
+      return {
+        success: false,
+        error: `Target "${options.target}" not found in config file.`,
+      };
+    }
+
+    const selectedTargets = options.target
+      ? { [options.target]: baseConfig.targets[options.target] }
+      : baseConfig.targets;
+    const defaults = baseConfig.defaults ?? {};
+    const resolvedTargets: ResolvedTargetConfig[] = [];
+
+    for (const [name, target] of Object.entries(selectedTargets)) {
+      let mergedTarget = mergeConfig(defaults, target);
+      if (options.target && name === options.target) {
+        mergedTarget = mergeConfig(mergedTarget, overrides);
+      }
+
+      if (!mergedTarget.endpoint && !mergedTarget.schema) {
+        return {
+          success: false,
+          error: `Target "${name}" is missing an endpoint or schema.`,
+        };
+      }
+
+      resolvedTargets.push({
+        name,
+        config: resolveConfig(mergedTarget),
+      });
+    }
+
+    return {
+      success: true,
+      targets: resolvedTargets,
+      isMulti: true,
+    };
+  }
+
+  if (options.target) {
+    return {
+      success: false,
+      error:
+        'Config file does not define targets. Remove --target to continue.',
+    };
+  }
+
+  const mergedConfig = mergeConfig(baseConfig, overrides);
 
-  // Validate at least one source is provided
   if (!mergedConfig.endpoint && !mergedConfig.schema) {
     return {
       success: false,
@@ -231,10 +413,11 @@ async function loadConfig(options: GenerateOptions): Promise<LoadConfigResult> {
     };
   }
 
-  // Resolve with defaults
-  const config = resolveConfig(mergedConfig);
-
-  return { success: true, config };
+  return {
+    success: true,
+    targets: [{ name: 'default', config: resolveConfig(mergedConfig) }],
+    isMulti: false,
+  };
 }
 
 export interface GeneratedFile {
diff --git a/graphql/codegen/src/cli/commands/init.ts b/graphql/codegen/src/cli/commands/init.ts
index c8c5b2ba8..e3a6497aa 100644
--- a/graphql/codegen/src/cli/commands/init.ts
+++ b/graphql/codegen/src/cli/commands/init.ts
@@ -27,6 +27,15 @@ export default defineConfig({
   // Output directory for generated files
   output: '{{OUTPUT}}',
 
+  // Optional: Multi-target config (use instead of endpoint/output)
+  // defaults: {
+  //   headers: { Authorization: 'Bearer YOUR_TOKEN' },
+  // },
+  // targets: {
+  //   public: { endpoint: 'https://api.example.com/graphql', output: './generated/public' },
+  //   admin: { schema: './admin.schema.graphql', output: './generated/admin' },
+  // },
+
   // Optional: Tables to include/exclude (supports glob patterns)
   // tables: {
   //   include: ['*'],
@@ -57,8 +66,15 @@ export interface InitResult {
 /**
  * Execute the init command
  */
-export async function initCommand(options: InitOptions = {}): Promise<InitResult> {
-  const { directory = process.cwd(), force = false, endpoint = '', output = './generated' } = options;
+export async function initCommand(
+  options: InitOptions = {}
+): Promise<InitResult> {
+  const {
+    directory = process.cwd(),
+    force = false,
+    endpoint = '',
+    output = './generated',
+  } = options;
 
   const configPath = path.join(directory, CONFIG_FILENAME);
 
@@ -71,9 +87,10 @@ export async function initCommand(options: InitOptions = {}): Promise<InitResult
   }
 
   // Generate config content
-  const content = CONFIG_TEMPLATE
-    .replace('{{ENDPOINT}}', endpoint || 'http://localhost:5000/graphql')
-    .replace('{{OUTPUT}}', output);
+  const content = CONFIG_TEMPLATE.replace(
+    '{{ENDPOINT}}',
+    endpoint || 'http://localhost:5000/graphql'
+  ).replace('{{OUTPUT}}', output);
 
   try {
     // Ensure directory exists
@@ -99,7 +116,9 @@ export async function initCommand(options: InitOptions = {}): Promise<InitResult
 /**
  * Find the nearest config file by walking up directories
  */
-export function findConfigFile(startDir: string = process.cwd()): string | null {
+export function findConfigFile(
+  startDir: string = process.cwd()
+): string | null {
   let currentDir = startDir;
 
   while (true) {
@@ -119,7 +138,7 @@ export function findConfigFile(startDir: string = process.cwd()): string | null
 
 /**
  * Load and validate a config file
- * 
+ *
  * Uses jiti to support TypeScript config files (.ts) in addition to
  * JavaScript (.js, .mjs, .cjs) without requiring the user to have
  * tsx or ts-node installed.
@@ -130,10 +149,12 @@ export async function loadConfigFile(configPath: string): Promise<{
   config?: any;
   error?: string;
 }> {
-  if (!fs.existsSync(configPath)) {
+  const resolvedPath = path.resolve(configPath);
+
+  if (!fs.existsSync(resolvedPath)) {
     return {
       success: false,
-      error: `Config file not found: ${configPath}`,
+      error: `Config file not found: ${resolvedPath}`,
     };
   }
 
@@ -146,7 +167,7 @@ export async function loadConfigFile(configPath: string): Promise<{
     });
 
     // jiti.import() with { default: true } returns mod?.default ?? mod
-    const config = await jiti.import(configPath, { default: true });
+    const config = await jiti.import(resolvedPath, { default: true });
 
     if (!config || typeof config !== 'object') {
       return {
@@ -155,13 +176,27 @@ export async function loadConfigFile(configPath: string): Promise<{
       };
     }
 
-    if (!('endpoint' in config)) {
+    const hasEndpoint = 'endpoint' in config;
+    const hasSchema = 'schema' in config;
+    const hasTargets = 'targets' in config;
+
+    if (!hasEndpoint && !hasSchema && !hasTargets) {
       return {
         success: false,
-        error: 'Config file missing required "endpoint" property',
+        error: 'Config file must define "endpoint", "schema", or "targets".',
       };
     }
 
+    if (hasTargets) {
+      const targets = config.targets as unknown;
+      if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
+        return {
+          success: false,
+          error: 'Config file "targets" must be an object of named configs.',
+        };
+      }
+    }
+
     return {
       success: true,
       config,
diff --git a/graphql/codegen/src/cli/index.ts b/graphql/codegen/src/cli/index.ts
index 010c8b40a..c30b8efd3 100644
--- a/graphql/codegen/src/cli/index.ts
+++ b/graphql/codegen/src/cli/index.ts
@@ -9,8 +9,11 @@ import { generateCommand } from './commands/generate';
 import { generateOrmCommand } from './commands/generate-orm';
 import { startWatch } from './watch';
 import {
+  isMultiConfig,
+  mergeConfig,
   resolveConfig,
   type GraphQLSDKConfig,
+  type GraphQLSDKConfigTarget,
   type ResolvedConfig,
 } from '../types/config';
 
@@ -21,7 +24,9 @@ const program = new Command();
  */
 async function loadWatchConfig(options: {
   config?: string;
+  target?: string;
   endpoint?: string;
+  output?: string;
   pollInterval?: number;
   debounce?: number;
   touch?: string;
@@ -33,7 +38,7 @@ async function loadWatchConfig(options: {
     configPath = findConfigFile() ?? undefined;
   }
 
-  let baseConfig: Partial<GraphQLSDKConfig> = {};
+  let baseConfig: GraphQLSDKConfig = {};
 
   if (configPath) {
     const loadResult = await loadConfigFile(configPath);
@@ -44,23 +49,31 @@ async function loadWatchConfig(options: {
     baseConfig = loadResult.config;
   }
 
-  // Merge CLI options with config
-  const mergedConfig: GraphQLSDKConfig = {
-    endpoint: options.endpoint || baseConfig.endpoint || '',
-    output: baseConfig.output,
-    headers: baseConfig.headers,
-    tables: baseConfig.tables,
-    queries: baseConfig.queries,
-    mutations: baseConfig.mutations,
-    excludeFields: baseConfig.excludeFields,
-    hooks: baseConfig.hooks,
-    postgraphile: baseConfig.postgraphile,
-    codegen: baseConfig.codegen,
-    orm: baseConfig.orm,
-    reactQuery: baseConfig.reactQuery,
+  if (isMultiConfig(baseConfig)) {
+    if (!options.target) {
+      console.error(
+        'x Watch mode requires --target when using multiple targets.'
+      );
+      return null;
+    }
+
+    if (!baseConfig.targets[options.target]) {
+      console.error(`x Target "${options.target}" not found in config file.`);
+      return null;
+    }
+  } else if (options.target) {
+    console.error('x Config file does not define targets. Remove --target.');
+    return null;
+  }
+
+  const sourceOverrides: GraphQLSDKConfigTarget = {};
+  if (options.endpoint) {
+    sourceOverrides.endpoint = options.endpoint;
+    sourceOverrides.schema = undefined;
+  }
+
+  const watchOverrides: GraphQLSDKConfigTarget = {
     watch: {
-      ...baseConfig.watch,
-      // CLI options override config
       ...(options.pollInterval !== undefined && {
         pollInterval: options.pollInterval,
       }),
@@ -70,14 +83,34 @@ async function loadWatchConfig(options: {
     },
   };
 
-  if (!mergedConfig.endpoint) {
+  let mergedTarget: GraphQLSDKConfigTarget;
+
+  if (isMultiConfig(baseConfig)) {
+    const defaults = baseConfig.defaults ?? {};
+    const targetConfig = baseConfig.targets[options.target!];
+    mergedTarget = mergeConfig(defaults, targetConfig);
+  } else {
+    mergedTarget = baseConfig;
+  }
+
+  mergedTarget = mergeConfig(mergedTarget, sourceOverrides);
+  mergedTarget = mergeConfig(mergedTarget, watchOverrides);
+
+  if (!mergedTarget.endpoint) {
     console.error(
-      'x No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".'
+      'x No endpoint specified. Watch mode only supports live endpoints.'
     );
     return null;
   }
 
-  return resolveConfig(mergedConfig);
+  if (mergedTarget.schema) {
+    console.error(
+      'x Watch mode is only supported with an endpoint, not schema.'
+    );
+    return null;
+  }
+
+  return resolveConfig(mergedTarget);
 }
 
 program
@@ -120,6 +153,7 @@ program
   .command('generate')
   .description('Generate SDK from GraphQL endpoint or schema file')
   .option('-c, --config <path>', 'Path to config file')
+  .option('-t, --target <name>', 'Target name in config file')
   .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
   .option('-s, --schema <path>', 'Path to GraphQL schema file (.graphql)')
   .option('-o, --output <dir>', 'Output directory (overrides config)')
@@ -174,6 +208,8 @@ program
         generatorType: 'generate',
         verbose: options.verbose,
         authorization: options.authorization,
+        configPath: options.config,
+        target: options.target,
         outputDir: options.output,
       });
       return;
@@ -182,6 +218,7 @@ program
     // Normal one-shot generation
     const result = await generateCommand({
       config: options.config,
+      target: options.target,
       endpoint: options.endpoint,
       schema: options.schema,
       output: options.output,
@@ -190,6 +227,36 @@ program
       dryRun: options.dryRun,
     });
 
+    const targetResults = result.targets ?? [];
+    const hasNamedTargets =
+      targetResults.length > 0 &&
+      (targetResults.length > 1 || targetResults[0]?.name !== 'default');
+
+    if (hasNamedTargets) {
+      console.log(result.success ? '[ok]' : 'x', result.message);
+      targetResults.forEach((target) => {
+        const status = target.success ? '[ok]' : 'x';
+        console.log(`\n${status} ${target.message}`);
+
+        if (target.tables && target.tables.length > 0) {
+          console.log('  Tables:');
+          target.tables.forEach((table) => console.log(`    - ${table}`));
+        }
+        if (target.filesWritten && target.filesWritten.length > 0) {
+          console.log('  Files written:');
+          target.filesWritten.forEach((file) => console.log(`    - ${file}`));
+        }
+        if (!target.success && target.errors) {
+          target.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      });
+
+      if (!result.success) {
+        process.exit(1);
+      }
+      return;
+    }
+
     if (result.success) {
       console.log('[ok]', result.message);
       if (result.tables && result.tables.length > 0) {
@@ -216,13 +283,10 @@ program
     'Generate Prisma-like ORM client from GraphQL endpoint or schema file'
   )
   .option('-c, --config <path>', 'Path to config file')
+  .option('-t, --target <name>', 'Target name in config file')
   .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
   .option('-s, --schema <path>', 'Path to GraphQL schema file (.graphql)')
-  .option(
-    '-o, --output <dir>',
-    'Output directory (overrides config)',
-    './generated/orm'
-  )
+  .option('-o, --output <dir>', 'Output directory (overrides config)')
   .option('-a, --authorization <header>', 'Authorization header value')
   .option('-v, --verbose', 'Verbose output', false)
   .option(
@@ -279,6 +343,8 @@ program
         generatorType: 'generate-orm',
         verbose: options.verbose,
         authorization: options.authorization,
+        configPath: options.config,
+        target: options.target,
         outputDir: options.output,
         skipCustomOperations: options.skipCustomOperations,
       });
@@ -288,6 +354,7 @@ program
     // Normal one-shot generation
     const result = await generateOrmCommand({
       config: options.config,
+      target: options.target,
       endpoint: options.endpoint,
       schema: options.schema,
       output: options.output,
@@ -297,6 +364,48 @@ program
       skipCustomOperations: options.skipCustomOperations,
     });
 
+    const targetResults = result.targets ?? [];
+    const hasNamedTargets =
+      targetResults.length > 0 &&
+      (targetResults.length > 1 || targetResults[0]?.name !== 'default');
+
+    if (hasNamedTargets) {
+      console.log(result.success ? '[ok]' : 'x', result.message);
+      targetResults.forEach((target) => {
+        const status = target.success ? '[ok]' : 'x';
+        console.log(`\n${status} ${target.message}`);
+
+        if (target.tables && target.tables.length > 0) {
+          console.log('  Tables:');
+          target.tables.forEach((table) => console.log(`    - ${table}`));
+        }
+        if (target.customQueries && target.customQueries.length > 0) {
+          console.log('  Custom Queries:');
+          target.customQueries.forEach((query) =>
+            console.log(`    - ${query}`)
+          );
+        }
+        if (target.customMutations && target.customMutations.length > 0) {
+          console.log('  Custom Mutations:');
+          target.customMutations.forEach((mutation) =>
+            console.log(`    - ${mutation}`)
+          );
+        }
+        if (target.filesWritten && target.filesWritten.length > 0) {
+          console.log('  Files written:');
+          target.filesWritten.forEach((file) => console.log(`    - ${file}`));
+        }
+        if (!target.success && target.errors) {
+          target.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      });
+
+      if (!result.success) {
+        process.exit(1);
+      }
+      return;
+    }
+
     if (result.success) {
       console.log('[ok]', result.message);
       if (result.tables && result.tables.length > 0) {
diff --git a/graphql/codegen/src/cli/watch/orchestrator.ts b/graphql/codegen/src/cli/watch/orchestrator.ts
index 52615fd60..71b973328 100644
--- a/graphql/codegen/src/cli/watch/orchestrator.ts
+++ b/graphql/codegen/src/cli/watch/orchestrator.ts
@@ -1,6 +1,6 @@
 /**
  * Watch mode orchestrator
- * 
+ *
  * Coordinates schema polling, change detection, and code regeneration
  */
 
@@ -9,13 +9,20 @@ import type { GeneratorType, WatchOptions, PollEvent } from './types';
 import { SchemaPoller } from './poller';
 import { debounce } from './debounce';
 import { generateCommand, type GenerateResult } from '../commands/generate';
-import { generateOrmCommand, type GenerateOrmResult } from '../commands/generate-orm';
+import {
+  generateOrmCommand,
+  type GenerateOrmResult,
+} from '../commands/generate-orm';
 
 export interface WatchOrchestratorOptions {
   config: ResolvedConfig;
   generatorType: GeneratorType;
   verbose: boolean;
   authorization?: string;
+  /** Config file path for regeneration */
+  configPath?: string;
+  /** Target name for multi-target configs */
+  target?: string;
   /** Override output directory (for ORM) */
   outputDir?: string;
   /** Skip custom operations flag */
@@ -143,7 +150,9 @@ export class WatchOrchestrator {
 
     // Start polling loop
     this.poller.start();
-    this.log(`Watching for schema changes (poll interval: ${this.watchOptions.pollInterval}ms)`);
+    this.log(
+      `Watching for schema changes (poll interval: ${this.watchOptions.pollInterval}ms)`
+    );
   }
 
   /**
@@ -174,7 +183,7 @@ export class WatchOrchestrator {
     }
 
     const startTime = Date.now();
-    
+
     if (this.watchOptions.clearScreen) {
       this.clearScreen();
       this.logHeader();
@@ -187,6 +196,8 @@ export class WatchOrchestrator {
 
       if (this.options.generatorType === 'generate') {
         result = await generateCommand({
+          config: this.options.configPath,
+          target: this.options.target,
           endpoint: this.options.config.endpoint,
           output: this.options.outputDir ?? this.options.config.output,
           authorization: this.options.authorization,
@@ -195,6 +206,8 @@ export class WatchOrchestrator {
         });
       } else {
         result = await generateOrmCommand({
+          config: this.options.configPath,
+          target: this.options.target,
           endpoint: this.options.config.endpoint,
           output: this.options.outputDir ?? this.options.config.orm?.output,
           authorization: this.options.authorization,
@@ -209,7 +222,7 @@ export class WatchOrchestrator {
         this.status.regenerateCount++;
         this.status.lastRegenTime = Date.now();
         this.logSuccess(`Generated in ${duration}ms`);
-        
+
         if (result.tables && result.tables.length > 0) {
           this.log(`  Tables: ${result.tables.length}`);
         }
@@ -247,9 +260,10 @@ export class WatchOrchestrator {
   }
 
   private logHeader(): void {
-    const generatorName = this.options.generatorType === 'generate' 
-      ? 'React Query hooks' 
-      : 'ORM client';
+    const generatorName =
+      this.options.generatorType === 'generate'
+        ? 'React Query hooks'
+        : 'ORM client';
     console.log(`\n${'─'.repeat(50)}`);
     console.log(`graphql-codegen watch mode (${generatorName})`);
     console.log(`Endpoint: ${this.options.config.endpoint}`);
@@ -275,7 +289,9 @@ export class WatchOrchestrator {
 /**
  * Start watch mode for a generator
  */
-export async function startWatch(options: WatchOrchestratorOptions): Promise<void> {
+export async function startWatch(
+  options: WatchOrchestratorOptions
+): Promise<void> {
   const orchestrator = new WatchOrchestrator(options);
   await orchestrator.start();
 
diff --git a/graphql/codegen/src/types/config.ts b/graphql/codegen/src/types/config.ts
index 68da99efb..b271ad080 100644
--- a/graphql/codegen/src/types/config.ts
+++ b/graphql/codegen/src/types/config.ts
@@ -64,9 +64,10 @@ export interface QueryKeyConfig {
 }
 
 /**
- * Main configuration for graphql-codegen
+ * Target configuration for graphql-codegen
+ * Represents a single schema source and output destination.
  */
-export interface GraphQLSDKConfig {
+export interface GraphQLSDKConfigTarget {
   /**
    * GraphQL endpoint URL for live introspection
    * Either endpoint or schema must be provided
@@ -201,6 +202,26 @@ export interface GraphQLSDKConfig {
   watch?: WatchConfig;
 }
 
+/**
+ * Multi-target configuration for graphql-codegen
+ */
+export interface GraphQLSDKMultiConfig {
+  /**
+   * Shared defaults applied to every target
+   */
+  defaults?: GraphQLSDKConfigTarget;
+
+  /**
+   * Named target configurations
+   */
+  targets: Record<string, GraphQLSDKConfigTarget>;
+}
+
+/**
+ * Main configuration type for graphql-codegen
+ */
+export type GraphQLSDKConfig = GraphQLSDKConfigTarget | GraphQLSDKMultiConfig;
+
 /**
  * Watch mode configuration options
  *
@@ -380,10 +401,120 @@ export function defineConfig(config: GraphQLSDKConfig): GraphQLSDKConfig {
   return config;
 }
 
+/**
+ * Resolved target configuration helper
+ */
+export interface ResolvedTargetConfig {
+  name: string;
+  config: ResolvedConfig;
+}
+
+/**
+ * Type guard for multi-target configs
+ */
+export function isMultiConfig(
+  config: GraphQLSDKConfig
+): config is GraphQLSDKMultiConfig {
+  const targets = (config as GraphQLSDKMultiConfig).targets;
+  return typeof targets === 'object' && targets !== null;
+}
+
+/**
+ * Merge two target configs (defaults + overrides)
+ */
+export function mergeConfig(
+  base: GraphQLSDKConfigTarget,
+  overrides: GraphQLSDKConfigTarget
+): GraphQLSDKConfigTarget {
+  const headers =
+    base.headers || overrides.headers
+      ? { ...(base.headers ?? {}), ...(overrides.headers ?? {}) }
+      : undefined;
+
+  const tables =
+    base.tables || overrides.tables
+      ? { ...(base.tables ?? {}), ...(overrides.tables ?? {}) }
+      : undefined;
+
+  const queries =
+    base.queries || overrides.queries
+      ? { ...(base.queries ?? {}), ...(overrides.queries ?? {}) }
+      : undefined;
+
+  const mutations =
+    base.mutations || overrides.mutations
+      ? { ...(base.mutations ?? {}), ...(overrides.mutations ?? {}) }
+      : undefined;
+
+  const hooks =
+    base.hooks || overrides.hooks
+      ? { ...(base.hooks ?? {}), ...(overrides.hooks ?? {}) }
+      : undefined;
+
+  const postgraphile =
+    base.postgraphile || overrides.postgraphile
+      ? { ...(base.postgraphile ?? {}), ...(overrides.postgraphile ?? {}) }
+      : undefined;
+
+  const codegen =
+    base.codegen || overrides.codegen
+      ? { ...(base.codegen ?? {}), ...(overrides.codegen ?? {}) }
+      : undefined;
+
+  const orm =
+    base.orm || overrides.orm
+      ? { ...(base.orm ?? {}), ...(overrides.orm ?? {}) }
+      : undefined;
+
+  const reactQuery =
+    base.reactQuery || overrides.reactQuery
+      ? { ...(base.reactQuery ?? {}), ...(overrides.reactQuery ?? {}) }
+      : undefined;
+
+  const queryKeys =
+    base.queryKeys || overrides.queryKeys
+      ? {
+          ...(base.queryKeys ?? {}),
+          ...(overrides.queryKeys ?? {}),
+          relationships: {
+            ...(base.queryKeys?.relationships ?? {}),
+            ...(overrides.queryKeys?.relationships ?? {}),
+          },
+        }
+      : undefined;
+
+  const watch =
+    base.watch || overrides.watch
+      ? { ...(base.watch ?? {}), ...(overrides.watch ?? {}) }
+      : undefined;
+
+  return {
+    ...base,
+    ...overrides,
+    headers,
+    tables,
+    queries,
+    mutations,
+    hooks,
+    postgraphile,
+    codegen,
+    orm,
+    reactQuery,
+    queryKeys,
+    watch,
+  };
+}
+
 /**
  * Resolve configuration by applying defaults
  */
 export function resolveConfig(config: GraphQLSDKConfig): ResolvedConfig {
+  if (isMultiConfig(config)) {
+    throw new Error(
+      'Multi-target config cannot be resolved with resolveConfig(). Use resolveConfigTargets().'
+    );
+  }
+
   return {
     endpoint: config.endpoint ?? '',
     schema: config.schema ?? null,
@@ -429,10 +560,18 @@ export function resolveConfig(config: GraphQLSDKConfig): ResolvedConfig {
     },
     queryKeys: {
       style: config.queryKeys?.style ?? DEFAULT_QUERY_KEY_CONFIG.style,
-      relationships: config.queryKeys?.relationships ?? DEFAULT_QUERY_KEY_CONFIG.relationships,
-      generateScopedKeys: config.queryKeys?.generateScopedKeys ?? DEFAULT_QUERY_KEY_CONFIG.generateScopedKeys,
-      generateCascadeHelpers: config.queryKeys?.generateCascadeHelpers ?? DEFAULT_QUERY_KEY_CONFIG.generateCascadeHelpers,
-      generateMutationKeys: config.queryKeys?.generateMutationKeys ?? DEFAULT_QUERY_KEY_CONFIG.generateMutationKeys,
+      relationships:
+        config.queryKeys?.relationships ??
+        DEFAULT_QUERY_KEY_CONFIG.relationships,
+      generateScopedKeys:
+        config.queryKeys?.generateScopedKeys ??
+        DEFAULT_QUERY_KEY_CONFIG.generateScopedKeys,
+      generateCascadeHelpers:
+        config.queryKeys?.generateCascadeHelpers ??
+        DEFAULT_QUERY_KEY_CONFIG.generateCascadeHelpers,
+      generateMutationKeys:
+        config.queryKeys?.generateMutationKeys ??
+        DEFAULT_QUERY_KEY_CONFIG.generateMutationKeys,
     },
     watch: {
       pollInterval:
@@ -444,3 +583,17 @@ export function resolveConfig(config: GraphQLSDKConfig): ResolvedConfig {
     },
   };
 }
+
+/**
+ * Resolve all targets in a multi-target config
+ */
+export function resolveConfigTargets(
+  config: GraphQLSDKMultiConfig
+): ResolvedTargetConfig[] {
+  const defaults = config.defaults ?? {};
+
+  return Object.entries(config.targets).map(([name, target]) => ({
+    name,
+    config: resolveConfig(mergeConfig(defaults, target)),
+  }));
+}
diff --git a/graphql/codegen/src/types/index.ts b/graphql/codegen/src/types/index.ts
index 13dc5f8ee..0498e391e 100644
--- a/graphql/codegen/src/types/index.ts
+++ b/graphql/codegen/src/types/index.ts
@@ -51,7 +51,15 @@ export type {
 // Config types
 export type {
   GraphQLSDKConfig,
+  GraphQLSDKConfigTarget,
+  GraphQLSDKMultiConfig,
   ResolvedConfig,
+  ResolvedTargetConfig,
 } from './config';
 
-export { defineConfig, resolveConfig, DEFAULT_CONFIG } from './config';
+export {
+  defineConfig,
+  resolveConfig,
+  resolveConfigTargets,
+  DEFAULT_CONFIG,
+} from './config';
diff --git a/packages/cli/src/commands/codegen.ts b/packages/cli/src/commands/codegen.ts
index df220bb96..9e67a4a83 100644
--- a/packages/cli/src/commands/codegen.ts
+++ b/packages/cli/src/commands/codegen.ts
@@ -1,10 +1,17 @@
-import { CLIOptions, Inquirerer } from 'inquirerer'
-import { ParsedArgs } from 'minimist'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import { buildSchemaSDL } from '@constructive-io/graphql-server'
-import { generateCommand } from '@constructive-io/graphql-codegen/cli/commands/generate'
-import { ConstructiveOptions, getEnvOptions } from '@constructive-io/graphql-env'
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { buildSchemaSDL } from '@constructive-io/graphql-server';
+import {
+  generateCommand,
+  type GenerateTargetResult,
+} from '@constructive-io/graphql-codegen/cli/commands/generate';
+import { findConfigFile } from '@constructive-io/graphql-codegen/cli/commands/init';
+import {
+  ConstructiveOptions,
+  getEnvOptions,
+} from '@constructive-io/graphql-env';
 
 const usage = `
 Constructive GraphQL Codegen:
@@ -14,6 +21,7 @@ Constructive GraphQL Codegen:
 Options:
   --help, -h                 Show this help message
   --config <path>            Path to graphql-codegen config file
+  --target <name>            Target name in config file
   --endpoint <url>           GraphQL endpoint URL
   --auth <token>             Authorization header value (e.g., "Bearer 123")
   --out <dir>                Output directory (default: graphql/codegen/dist)
@@ -22,7 +30,7 @@ Options:
 
   --database <name>          Database override for DB mode (defaults to PGDATABASE)
   --schemas <list>           Comma-separated schemas (required for DB mode)
-`
+`;
 
 export default async (
   argv: Partial<ParsedArgs>,
@@ -30,65 +38,114 @@ export default async (
   _options: CLIOptions
 ) => {
   if (argv.help || argv.h) {
-    console.log(usage)
-    process.exit(0)
+    console.log(usage);
+    process.exit(0);
   }
 
-  const endpointArg = (argv.endpoint as string) || ''
-  const outDir = (argv.out as string) || 'codegen'
-  const auth = (argv.auth as string) || ''
-  const configPath = (argv.config as string) || ''
-  const dryRun = !!(argv['dry-run'] || argv.dryRun)
-  const verbose = !!(argv.verbose || argv.v)
+  const endpointArg = (argv.endpoint as string) || '';
+  const outputArg = argv.out as string | undefined;
+  const outDir = outputArg || 'codegen';
+  const auth = (argv.auth as string) || '';
+  const configPath = (argv.config as string) || '';
+  const target = (argv.target as string) || '';
+  const dryRun = !!(argv['dry-run'] || argv.dryRun);
+  const verbose = !!(argv.verbose || argv.v);
+  const resolvedConfigPath = configPath || findConfigFile() || '';
+  const hasConfigFile = Boolean(resolvedConfigPath);
+  const outputForGenerate = outputArg || !hasConfigFile ? outDir : undefined;
 
-  const selectedDb = (argv.database as string) || undefined
-  const options: ConstructiveOptions = selectedDb ? getEnvOptions({ pg: { database: selectedDb } }) : getEnvOptions()
-  const schemasArg = (argv.schemas as string) || ''
+  const selectedDb = (argv.database as string) || undefined;
+  const options: ConstructiveOptions = selectedDb
+    ? getEnvOptions({ pg: { database: selectedDb } })
+    : getEnvOptions();
+  const schemasArg = (argv.schemas as string) || '';
 
-  const runGenerate = async ({ endpoint, schema }: { endpoint?: string; schema?: string }) => {
+  const runGenerate = async ({
+    endpoint,
+    schema,
+  }: {
+    endpoint?: string;
+    schema?: string;
+  }) => {
     const result = await generateCommand({
       config: configPath || undefined,
+      target: target || undefined,
       endpoint,
       schema,
-      output: outDir,
+      output: outputForGenerate,
       authorization: auth || undefined,
       verbose,
       dryRun,
-    })
+    });
+    const targetResults: GenerateTargetResult[] = result.targets ?? [];
+    const hasNamedTargets =
+      targetResults.length > 0 &&
+      (targetResults.length > 1 || targetResults[0]?.name !== 'default');
+
+    if (hasNamedTargets) {
+      console.log(result.message);
+      targetResults.forEach((target) => {
+        const status = target.success ? '[ok]' : 'x';
+        console.log(`\n${status} ${target.message}`);
+
+        if (target.tables?.length) {
+          console.log('  Tables:');
+          target.tables.forEach((table) => console.log(`    - ${table}`));
+        }
+        if (target.filesWritten?.length) {
+          console.log('  Files written:');
+          target.filesWritten.forEach((file) => console.log(`    - ${file}`));
+        }
+        if (!target.success && target.errors?.length) {
+          target.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      });
+
+      if (!result.success) {
+        process.exit(1);
+      }
+      return;
+    }
 
     if (!result.success) {
-      console.error(result.message)
-      if (result.errors?.length) result.errors.forEach(e => console.error('  -', e))
-      process.exit(1)
+      console.error(result.message);
+      if (result.errors?.length)
+        result.errors.forEach((e) => console.error('  -', e));
+      process.exit(1);
     }
-    console.log(result.message)
+    console.log(result.message);
     if (result.filesWritten?.length) {
-      result.filesWritten.forEach(f => console.log(f))
+      result.filesWritten.forEach((f) => console.log(f));
     }
-  }
+  };
 
   if (endpointArg) {
-    await runGenerate({ endpoint: endpointArg })
-    return
+    await runGenerate({ endpoint: endpointArg });
+    return;
   }
 
   if (!schemasArg.trim()) {
-    console.error('Error: --schemas is required when building from database. Provide a comma-separated list of schemas.')
-    process.exit(1)
+    console.error(
+      'Error: --schemas is required when building from database. Provide a comma-separated list of schemas.'
+    );
+    process.exit(1);
   }
 
-  const schemas = schemasArg.split(',').map((s: string) => s.trim()).filter(Boolean)
-  await fs.promises.mkdir(outDir, { recursive: true })
+  const schemas = schemasArg
+    .split(',')
+    .map((s: string) => s.trim())
+    .filter(Boolean);
+  await fs.promises.mkdir(outDir, { recursive: true });
   const sdl = await buildSchemaSDL({
     database: options.pg.database,
     schemas,
     graphile: {
       pgSettings: async () => ({ role: 'administrator' }),
     },
-  })
+  });
 
-  const schemaPath = path.join(outDir, 'schema.graphql')
-  await fs.promises.writeFile(schemaPath, sdl, 'utf-8')
+  const schemaPath = path.join(outDir, 'schema.graphql');
+  await fs.promises.writeFile(schemaPath, sdl, 'utf-8');
 
-  await runGenerate({ schema: schemaPath })
-}
+  await runGenerate({ schema: schemaPath });
+};