@stonecrop/nuxt-grafserv 0.7.4 → 0.7.6

package/README.md

@@ -3,21 +3,31 @@
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
 [![License][license-src]][license-href]
-[![Nuxt][nuxt-src]][nuxt-href]
 
 Pluggable Grafserv GraphQL server as a Nuxt Module. Uses the Grafast execution engine for high-performance GraphQL.
 
-- [✨  Release Notes](/CHANGELOG.md)
-
 ## Features
 
 - 🚀  Grafserv Server Integration
-- ⚡️  Grafast Execution Engine (faster than graphql-js)
+- ⚡️  Grafast Execution Engine (faster than [`graphql-js`](https://github.com/graphql/graphql-js))
 - 🔄  Schema Stitching Support
-- 🛠  Middleware Support
+- 🔍  Graphile Preset System for Advanced Configuration
 - 📝  TypeScript Support
-- 🔍  GraphiQL Interface
+- 🔍  GraphiQL/Ruru Interface
 - ⚡️  Hot Module Reloading
+- 🎯  Separate Route Handlers for GraphQL/UI and Static Assets
+
+## Architecture
+
+This module uses modern Grafserv patterns with three key components:
+
+1. **Preset-Based Configuration**: Leverages Graphile's preset system for extensibility and plugin support
+2. **Separate Route Handlers**: Two dedicated handlers for GraphQL operations/UI and static assets
+3. **Objects Structure**: Uses Grafast's modern `objects/interfaces/enums` schema building pattern for better type safety
+
+The module automatically registers these handlers:
+- `{url}` - Unified GraphQL operations and Ruru UI endpoint
+- `/ruru-static/**` - Static assets for the Ruru IDE
 
 ## Quick Setup
 
@@ -40,48 +50,54 @@ npm install @stonecrop/nuxt-grafserv
 export default defineNuxtConfig({
   modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
-    schema: './server/**/*.graphql',
-    resolvers: './server/resolvers.ts',
-    url: '/graphql/',
+    schema: 'server/**/*.graphql',
+    resolvers: 'server/resolvers.ts',
+    url: '/graphql/', // Serves both GraphQL API and Ruru UI
   }
 })
 ```
 
 ## Configuration
 
-Here's a full example of all available options:
+### All Available Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `schema` | `string \| string[] \| SchemaProvider \| PostGraphileInstance` | `'server/**/*.graphql'` | Path(s) to GraphQL schema files, schema provider function, or PostGraphile instance |
+| `resolvers` | `string` | `undefined` | Path to resolvers file (optional - not needed for PostGraphile) |
+| `url` | `string` | `'/graphql/'` | GraphQL endpoint URL (also serves Ruru UI) |
+| `graphiql` | `boolean` | `true` in dev, `false` in prod | Enable GraphiQL IDE |
+| `preset` | `GraphileConfig.Preset` | `undefined` | Custom Graphile preset for advanced configuration |
+
+### Full Configuration Example
 
 ```ts
 export default defineNuxtConfig({
   modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
-    // Path to your GraphQL schema files
-    schema: './server/**/*.graphql',
-    
-    // Path to your resolvers
-    resolvers: './server/resolvers.ts',
-    
-    // GraphQL endpoint URL (default: /graphql/)
-    url: '/graphql/',
-    
-    // Enable GraphiQL IDE (default: true in dev, false in prod)
+    // Schema configuration
+    schema: 'server/**/*.graphql',
+    resolvers: 'server/resolvers.ts',
+
+    // Endpoints
+    url: '/graphql/', // Serves both GraphQL API and Ruru UI
     graphiql: true,
-    
-    // Middleware functions
-    middleware: [
-      async (ctx, next) => {
-        const start = Date.now()
-        const result = await next()
-        console.log(`Request took ${Date.now() - start}ms`)
-        return result
+
+    // Graphile preset with grafserv options
+    preset: {
+      grafserv: {
+        websockets: false,
+        graphqlOverGET: true, // Enable GET requests for queries
+        maxRequestLength: 100000,
+        allowedRequestContentTypes: [
+          'application/json',
+          'application/graphql+json'
+        ]
+      },
+      grafast: {
+        explain: true, // Enable plan diagrams
       }
-    ],
-    
-    // Grafserv-specific options
-    grafserv: {
-      websockets: false,
-      introspection: true
-    }
+    },
   }
 })
 ```
@@ -104,41 +120,405 @@ type Mutation {
 2. Create your resolvers (`server/resolvers.ts`):
 
 ```typescript
-export default {
+import { constant, lambda, access, object, filter, type GrafastSchemaConfig } from 'grafast'
+
+const resolvers: GrafastSchemaConfig['objects'] = {
   Query: {
-    hello: () => 'world',
-    ping: () => true
+    plans: {
+      hello: () => constant('world'),
+      ping: () => constant(true)
+    }
   },
   Mutation: {
-    echo: (_: unknown, { message }: { message: string }) => message
+    plans: {
+      echo: (_source, fieldArgs) => {
+        const { $message } = fieldArgs
+        return $message
+      }
+    }
   }
 }
+
+export default resolvers
 ```
 
-## Middleware
+## Advanced Usage
+
+### Middleware via Grafserv Plugins
+
+For middleware functionality (authentication, logging, etc.), use Grafserv plugins. The CLI installer creates a `server/plugins.ts` file with examples.
 
-Add middleware functions to process requests:
+#### Inline Plugin Configuration
 
 ```ts
-grafserv: {
-  middleware: [
-    // Logging middleware
-    async (ctx, next) => {
-      const start = Date.now()
-      const result = await next()
-      console.log(`Request took ${Date.now() - start}ms`)
-      return result
+export default defineNuxtConfig({
+  grafserv: {
+    preset: {
+      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
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+})
+```
+
+#### Using External Plugin File
+
+```ts
+// nuxt.config.ts
+import plugins from './server/plugins'
+
+export default defineNuxtConfig({
+  grafserv: {
+    schema: 'server/schema.graphql',
+    resolvers: 'server/resolvers.ts',
+    preset: {
+      plugins
+    }
+  }
+})
+```
+
+```ts
+// server/plugins.ts
+import type { GraphileConfig } from 'graphile-config'
+
+const loggingPlugin: GraphileConfig.Plugin = {
+  name: 'request-logging',
+  version: '1.0.0',
+  grafserv: {
+    middleware: {
+      processGraphQLRequestBody: async (next, event) => {
+        console.log('Processing:', event.request.url)
+        return next()
+      }
+    }
+  }
+}
+
+const authPlugin: GraphileConfig.Plugin = {
+  name: 'authentication',
+  version: '1.0.0',
+  grafserv: {
+    middleware: {
+      processGraphQLRequestBody: async (next, event) => {
+        const token = event.request.headers.get('authorization')
+        // TODO: Validate token and add user to context
+        return next()
+      }
+    }
+  }
+}
+
+export default [loggingPlugin, authPlugin]
+```
+
+#### Available Middleware Hooks
+
+- `processRequest` - Process all incoming requests
+- `processGraphQLRequestBody` - Process GraphQL request bodies
+- `ruruHTML` - Customize Ruru IDE HTML generation
+- `onSubscribe` - Handle GraphQL subscriptions
+
+## Advanced Usage
+
+### PostGraphile Integration
+
+This module has first-class support for PostGraphile, enabling instant GraphQL APIs from PostgreSQL databases. PostGraphile generates the complete schema and resolvers, so you don't need to define them manually.
+
+#### Setup with PostGraphile
+
+1. Install PostGraphile:
+
+```bash
+pnpm add postgraphile @graphile/crystal graphile-build-pg
+```
+
+2. Create a PostGraphile schema provider (`server/graphql/schema.ts`):
+
+```typescript
+import { postgraphile } from 'postgraphile'
+import type { GraphQLSchema } from 'graphql'
+
+// Define your PostGraphile preset
+const preset = {
+  pgServices: [
+    {
+      name: 'main',
+      connectionString: process.env.DATABASE_URL || 'postgres://localhost/mydb',
+      schemas: ['public'],
+    },
+  ],
+  grafserv: {
+    websockets: false, // Disable websockets for Nuxt compatibility
+  },
+}
+
+// Create PostGraphile instance
+const pgl = postgraphile(preset)
+
+// Export schema provider function
+export async function createPostGraphileSchema(): Promise<GraphQLSchema> {
+  const { schema } = await pgl.getSchemaResult()
+  return schema
+}
+
+// Export the instance if you need direct access
+export { pgl }
+```
+
+3. Configure Nuxt to use the PostGraphile schema:
+
+```typescript
+// nuxt.config.ts
+import { createPostGraphileSchema } from './server/graphql/schema'
+
+export default defineNuxtConfig({
+  modules: ['@stonecrop/nuxt-grafserv'],
+  grafserv: {
+    // Use PostGraphile schema provider function
+    schema: createPostGraphileSchema,
+    // No resolvers needed - PostGraphile generates everything
+    url: '/graphql',
+    graphiql: true, // Enable Ruru IDE
+  }
+})
+```
+
+#### Direct PostGraphile Instance Usage
+
+You can also pass a PostGraphile instance directly:
+
+```typescript
+// nuxt.config.ts
+import { pgl } from './server/graphql/schema'
+
+export default defineNuxtConfig({
+  grafserv: {
+    schema: pgl, // Pass PostGraphile instance directly
+    url: '/graphql',
+  }
+})
+```
+
+#### PostGraphile with Custom Plugins
+
+Enhance your PostGraphile setup with custom plugins:
+
+```typescript
+// server/graphql/schema.ts
+import { postgraphile } from 'postgraphile'
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import PgSimplifyInflectorPlugin from '@graphile-contrib/pg-simplify-inflector'
+
+const preset = {
+  extends: [PostGraphileAmberPreset],
+  plugins: [PgSimplifyInflectorPlugin],
+  pgServices: [
+    {
+      name: 'main',
+      connectionString: process.env.DATABASE_URL,
+      schemas: ['public'],
     },
-    // Authentication middleware
-    async (ctx, next) => {
-      const token = ctx.req.headers.get('authorization')
-      if (!token) throw new Error('Unauthorized')
-      return next()
+  ],
+  grafserv: {
+    websockets: false,
+  },
+  grafast: {
+    explain: process.env.NODE_ENV === 'development', // Enable plan diagrams in dev
+  },
+  schema: {
+    // Add custom behavior overrides
+    defaultBehavior: 'connection', // Enable Relay-style connections by default
+  },
+}
+
+const pgl = postgraphile(preset)
+
+export async function createPostGraphileSchema() {
+  const { schema } = await pgl.getSchemaResult()
+  return schema
+}
+```
+
+#### Benefits of PostGraphile Integration
+
+- **Zero Schema Definition**: Automatically generates GraphQL schema from PostgreSQL
+- **Auto-Generated Resolvers**: All queries and mutations created from database schema
+- **Real-time Subscriptions**: Live query support via PostgreSQL LISTEN/NOTIFY
+- **Row-Level Security**: Leverages PostgreSQL RLS for authorization
+- **High Performance**: Uses Grafast execution engine with intelligent batching
+- **Type Safety**: Full TypeScript support for generated schema
+
+### Custom Graphile Preset
+
+Leverage the full power of the Graphile ecosystem with custom presets:
+
+```ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+
+export default defineNuxtConfig({
+  grafserv: {
+    preset: {
+      extends: [PostGraphileAmberPreset],
+      grafast: {
+        explain: true, // Enable plan diagrams for debugging
+        context: {
+          // Custom context available in all resolvers
+          apiVersion: '1.0'
+        }
+      },
+      grafserv: {
+        graphqlOverGET: true,
+        maxRequestLength: 200000
+      }
     }
-  ]
+  }
+})
+```
+
+### Accessing Grafserv Instance
+
+For advanced use cases, you can access the grafserv instance directly:
+
+```ts
+// server/api/custom.ts
+import { getGrafservInstance } from '@stonecrop/nuxt-grafserv/runtime/handler'
+import { useRuntimeConfig } from '#imports'
+
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig()
+  const serv = await getGrafservInstance(config.grafserv)
+
+  // Access grafserv methods or configuration
+  const preset = serv.getPreset()
+
+  return { preset }
+})
+```
+
+### Schema Building with Objects Structure
+
+The module uses Grafast's modern objects structure for better type safety and performance. Leverage Grafast's standard steps for common operations:
+
+```typescript
+import { constant, lambda, access, object, filter, type GrafastSchemaConfig } from 'grafast'
+
+const resolvers: GrafastSchemaConfig['objects'] = {
+  Query: {
+    plans: {
+      // Static values use constant()
+      hello: () => constant('world'),
+
+      // Arguments accessed via fieldArgs with $ prefix
+      user: (_source, fieldArgs) => {
+        const { $id } = fieldArgs
+        return lambda($id, (id) => getUserById(id))
+      },
+
+      // Use filter() for list filtering
+      userOrders: (_source, fieldArgs) => {
+        const { $userId } = fieldArgs
+        const $allOrders = constant(getAllOrders())
+        return filter($allOrders, $order =>
+          lambda([access($order, 'userId'), $userId],
+            ([orderUserId, userId]) => orderUserId === userId
+          )
+        )
+      }
+    }
+  },
+
+  Mutation: {
+    plans: {
+      // Use object() to compose objects from steps
+      createUser: (_source, fieldArgs) => {
+        const { $name, $email } = fieldArgs
+        const $id = constant(generateId())
+        const $now = constant(new Date().toISOString())
+
+        const $user = object({
+          id: $id,
+          name: $name,
+          email: $email,
+          role: constant('user'),
+          createdAt: $now,
+          updatedAt: $now
+        })
+
+        return lambda($user, user => {
+          saveUser(user)
+          return user
+        })
+      }
+    }
+  },
+
+  // Field resolvers for types
+  User: {
+    plans: {
+      fullName: ($user) => {
+        return lambda($user, (user) => {
+          const typed = user as { firstName: string; lastName: string }
+          return `${typed.firstName} ${typed.lastName}`
+        })
+      }
+    }
+  },
+
+  // Related type resolvers
+  Order: {
+    plans: {
+      // Use access() to extract properties before lookups
+      user: ($order) => {
+        const $userId = access($order, 'userId')
+        return lambda($userId, userId => getUserById(userId as string) ?? null)
+      }
+    }
+  }
 }
+
+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)
+
 ## Development
 
 ```bash
@@ -162,10 +542,6 @@ pnpm run test
 pnpm run test:watch
 ```
 
-## License
-
-[MIT License](./LICENSE)
-
 <!-- Badges -->
 [npm-version-src]: https://img.shields.io/npm/v/@stonecrop/nuxt-grafserv/latest.svg?style=flat&colorA=020420&colorB=00DC82
 [npm-version-href]: https://npmjs.com/package/@stonecrop/nuxt-grafserv
@@ -175,6 +551,3 @@ pnpm run test:watch
 
 [license-src]: https://img.shields.io/npm/l/@stonecrop/nuxt-grafserv.svg?style=flat&colorA=020420&colorB=00DC82
 [license-href]: https://npmjs.com/package/@stonecrop/nuxt-grafserv
-
-[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
-[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -1,61 +1,39 @@
 import { NuxtModule } from '@nuxt/schema';
+import { PromiseOrDirect } from 'grafast';
 import { GraphQLSchema } from 'graphql';
 import { GraphileConfig } from 'graphile-config';
 
-/**
- * Context provided to GraphQL resolvers
- */
-type GrafastContext = {
-    req: Request;
-    params: Record<string, string>;
-    [key: string]: unknown;
-};
-/**
- * Middleware function type for request processing
- */
-type MiddlewareFunction = (context: GrafastContext, next: () => Promise<GrafastContext>) => Promise<GrafastContext>;
 /**
  * Schema provider function - returns a GraphQL schema
  */
 type SchemaProvider = () => GraphQLSchema | Promise<GraphQLSchema>;
+/**
+ * PostGraphile instance interface (minimal type for compatibility)
+ */
+interface PostGraphileInstance {
+    getSchema(): PromiseOrDirect<GraphQLSchema>;
+    getSchemaResult(): PromiseOrDirect<{
+        schema: GraphQLSchema;
+        resolvedPreset: GraphileConfig.ResolvedPreset;
+    }>;
+}
 /**
  * Configuration for the Grafast module
  */
 interface ModuleOptions {
-    /** Path to schema file(s) or a schema provider function */
-    schema?: string | string[] | SchemaProvider;
-    /** Path to resolvers file (for .graphql schema files) */
+    /** Path to schema file(s), a schema provider function, or a PostGraphile instance */
+    schema?: string | string[] | SchemaProvider | PostGraphileInstance;
+    /** Path to resolvers file (optional, only needed for .graphql schema files without PostGraphile) */
     resolvers?: string;
     /** GraphQL endpoint URL (default: '/graphql/') */
     url?: string;
     /** Whether to enable GraphiQL IDE (default: true in dev, false in prod) */
     graphiql?: boolean;
-    /**
-     * Path to middleware file that exports an array of middleware functions.
-     * This is the recommended approach as it preserves imports/dependencies.
-     * Example: './server/middleware.ts'
-     */
-    middlewarePath?: string;
-    /**
-     * Middleware functions to process requests (inline).
-     * Note: Inline middleware cannot reference external modules.
-     * For middleware with dependencies, use middlewarePath instead.
-     * @deprecated Use middlewarePath for middleware with external dependencies
-     */
-    middleware?: MiddlewareFunction[];
     /** Custom Graphile preset to extend (for advanced grafast configuration) */
     preset?: GraphileConfig.Preset;
-    /** Additional Graphile plugins */
-    plugins?: GraphileConfig.Plugin[];
-    /** Grafserv options */
-    grafserv?: {
-        /** Whether to enable the GraphQL websocket endpoint */
-        websockets?: boolean;
-        /** Whether to enable introspection (default: true in dev) */
-        introspection?: boolean;
-    };
 }
 
 declare const module$1: NuxtModule<ModuleOptions>;
 
 export { module$1 as default };
+export type { ModuleOptions, SchemaProvider };

package/dist/module.json

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

package/dist/module.mjs

@@ -1,63 +1,91 @@
 import { join } from 'node:path';
+import { createRequire } from 'node:module';
 import { useLogger, defineNuxtModule, createResolver } from '@nuxt/kit';
 
-const logger = useLogger("nuxt-grafserv");
+const logger = useLogger("@stonecrop/nuxt-grafserv");
 const module$1 = defineNuxtModule({
   meta: {
-    name: "nuxt-grafserv",
+    name: "@stonecrop/nuxt-grafserv",
     configKey: "grafserv"
   },
   defaults: (_nuxt) => ({
-    schema: "./server/**/*.graphql",
-    resolvers: "./server/resolvers.ts",
+    schema: "server/**/*.graphql",
+    resolvers: void 0,
+    // Optional - not needed for PostGraphile setups
     url: "/graphql/",
     graphiql: void 0,
     // Will default based on dev mode
-    middleware: [],
     plugins: [],
-    grafserv: {
-      websockets: false,
-      introspection: void 0
-      // Will default based on dev mode
+    preset: {
+      grafserv: {
+        websockets: false
+      }
     }
   }),
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
+    const require = createRequire(import.meta.url);
     nuxt.hook("nitro:config", (config) => {
-      const resolverPath = options.resolvers ? join(nuxt.options.srcDir, options.resolvers) : void 0;
+      config.alias = config.alias || {};
+      config.alias["#grafserv-server"] = join(nuxt.options.rootDir, "server");
+      const resolveForSchema = (path) => {
+        if (path.startsWith("/")) {
+          return path;
+        }
+        return join(nuxt.options.rootDir, path);
+      };
+      const resolveForVirtualModule = (path) => {
+        if (path.startsWith("/")) {
+          return path;
+        }
+        return join(nuxt.options.rootDir, path);
+      };
+      logger.info(`Nitro srcDir: ${config.srcDir}`);
+      logger.info(`Nuxt srcDir: ${nuxt.options.srcDir}`);
+      logger.info(`Nuxt rootDir: ${nuxt.options.rootDir}`);
+      logger.info(`Grafserv server alias: ${config.alias["#grafserv-server"]}`);
+      const resolverPath = options.resolvers ? resolveForVirtualModule(options.resolvers) : void 0;
+      if (resolverPath) {
+        logger.info(`Resolved resolver path: ${resolverPath}`);
+      } else {
+        logger.info("No resolvers configured (normal for PostGraphile setups)");
+      }
+      let runtimeSchema;
+      if (typeof options.schema === "function" || options.schema && typeof options.schema === "object" && "getSchema" in options.schema) {
+        runtimeSchema = options.schema;
+        logger.info("Using schema provider function or PostGraphile instance");
+      } else if (typeof options.schema === "string") {
+        runtimeSchema = resolveForSchema(options.schema);
+        logger.info(`Resolved schema path: ${runtimeSchema}`);
+      } else if (Array.isArray(options.schema)) {
+        runtimeSchema = options.schema.map((s) => resolveForSchema(s));
+        logger.info(`Resolved schema paths: ${runtimeSchema.join(", ")}`);
+      } else {
+        runtimeSchema = options.schema;
+      }
       config.runtimeConfig = config.runtimeConfig || {};
       config.runtimeConfig.grafserv = {
         ...options,
-        // Resolve schema paths
-        schema: typeof options.schema === "string" ? join(nuxt.options.srcDir, options.schema) : Array.isArray(options.schema) ? options.schema.map((s) => join(nuxt.options.srcDir, s)) : options.schema
-        // function passed through
+        // Pass resolved resolver path for direct import
+        resolversPath: resolverPath,
+        // Pass schema (either resolved paths or function/instance)
+        schema: runtimeSchema
       };
       config.virtual = config.virtual || {};
       if (resolverPath) {
         config.virtual["#internal/grafserv/resolvers"] = `export { default } from '${resolverPath}'`;
       }
-      let middlewareCode;
-      if (options.middlewarePath) {
-        const middlewarePath = join(nuxt.options.srcDir, options.middlewarePath);
-        middlewareCode = `export { default } from '${middlewarePath}'`;
-      } else if (options.middleware?.length) {
-        logger.warn("Inline middleware is deprecated. Use middlewarePath for middleware with external dependencies.");
-        middlewareCode = `export default [${options.middleware.map((fn) => fn.toString()).join(",")}]`;
-      } else {
-        middlewareCode = "export default []";
-      }
-      config.virtual["#internal/grafserv/middleware"] = middlewareCode;
       config.externals = config.externals || {};
-      config.externals.inline = config.externals.inline || [];
-      config.externals.inline.push(
+      config.externals.external = config.externals.external || [];
+      config.externals.external.push(
         "grafast",
-        "grafserv",
-        "grafserv/h3/v1",
-        "graphile-config",
         "@graphql-tools/schema",
         "@graphql-tools/load",
         "@graphql-tools/graphql-file-loader"
       );
+      const grafastPath = require.resolve("grafast");
+      config.alias = config.alias || {};
+      config.alias["grafast"] = grafastPath;
     });
     nuxt.hook("nitro:config", (config) => {
       config.handlers = config.handlers || [];
@@ -66,18 +94,18 @@ const module$1 = defineNuxtModule({
         handler: resolve("./runtime/handler")
       });
       config.handlers.push({
-        route: "/graphql/cache",
-        handler: resolve("./runtime/cache")
+        route: "/ruru-static/**",
+        handler: resolve("./runtime/ruru-static")
       });
       config.handlers.push({
-        route: "/ruru-static/**",
-        handler: resolve("./runtime/handler")
+        route: "/graphql/cache",
+        handler: resolve("./runtime/cache")
       });
     });
     if (options.url) {
       nuxt.hook("devtools:customTabs", (tabs) => {
         tabs.push({
-          name: "nuxt-grafserv",
+          name: "@stonecrop/nuxt-grafserv",
           title: "GraphQL (Grafserv)",
           icon: "simple-icons:graphql",
           view: {
@@ -93,7 +121,6 @@ const module$1 = defineNuxtModule({
         const isSchemaFile = path.endsWith(".graphql");
         const isResolverFile = options.resolvers && path.includes(options.resolvers.replace("./", ""));
         if (isSchemaFile || isResolverFile) {
-          logger.info(`${path} changed`);
           if (!cacheClearing) {
             cacheClearing = true;
             try {

package/dist/runtime/graphql.d.ts

@@ -0,0 +1,6 @@
+/**
+ * GraphQL operations handler
+ * Handles POST requests with GraphQL queries, mutations, and subscriptions
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike> | import("grafserv").JSONValue | undefined>>;
+export default _default;

package/dist/runtime/graphql.js

@@ -0,0 +1,9 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { getGrafservInstance } from "./handler.js";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const options = config.grafserv;
+  const serv = await getGrafservInstance(options);
+  return serv.handleGraphQLEvent(event);
+});

package/dist/runtime/handler.d.ts

@@ -1,9 +1,17 @@
+import { grafserv } from 'grafserv/h3/v1';
+import type { ModuleOptions } from '../types.js';
+/**
+ * Get or create the grafserv instance
+ * Exported for use by separate handler files
+ */
+export declare function getGrafservInstance(options: ModuleOptions): Promise<ReturnType<typeof grafserv>>;
 /**
  * Clear the cached instances (useful for development hot reload)
  */
 export declare function clearGrafservCache(): Promise<void>;
 /**
- * Main H3 event handler for GraphQL requests
+ * Main H3 event handler for GraphQL requests and Ruru UI
+ * Routes between GraphQL operations and GraphiQL UI based on request type
  */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike> | import("grafserv").JSONValue | undefined>>;
 export default _default;

package/dist/runtime/handler.js

@@ -1,22 +1,9 @@
-import { grafserv } from "grafserv/h3/v1";
-import { makeGrafastSchema } from "grafast";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
 import { loadTypedefs } from "@graphql-tools/load";
+import { grafserv } from "grafserv/h3/v1";
+import { makeGrafastSchema } from "grafast";
 import { defineEventHandler } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-let middlewareFunctions = null;
-async function getMiddleware() {
-  if (middlewareFunctions !== null) {
-    return middlewareFunctions;
-  }
-  try {
-    const mod = await import("#internal/grafserv/middleware");
-    middlewareFunctions = mod.default || [];
-  } catch {
-    middlewareFunctions = [];
-  }
-  return middlewareFunctions;
-}
 let grafservInstance = null;
 let cachedSchema = null;
 async function loadTypeDefsFromFiles(schemaPath) {
@@ -26,58 +13,80 @@ async function loadTypeDefsFromFiles(schemaPath) {
   });
   return sources.map((source) => source.document).filter(Boolean);
 }
+function isPostGraphileInstance(value) {
+  return value !== null && typeof value === "object" && "getSchema" in value && typeof value.getSchema === "function";
+}
 async function getSchema(options) {
   if (cachedSchema) {
     return cachedSchema;
   }
   let schema;
-  if (typeof options.schema === "function") {
+  if (isPostGraphileInstance(options.schema)) {
+    console.debug("[@stonecrop/nuxt-grafserv] Using PostGraphile instance for schema");
+    try {
+      if ("getSchemaResult" in options.schema && typeof options.schema.getSchemaResult === "function") {
+        const result = await options.schema.getSchemaResult();
+        schema = result.schema;
+      } else {
+        schema = await options.schema.getSchema();
+      }
+      console.debug("[@stonecrop/nuxt-grafserv] PostGraphile schema loaded successfully");
+    } catch (error) {
+      console.error("[@stonecrop/nuxt-grafserv] Error loading PostGraphile schema:", error);
+      throw error;
+    }
+  } else if (typeof options.schema === "function") {
     schema = await options.schema();
   } else if (options.schema) {
     const typeDefDocs = await loadTypeDefsFromFiles(options.schema);
-    let plans = {};
+    const objects = {};
     if (options.resolvers) {
       try {
         const resolverModule = await import("#internal/grafserv/resolvers");
         const resolvers = resolverModule.default || resolverModule;
-        console.log("[@stonecrop/nuxt-grafserv] Resolvers loaded:", Object.keys(resolvers));
+        console.debug("[@stonecrop/nuxt-grafserv] Resolvers loaded:", Object.keys(resolvers));
         for (const typeName of Object.keys(resolvers)) {
-          plans[typeName] = {};
           const typeResolvers = resolvers[typeName];
-          for (const fieldName of Object.keys(typeResolvers)) {
-            const resolver = typeResolvers[fieldName];
-            if (typeof resolver === "function") {
-              plans[typeName][fieldName] = { resolve: resolver };
-            } else {
-              plans[typeName][fieldName] = resolver;
-            }
+          if (typeResolvers && typeof typeResolvers === "object" && "plans" in typeResolvers) {
+            objects[typeName] = typeResolvers;
+          } else {
+            objects[typeName] = { plans: typeResolvers };
           }
         }
       } catch (e) {
-        console.warn("[@stonecrop/nuxt-grafserv] Could not load resolvers:", e);
+        console.error("[@stonecrop/nuxt-grafserv] Error loading resolvers:", e);
+        console.warn("[@stonecrop/nuxt-grafserv] Continuing without resolvers - this is normal for PostGraphile setups");
       }
+    } else {
+      console.debug(
+        "[@stonecrop/nuxt-grafserv] No resolvers specified - using schema-only mode (normal for PostGraphile)"
+      );
+    }
+    try {
+      schema = makeGrafastSchema({
+        typeDefs: typeDefDocs,
+        objects
+      });
+      console.debug("[@stonecrop/nuxt-grafserv] Grafast schema created successfully");
+    } catch (error) {
+      console.error("[@stonecrop/nuxt-grafserv] Error creating Grafast schema:", error);
+      throw error;
     }
-    schema = makeGrafastSchema({
-      typeDefs: typeDefDocs,
-      plans
-    });
   } else {
-    throw new Error("[@stonecrop/nuxt-grafserv] No schema provided. Configure schema path or provider function.");
+    throw new Error(
+      "[@stonecrop/nuxt-grafserv] No schema provided. Configure schema path, provider function, or PostGraphile instance."
+    );
   }
   cachedSchema = schema;
   return schema;
 }
-async function getGrafservInstance(options) {
+export async function getGrafservInstance(options) {
   if (grafservInstance) {
+    console.log("[@stonecrop/nuxt-grafserv] Returning cached grafserv instance");
     return grafservInstance;
   }
   const schema = await getSchema(options);
-  const isDev = process.env.NODE_ENV === "development";
-  grafservInstance = grafserv({
-    schema,
-    graphiql: options.graphiql ?? isDev,
-    websockets: options.grafserv?.websockets ?? false
-  });
+  grafservInstance = grafserv({ schema, preset: options.preset });
   console.log("[@stonecrop/nuxt-grafserv] Grafserv instance created");
   return grafservInstance;
 }
@@ -86,46 +95,16 @@ export async function clearGrafservCache() {
   cachedSchema = null;
   console.log("[@stonecrop/nuxt-grafserv] Cache cleared");
 }
-async function applyMiddleware(context, middleware) {
-  if (!middleware || middleware.length === 0) {
-    return context;
-  }
-  const applyNext = async (index) => {
-    if (index >= middleware.length) {
-      return context;
-    }
-    return middleware[index](context, () => applyNext(index + 1));
-  };
-  return applyNext(0);
-}
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
   const options = config.grafserv;
   try {
-    if (event.node.req.url?.includes("/__grafserv_cache_clear") && process.env.NODE_ENV === "development") {
-      await clearGrafservCache();
-      return { success: true, message: "Cache cleared" };
-    }
-    const { req } = event.node;
-    const context = {
-      req: new Request(new URL(req.url || "/", `http://${req.headers.host || "localhost"}`), {
-        method: req.method,
-        headers: req.headers
-      }),
-      params: event.context.params || {}
-    };
-    const middleware = await getMiddleware();
-    await applyMiddleware(context, middleware);
     const serv = await getGrafservInstance(options);
-    const url = event.node.req.url || "";
-    const method = event.node.req.method || "GET";
-    if (url.includes("/ruru-static/")) {
-      return serv.handleGraphiqlStaticEvent(event);
-    }
-    if (method === "GET" && url.match(/\/graphql\/?(\?.*)?$/)) {
-      return serv.handleGraphiqlEvent(event);
+    const graphqlResult = await serv.handleGraphQLEvent(event);
+    if (graphqlResult !== null) {
+      return graphqlResult;
     }
-    return serv.handleGraphQLEvent(event);
+    return serv.handleGraphiqlEvent(event);
   } catch (error) {
     console.error("[@stonecrop/nuxt-grafserv] Error in GraphQL handler:", error);
     throw error;

package/dist/runtime/ruru-static.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ruru/GraphiQL static assets handler
+ * Serves CSS, JavaScript, and other static files for the GraphQL IDE
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike> | import("grafserv").JSONValue | undefined>>;
+export default _default;

package/dist/runtime/ruru-static.js

@@ -0,0 +1,9 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { getGrafservInstance } from "./handler.js";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const options = config.grafserv;
+  const serv = await getGrafservInstance(options);
+  return serv.handleGraphiqlStaticEvent(event);
+});

package/dist/runtime/ruru.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ruru/GraphiQL UI handler
+ * Serves the GraphQL IDE interface for exploring and testing the API
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike> | import("grafserv").JSONValue | undefined>>;
+export default _default;

package/dist/runtime/ruru.js

@@ -0,0 +1,9 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { getGrafservInstance } from "./handler.js";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const options = config.grafserv;
+  const serv = await getGrafservInstance(options);
+  return serv.handleGraphiqlEvent(event);
+});

package/dist/types.d.mts

@@ -1,7 +1,3 @@
-import type { NuxtModule } from '@nuxt/schema'
-
-import type { default as Module } from './module.mjs'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
 export { default } from './module.mjs'
+
+export { type ModuleOptions, type SchemaProvider } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/nuxt-grafserv",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Pluggable Grafserv GraphQL server as Nuxt Module",
   "license": "MIT",
   "type": "module",
@@ -19,16 +19,16 @@
   "exports": {
     ".": {
       "import": "./dist/module.mjs",
-      "types": "./dist/types.d.mts"
+      "types": "./dist/module.d.mts"
     },
     "./runtime/*": "./dist/runtime/*"
   },
   "main": "./dist/module.mjs",
-  "types": "./dist/types.d.mts",
+  "types": "./dist/module.d.mts",
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/types.d.mts"
+        "./dist/module.d.mts"
       ]
     }
   },
@@ -40,14 +40,14 @@
     "@graphql-tools/load": "^8.1.8",
     "@graphql-tools/stitch": "^10.1.8",
     "@graphql-tools/wrap": "^11.1.4",
-    "grafast": "^1.0.0-rc.3",
-    "grafserv": "^1.0.0-rc.3",
-    "graphile-config": "^1.0.0-rc.2",
+    "grafast": "^1.0.0-rc.4",
+    "grafserv": "^1.0.0-rc.4",
+    "graphile-config": "^1.0.0-rc.3",
     "graphql": "^16.12.0",
-    "@stonecrop/graphql-middleware": "0.7.4"
+    "@stonecrop/graphql-middleware": "0.7.6"
   },
   "devDependencies": {
-    "@casl/ability": "^6.7.5",
+    "@casl/ability": "^6.8.0",
     "@eslint/js": "^9.39.2",
     "@nuxt/devtools": "^3.1.1",
     "@nuxt/eslint-config": "^1.12.1",
@@ -57,22 +57,23 @@
     "@nuxt/test-utils": "^3.23.0",
     "@vitest/coverage-istanbul": "^4.0.17",
     "@types/node": "^22.19.5",
-    "h3": "^1.15.4",
-    "nitropack": "^2.13.0",
+    "h3": "^1.15.5",
+    "nitropack": "^2.13.1",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "jsdom": "^27.4.0",
     "nuxt": "^4.2.2",
+    "postgraphile": "^5.0.0-rc.4",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
     "vitest": "^4.0.17",
     "vue-tsc": "^3.2.2",
-    "@stonecrop/casl-middleware": "0.7.4",
-    "@stonecrop/rockfoil": "0.7.4"
+    "@stonecrop/casl-middleware": "0.7.6",
+    "@stonecrop/rockfoil": "0.7.6"
   },
   "peerDependencies": {
-    "@stonecrop/casl-middleware": "0.7.4",
-    "@stonecrop/rockfoil": "0.7.4"
+    "@stonecrop/casl-middleware": "0.7.6",
+    "@stonecrop/rockfoil": "0.7.6"
   },
   "peerDependenciesMeta": {
     "@stonecrop/casl-middleware": {
@@ -93,6 +94,8 @@
     "lint": "eslint .",
     "test": "vitest run",
     "test:ci": "vitest run --run",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "vitest run test/e2e",
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   }