@stonecrop/nuxt-grafserv 0.7.8 → 0.7.9

package/README.md

@@ -48,25 +48,33 @@ yarn add @stonecrop/nuxt-grafserv postgraphile
 npm install @stonecrop/nuxt-grafserv postgraphile
 ```
 
-2. Configure in `nuxt.config.ts`:
+2. Create your preset file `server/graphile.preset.ts`:
 
 ```ts
 import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
 import { makePgService } from 'postgraphile/adaptors/pg'
 
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [
+    makePgService({
+      connectionString: process.env.DATABASE_URL || 'postgresql://localhost/mydb',
+      schemas: ['public'],
+    }),
+  ],
+}
+
+export default preset
+```
+
+3. Configure in `nuxt.config.ts`:
+
+```ts
 export default defineNuxtConfig({
   modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
     type: 'postgraphile', // Required: specify configuration type
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL || 'postgresql://localhost/mydb',
-          schemas: ['public'],
-        }),
-      ],
-    },
+    preset: './server/graphile.preset.ts', // Path to preset file
     url: '/graphql',
     graphiql: true,
   }
@@ -109,35 +117,45 @@ Use `type: 'postgraphile'` for PostGraphile-based GraphQL APIs:
 | Option | Type | Required | Description |
 |--------|------|----------|-------------|
 | `type` | `'postgraphile'` | ✅ | Configuration type discriminator |
-| `preset` | `GraphileConfig.Preset` | ✅ | PostGraphile preset passed to makeSchema() |
+| `preset` | `string` | ✅ | Path to PostGraphile preset file (e.g., './server/graphile.preset.ts') |
 | `url` | `string` | ❌ | GraphQL endpoint URL (default: '/graphql/') |
 | `graphiql` | `boolean` | ❌ | Enable GraphiQL IDE (default: true in dev, false in prod) |
 
+> **Important:** The preset must be a file path, not an inline object. See "Why File-Based Presets?" section below.
+
 **Example:**
 
 ```ts
-import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
-import { makePgService } from 'postgraphile/adaptors/pg'
-
+// nuxt.config.ts
 export default defineNuxtConfig({
   grafserv: {
     type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL,
-          schemas: ['public'],
-        }),
-      ],
-      plugins: [MyCustomPlugin],
-    },
+    preset: './server/graphile.preset.ts',
     url: '/graphql',
     graphiql: true,
   }
 })
 ```
 
+```ts
+// server/graphile.preset.ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [
+    makePgService({
+      connectionString: process.env.DATABASE_URL,
+      schemas: ['public'],
+    }),
+  ],
+  plugins: [MyCustomPlugin],
+}
+
+export default preset
+```
+
 ### Schema Configuration
 
 Use `type: 'schema'` for custom GraphQL schemas with Grafast resolvers:
@@ -249,109 +267,47 @@ export default defineNuxtConfig({
 
 For database-backed GraphQL APIs:
 
-1. Configure PostGraphile in `nuxt.config.ts`:
+1. Create your preset file `server/graphile.preset.ts`:
 
 ```ts
 import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
 import { makePgService } from 'postgraphile/adaptors/pg'
 
-export default defineNuxtConfig({
-  modules: ['@stonecrop/nuxt-grafserv'],
-  grafserv: {
-    type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL,
-          schemas: ['public'],
-        }),
-      ],
-    },
-  }
-})
-```
-
-2. That's it! PostGraphile automatically generates your GraphQL schema from your PostgreSQL database.
-
-## Advanced Usage
-
-## Advanced Usage
-
-### Grafserv Middleware and Plugins
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [
+    makePgService({
+      connectionString: process.env.DATABASE_URL,
+      schemas: ['public'],
+    }),
+  ],
+}
 
-For cross-cutting concerns like authentication, logging, or rate limiting, use Grafserv plugins through the preset configuration. This works for both PostGraphile and Schema configurations.
+export default preset
+```
 
-#### Inline Plugin Configuration (PostGraphile)
+2. Configure PostGraphile in `nuxt.config.ts`:
 
 ```ts
-import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
-import { makePgService } from 'postgraphile/adaptors/pg'
-
 export default defineNuxtConfig({
+  modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
     type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [makePgService({ /* ... */ })],
-      plugins: [
-        {
-          name: 'request-logging',
-          version: '1.0.0',
-          grafserv: {
-            middleware: {
-              processGraphQLRequestBody: async (next, event) => {
-                const start = Date.now()
-                console.log('[GraphQL] Request started')
-                const result = await next()
-                console.log(`[GraphQL] Completed in ${Date.now() - start}ms`)
-                return result
-              }
-            }
-          }
-        }
-      ]
-    }
+    preset: './server/graphile.preset.ts',
   }
 })
 ```
 
-#### Inline Plugin Configuration (Schema)
-
-```ts
-export default defineNuxtConfig({
-  grafserv: {
-    type: 'schema',
-    schema: 'server/**/*.graphql',
-    resolvers: 'server/resolvers.ts',
-    // Note: For Schema config, advanced plugin configuration should be done
-    // through a preset configuration or custom schema provider
-  }
-})
-```
+3. That's it! PostGraphile automatically generates your GraphQL schema from your PostgreSQL database.
 
-#### Using External Plugin File
+## Advanced Usage
 
-```ts
-// nuxt.config.ts
-import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
-import { makePgService } from 'postgraphile/adaptors/pg'
-import plugins from './server/plugins'
+### Custom Grafserv Plugins
 
-export default defineNuxtConfig({
-  grafserv: {
-    type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [makePgService({ /* ... */ })],
-      plugins
-    }
-  }
-})
-```
+Add custom plugins for authentication, logging, or rate limiting through your preset file:
 
 ```ts
-// server/plugins.ts
+// server/graphile/plugins.ts
 import type { GraphileConfig } from 'graphile-config'
 
 const loggingPlugin: GraphileConfig.Plugin = {
@@ -387,6 +343,23 @@ const authPlugin: GraphileConfig.Plugin = {
 export default [loggingPlugin, authPlugin]
 ```
 
+Import the plugins in your preset:
+
+```ts
+// server/graphile/graphile.preset.ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+import plugins from './plugins'
+
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [makePgService({ /* ... */ })],
+  plugins
+}
+
+export default preset
+```
+
 #### Available Middleware Hooks
 
 - `processRequest` - Process all incoming requests
@@ -396,149 +369,120 @@ export default [loggingPlugin, authPlugin]
 
 ## PostGraphile Integration
 
-This module has first-class support for PostGraphile v5 using the preset configuration pattern. PostGraphile automatically generates your complete GraphQL schema and resolvers from your PostgreSQL database.
-
-### Prerequisites
+PostGraphile v5+ automatically generates your GraphQL schema from PostgreSQL.
 
-```bash
-pnpm add postgraphile
-```
-
-### Basic PostGraphile Setup
+### With Community Plugins
 
 ```typescript
-// nuxt.config.ts
 import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
 import { makePgService } from 'postgraphile/adaptors/pg'
+import PgSimplifyInflectorPlugin from '@graphile-contrib/pg-simplify-inflector'
 
-export default defineNuxtConfig({
-  modules: ['@stonecrop/nuxt-grafserv'],
-  grafserv: {
-    type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL || 'postgresql://localhost/mydb',
-          schemas: ['public'],
-        }),
-      ],
-    },
-    url: '/graphql',
-    graphiql: true,
-  }
-})
-```
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  plugins: [PgSimplifyInflectorPlugin],
+  pgServices: [
+    makePgService({
+      connectionString: process.env.DATABASE_URL,
+      schemas: ['public'],
+    }),
+  ],
+  schema: {
+    defaultBehavior: 'connection', // Enable Relay-style connections
+  },
+  grafast: {
+    explain: process.env.NODE_ENV === 'development', // Plan diagrams in dev
+  },
+}
 
-### PostGraphile with Custom Plugins
+export default preset
+```
 
-Enhance your PostGraphile setup with community plugins:
+### Advanced Configuration
 
 ```typescript
-// nuxt.config.ts
 import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
 import { makePgService } from 'postgraphile/adaptors/pg'
-import PgSimplifyInflectorPlugin from '@graphile-contrib/pg-simplify-inflector'
 
-export default defineNuxtConfig({
-  grafserv: {
-    type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      plugins: [PgSimplifyInflectorPlugin],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL,
-          schemas: ['public'],
-        }),
-      ],
-      schema: {
-        defaultBehavior: 'connection', // Enable Relay-style connections
-      },
-      grafast: {
-        explain: process.env.NODE_ENV === 'development', // Plan diagrams in dev
-      },
-    },
-  }
-})
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [
+    makePgService({
+      connectionString: process.env.DATABASE_URL,
+      schemas: ['public', 'app_private'],
+      superuserConnectionString: process.env.SUPERUSER_DATABASE_URL, // For watch mode
+      pubsub: true, // Enable LISTEN/NOTIFY for subscriptions
+    }),
+  ],
+  gather: {
+    // Smart tags for schema customization
+    pgJwtTypes: 'app_public.jwt_token',
+  },
+  schema: {
+    // Behavior overrides
+    defaultBehavior: '-insert -update -delete', // Read-only by default
+    pgJwtSecret: process.env.JWT_SECRET,
+  },
+  grafast: {
+    explain: true,
+    context: (requestContext) => ({
+      // Custom context for all resolvers
+      userId: requestContext.user?.id,
+    }),
+  },
+}
+
+export default preset
 ```
 
-### Advanced PostGraphile Configuration
+### Why File-Based Presets?
 
-```typescript
-import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
-import { makePgService } from 'postgraphile/adaptors/pg'
+PostGraphile presets must be in separate files, not inline in `nuxt.config.ts`.
 
-export default defineNuxtConfig({
-  grafserv: {
-    type: 'postgraphile',
-    preset: {
-      extends: [PostGraphileAmberPreset],
-      pgServices: [
-        makePgService({
-          connectionString: process.env.DATABASE_URL,
-          schemas: ['public', 'app_private'],
-          superuserConnectionString: process.env.SUPERUSER_DATABASE_URL, // For watch mode
-          pubsub: true, // Enable LISTEN/NOTIFY for subscriptions
-        }),
-      ],
-      gather: {
-        // Smart tags for schema customization
-        pgJwtTypes: 'app_public.jwt_token',
-      },
-      schema: {
-        // Behavior overrides
-        defaultBehavior: '-insert -update -delete', // Read-only by default
-        pgJwtSecret: process.env.JWT_SECRET,
-      },
-      grafast: {
-        explain: true,
-        context: (requestContext) => ({
-          // Custom context for all resolvers
-          userId: requestContext.user?.id,
-        }),
-      },
-    },
-  }
-})
-```
+The module uses PostGraphile's [instance-based approach](https://postgraphile.org/postgraphile/next/usage-library):
 
-### Benefits of PostGraphile Integration
+1. At build time, the preset file is imported and a PostGraphile instance is created
+2. The instance is exposed via Nitro's virtual module system
+3. At runtime, handlers call `pgl.getSchema()` to get the schema
 
-- **Zero Schema Definition**: Automatically generates GraphQL schema from PostgreSQL
-- **Auto-Generated Resolvers**: All queries, mutations, and subscriptions from database
-- **Real-time Subscriptions**: Live queries via PostgreSQL LISTEN/NOTIFY
-- **Row-Level Security**: Leverages PostgreSQL RLS for fine-grained authorization
-- **High Performance**: Grafast execution engine with intelligent query planning
-- **Type Safety**: Full TypeScript support for generated schema
-- **Plugin Ecosystem**: Rich collection of community plugins for extended functionality
+This approach avoids GraphQL module duplication, follows PostGraphile's recommended pattern, supports watch mode, and properly handles database connections.
 
-### Accessing Grafserv Instance
+**Your preset file needs a default export:**
 
-For advanced use cases, you can access the grafserv instance directly in server routes:
+```typescript
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
 
-```ts
-// server/api/custom.ts
-import { getGrafservInstance } from '@stonecrop/nuxt-grafserv/runtime/handler'
-import { useRuntimeConfig } from '#imports'
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  // ...
+}
 
-export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig()
-  const serv = await getGrafservInstance(config.grafserv)
+export default preset
+```
 
-  // Access grafserv methods
-  // Note: serv contains the grafserv instance with your schema
+**Import Requirements:**
 
-  return {
-    status: 'GraphQL server is running',
-    endpoint: config.grafserv.url
-  }
-})
+Relative imports in preset files work with file extensions:
+
+```typescript
+// server/graphile/graphile.preset.ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+import { MyPlugin } from './plugins/my-plugin'
+import { AnotherPlugin } from './plugins/another'
+
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [makePgService({/*...*/})],
+  plugins: [MyPlugin, AnotherPlugin],
+}
+
+export default preset
 ```
 
-### Schema Building with Objects Structure
+### Schema Building with Grafast
 
-The module uses Grafast's modern objects structure for better type safety and performance. Leverage Grafast's standard steps for common operations:
+Grafast uses a step-based execution model. Common patterns:
 
 ```typescript
 import { constant, lambda, access, object, filter, type GrafastSchemaConfig } from 'grafast'
@@ -621,26 +565,15 @@ export default resolvers
 ```
 
 **Key Concepts:**
-- All resolvers return **steps** (constant, lambda, access, object, filter, etc.), not plain values
-- Arguments are accessed via `fieldArgs.$argumentName` (note the `$` prefix)
-- Use `constant()` for static values
-- Use `lambda()` to transform step values at execution time
-- Use `access()` to extract object properties (more efficient than lambda for simple property access)
-- Use `object()` to compose objects from multiple steps
-- Use `filter()` for list filtering operations
-- Source objects (`$source`, `$user`, `$order`, etc.) are also steps that need `lambda()` or `access()` to work with their properties
-
-**Standard Steps Reference:**
-- `constant()` - Create a step from a static value
-- `lambda()` - Transform step values with execution-time callbacks
-- `access()` - Extract properties from object steps
-- `object()` - Compose objects from multiple steps
-- `filter()` - Filter list steps based on conditions
-- `list()` - Create lists from step tuples
-- `first()`/`last()` - Get first/last elements from lists
-- `loadOne()`/`loadMany()` - Batch data loading (DataLoader-style)
-
-For the complete list, see [Grafast Standard Steps](https://grafast.org/grafast/standard-steps)
+- Resolvers return **steps** (constant, lambda, access, object, filter), not plain values
+- Arguments are accessed via `fieldArgs.$argumentName`
+- `constant()` - static values
+- `lambda()` - transform step values at execution time
+- `access()` - extract object properties efficiently
+- `object()` - compose objects from steps
+- `filter()` - filter list steps
+
+See [Grafast Standard Steps](https://grafast.org/grafast/standard-steps) for the complete reference.
 
 ## Development
 

package/dist/module.d.mts

@@ -1,6 +1,5 @@
 import { NuxtModule } from '@nuxt/schema';
 import { GraphQLSchema } from 'graphql';
-import { GraphileConfig } from 'graphile-config';
 
 /**
  * Schema provider function - returns a GraphQL schema
@@ -10,27 +9,34 @@ type SchemaProvider = () => GraphQLSchema | Promise<GraphQLSchema>;
  * PostGraphile configuration using preset
  *
  * This is the recommended approach for PostGraphile integration.
- * The preset is passed to PostGraphile's makeSchema() function to generate the GraphQL schema.
+ * The preset file path is resolved and imported at runtime, then passed to PostGraphile's makeSchema() function.
+ *
+ * Note: Inline preset objects are not supported due to Nitro's build/runtime separation.
+ * Complex objects with extends arrays, plugins, and functions cannot be serialized across this boundary.
  *
  * @example
  * ```typescript
+ * // 1. Create server/graphile.preset.ts
  * import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
  * import { makePgService } from 'postgraphile/adaptors/pg'
  *
+ * export default {
+ *   extends: [PostGraphileAmberPreset],
+ *   pgServices: [
+ *     makePgService({
+ *       connectionString: process.env.DATABASE_URL,
+ *       schemas: ['public'],
+ *     }),
+ *   ],
+ *   plugins: [MyCustomPlugin],
+ * }
+ *
+ * // 2. Reference the preset file in nuxt.config.ts
  * export default defineNuxtConfig({
  *   modules: ['@stonecrop/nuxt-grafserv'],
  *   grafserv: {
  *     type: 'postgraphile',
- *     preset: {
- *       extends: [PostGraphileAmberPreset],
- *       pgServices: [
- *         makePgService({
- *           connectionString: process.env.DATABASE_URL,
- *           schemas: ['public'],
- *         }),
- *       ],
- *       plugins: [MyCustomPlugin],
- *     },
+ *     preset: './server/graphile.preset.ts',
  *     url: '/graphql',
  *     graphiql: true,
  *   },
@@ -40,8 +46,18 @@ type SchemaProvider = () => GraphQLSchema | Promise<GraphQLSchema>;
 interface PostGraphileConfig {
     /** Configuration type discriminator */
     type: 'postgraphile';
-    /** PostGraphile preset configuration - passed to makeSchema() */
-    preset: GraphileConfig.Preset;
+    /**
+     * Path to PostGraphile preset file
+     *
+     * The preset file must export the preset configuration using default export:
+     * `export default { extends: [...], pgServices: [...], plugins: [...] }`
+     *
+     * A PostGraphile instance will be created from this preset at build time.
+     *
+     * @example './server/graphile.preset.ts'
+     * @example './server/graphile.preset.js'
+     */
+    preset: string;
     /** GraphQL endpoint URL (default: '/graphql/') */
     url?: string;
     /** Whether to enable GraphiQL IDE (default: true in dev, false in prod) */

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@stonecrop/nuxt-grafserv",
   "configKey": "grafserv",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,6 +1,7 @@
-import { join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { useLogger, defineNuxtModule, createResolver, addTemplate } from '@nuxt/kit';
+import { join } from 'node:path';
+import { useLogger, defineNuxtModule, createResolver } from '@nuxt/kit';
 
 const logger = useLogger("@stonecrop/nuxt-grafserv");
 function validateConfig(options) {
@@ -77,19 +78,53 @@ const module$1 = defineNuxtModule({
       logger.info(`Grafserv server alias: ${config.alias["#grafserv-server"]}`);
       if (options.type === "postgraphile") {
         logger.info("Using PostGraphile preset configuration");
-        const template = addTemplate({
-          filename: "grafserv-preset.mjs",
-          write: true,
-          getContents: () => {
-            return `export const preset = ${JSON.stringify(options.preset, null, 2)}`;
+        let presetPath = resolveForVirtualModule(options.preset);
+        if (!existsSync(presetPath)) {
+          const extensions = [".ts", ".js", ".mjs"];
+          let found = false;
+          for (const ext of extensions) {
+            const pathWithExt = presetPath + ext;
+            if (existsSync(pathWithExt)) {
+              presetPath = pathWithExt;
+              found = true;
+              break;
+            }
           }
-        });
+          if (!found) {
+            throw new Error(
+              `[@stonecrop/nuxt-grafserv] Preset file not found: ${presetPath}
+Tried extensions: ${extensions.join(", ")}
+
+Create the preset file with your PostGraphile configuration:
+
+// ${options.preset}.ts (or .js, .mjs)
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+
+export default {
+  extends: [PostGraphileAmberPreset],
+  pgServices: [makePgService({ connectionString: process.env.DATABASE_URL, schemas: ['public'] })],
+  plugins: [],
+}
+`
+            );
+          }
+        }
+        logger.info(`Resolved preset path: ${presetPath}`);
+        config.virtual = config.virtual || {};
+        config.virtual["#internal/grafserv/pgl"] = [
+          `import { postgraphile } from 'postgraphile'`,
+          `import preset from '${presetPath}'`,
+          ``,
+          `// Create PostGraphile instance with the preset`,
+          `// This handles schema building, watch mode, and lifecycle`,
+          `export const pgl = postgraphile(preset)`
+        ].join("\n");
         config.runtimeConfig = config.runtimeConfig || {};
         config.runtimeConfig.grafserv = {
           type: "postgraphile",
           url: options.url || "/graphql/",
-          graphiql: options.graphiql,
-          presetPath: template.dst
+          graphiql: options.graphiql
         };
       } else if (options.type === "schema") {
         logger.info("Using schema configuration");
@@ -128,7 +163,11 @@ const module$1 = defineNuxtModule({
       config.externals = config.externals || {};
       config.externals.external = config.externals.external || [];
       config.externals.external.push(
+        "graphql",
         "grafast",
+        "postgraphile",
+        "graphile-config",
+        "graphile-build",
         "@graphql-tools/schema",
         "@graphql-tools/load",
         "@graphql-tools/graphql-file-loader"
@@ -136,6 +175,11 @@ const module$1 = defineNuxtModule({
       const grafastPath = require.resolve("grafast");
       config.alias = config.alias || {};
       config.alias["grafast"] = grafastPath;
+      config.typescript = config.typescript || {};
+      config.typescript.tsConfig = config.typescript.tsConfig || {};
+      config.typescript.tsConfig.compilerOptions = config.typescript.tsConfig.compilerOptions || {};
+      config.typescript.tsConfig.compilerOptions.allowImportingTsExtensions = true;
+      config.typescript.tsConfig.compilerOptions.moduleResolution = "bundler";
     });
     nuxt.hook("nitro:config", (config) => {
       config.handlers = config.handlers || [];
@@ -170,7 +214,8 @@ const module$1 = defineNuxtModule({
       nuxt.hook("builder:watch", async (event, path) => {
         const isSchemaFile = path.endsWith(".graphql");
         const isResolverFile = options.type === "schema" && options.resolvers && path.includes(options.resolvers.replace("./", ""));
-        if (isSchemaFile || isResolverFile) {
+        const isPresetFile = options.type === "postgraphile" && path.includes(options.preset.replace("./", ""));
+        if (isSchemaFile || isResolverFile || isPresetFile) {
           if (!cacheClearing) {
             cacheClearing = true;
             try {

package/dist/runtime/handler.js

@@ -19,25 +19,19 @@ async function getSchema(options) {
   }
   let schema;
   if (options.type === "postgraphile") {
-    console.debug("[@stonecrop/nuxt-grafserv] Creating schema from PostGraphile preset");
+    console.debug("[@stonecrop/nuxt-grafserv] Getting schema from PostGraphile instance");
     try {
-      const { makeSchema } = await import("postgraphile");
-      const config = useRuntimeConfig();
-      if (config.grafserv.type !== "postgraphile") {
-        throw new Error("Expected PostGraphile configuration");
-      }
-      const presetModule = await import(config.grafserv.presetPath);
-      const preset = presetModule.preset;
-      const result = await makeSchema(preset);
-      schema = result.schema;
-      console.debug("[@stonecrop/nuxt-grafserv] PostGraphile schema created successfully");
+      const { pgl } = await import("#internal/grafserv/pgl");
+      console.debug("[@stonecrop/nuxt-grafserv] Calling pgl.getSchema()");
+      schema = await pgl.getSchema();
+      console.debug("[@stonecrop/nuxt-grafserv] PostGraphile schema retrieved successfully");
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND") {
         throw new Error(
           '[@stonecrop/nuxt-grafserv] PostGraphile preset provided but "postgraphile" package not found. Install it with: npm install postgraphile'
         );
       }
-      console.error("[@stonecrop/nuxt-grafserv] Error creating PostGraphile schema:", error);
+      console.error("[@stonecrop/nuxt-grafserv] Error getting PostGraphile schema:", error);
       throw error;
     }
   } else if (options.type === "schema") {
@@ -80,7 +74,9 @@ async function getSchema(options) {
       }
     }
   } else {
-    throw new Error(`[@stonecrop/nuxt-grafserv] Invalid configuration type: ${options.type}`);
+    throw new Error(
+      `[@stonecrop/nuxt-grafserv] Invalid configuration type: ${options.type}`
+    );
   }
   cachedSchema = schema;
   return schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/nuxt-grafserv",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "Pluggable Grafserv GraphQL server as Nuxt Module",
   "license": "MIT",
   "type": "module",
@@ -43,7 +43,7 @@
     "grafast": "^1.0.0-rc.4",
     "grafserv": "^1.0.0-rc.4",
     "graphql": "^16.12.0",
-    "@stonecrop/graphql-middleware": "0.7.8"
+    "@stonecrop/graphql-middleware": "0.7.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",