@stonecrop/nuxt-grafserv 0.7.6 → 0.7.8

package/README.md

@@ -31,79 +31,169 @@ The module automatically registers these handlers:
 
 ## Quick Setup
 
-1. Add `@stonecrop/nuxt-grafserv` dependency to your project:
+### PostGraphile Integration (Recommended)
+
+For PostGraphile users, this is the recommended configuration approach:
+
+1. Add dependencies:
 
 ```bash
 # Using pnpm
-pnpm add @stonecrop/nuxt-grafserv
+pnpm add @stonecrop/nuxt-grafserv postgraphile
 
 # Using yarn
-yarn add @stonecrop/nuxt-grafserv
+yarn add @stonecrop/nuxt-grafserv postgraphile
 
 # Using npm
-npm install @stonecrop/nuxt-grafserv
+npm install @stonecrop/nuxt-grafserv postgraphile
 ```
 
-2. Add `@stonecrop/nuxt-grafserv` to the `modules` section of `nuxt.config.ts`:
+2. Configure 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', // Required: specify configuration type
+    preset: {
+      extends: [PostGraphileAmberPreset],
+      pgServices: [
+        makePgService({
+          connectionString: process.env.DATABASE_URL || 'postgresql://localhost/mydb',
+          schemas: ['public'],
+        }),
+      ],
+    },
+    url: '/graphql',
+    graphiql: true,
+  }
+})
+```
+
+### Custom Schema Configuration
+
+For custom GraphQL schemas with your own resolvers:
+
+1. Add dependency:
+
+```bash
+pnpm add @stonecrop/nuxt-grafserv
+```
+
+2. Configure in `nuxt.config.ts`:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['@stonecrop/nuxt-grafserv'],
+  grafserv: {
+    type: 'schema', // Required: specify configuration type
     schema: 'server/**/*.graphql',
     resolvers: 'server/resolvers.ts',
-    url: '/graphql/', // Serves both GraphQL API and Ruru UI
+    url: '/graphql',
+    graphiql: true,
   }
 })
 ```
 
 ## Configuration
 
-### All Available Options
+The module supports two configuration types using a discriminated union pattern:
+
+### PostGraphile Configuration
 
-| 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 |
+Use `type: 'postgraphile'` for PostGraphile-based GraphQL APIs:
 
-### Full Configuration Example
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `type` | `'postgraphile'` | ✅ | Configuration type discriminator |
+| `preset` | `GraphileConfig.Preset` | ✅ | PostGraphile preset passed to makeSchema() |
+| `url` | `string` | ❌ | GraphQL endpoint URL (default: '/graphql/') |
+| `graphiql` | `boolean` | ❌ | Enable GraphiQL IDE (default: true in dev, false in prod) |
+
+**Example:**
 
 ```ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+
 export default defineNuxtConfig({
-  modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
-    // Schema configuration
+    type: 'postgraphile',
+    preset: {
+      extends: [PostGraphileAmberPreset],
+      pgServices: [
+        makePgService({
+          connectionString: process.env.DATABASE_URL,
+          schemas: ['public'],
+        }),
+      ],
+      plugins: [MyCustomPlugin],
+    },
+    url: '/graphql',
+    graphiql: true,
+  }
+})
+```
+
+### Schema Configuration
+
+Use `type: 'schema'` for custom GraphQL schemas with Grafast resolvers:
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `type` | `'schema'` | ✅ | Configuration type discriminator |
+| `schema` | `string \| string[] \| SchemaProvider` | ✅ | Path(s) to .graphql files or schema provider function |
+| `resolvers` | `string` | ❌ | Path to resolvers file (required for .graphql files) |
+| `url` | `string` | ❌ | GraphQL endpoint URL (default: '/graphql/') |
+| `graphiql` | `boolean` | ❌ | Enable GraphiQL IDE (default: true in dev, false in prod) |
+
+**Example with files:**
+
+```ts
+export default defineNuxtConfig({
+  grafserv: {
+    type: 'schema',
     schema: 'server/**/*.graphql',
     resolvers: 'server/resolvers.ts',
+    url: '/graphql',
+  }
+})
+```
 
-    // Endpoints
-    url: '/graphql/', // Serves both GraphQL API and Ruru UI
-    graphiql: true,
+**Example with schema provider function:**
 
-    // 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
-      }
+```ts
+export default defineNuxtConfig({
+  grafserv: {
+    type: 'schema',
+    schema: async () => {
+      // Return a GraphQLSchema instance
+      return myCustomSchema
     },
   }
 })
 ```
 
+### Configuration Comparison
+
+| Feature | PostGraphile Config | Schema Config |
+|---------|---------------------|---------------|
+| Type discriminator | `type: 'postgraphile'` | `type: 'schema'` |
+| Schema source | Generated from preset | Files or function |
+| Resolvers | Auto-generated by PostGraphile | Must provide via resolvers file |
+| Primary use case | PostgreSQL-backed APIs | Custom GraphQL APIs |
+| Setup complexity | Minimal (DB connection only) | Moderate (schema + resolvers) |
+| Plugin system | PostGraphile plugins | Grafast standard steps |
+
 ## Basic Usage
 
+### Schema Configuration Example
+
+For custom schemas with resolvers:
+
 1. Create your GraphQL schema (`server/schema.graphql`):
 
 ```graphql
@@ -120,7 +210,7 @@ type Mutation {
 2. Create your resolvers (`server/resolvers.ts`):
 
 ```typescript
-import { constant, lambda, access, object, filter, type GrafastSchemaConfig } from 'grafast'
+import { constant, lambda, type GrafastSchemaConfig } from 'grafast'
 
 const resolvers: GrafastSchemaConfig['objects'] = {
   Query: {
@@ -142,18 +232,68 @@ const resolvers: GrafastSchemaConfig['objects'] = {
 export default resolvers
 ```
 
+3. Configure Nuxt:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['@stonecrop/nuxt-grafserv'],
+  grafserv: {
+    type: 'schema',
+    schema: 'server/schema.graphql',
+    resolvers: 'server/resolvers.ts',
+  }
+})
+```
+
+### PostGraphile Configuration Example
+
+For database-backed GraphQL APIs:
+
+1. 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({
+          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
 
-### Middleware via Grafserv Plugins
+### Grafserv Middleware and Plugins
 
-For middleware functionality (authentication, logging, etc.), use Grafserv plugins. The CLI installer creates a `server/plugins.ts` file with examples.
+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.
 
-#### Inline Plugin Configuration
+#### Inline Plugin Configuration (PostGraphile)
 
 ```ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+
 export default defineNuxtConfig({
   grafserv: {
+    type: 'postgraphile',
     preset: {
+      extends: [PostGraphileAmberPreset],
+      pgServices: [makePgService({ /* ... */ })],
       plugins: [
         {
           name: 'request-logging',
@@ -163,9 +303,7 @@ export default defineNuxtConfig({
               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
               }
@@ -178,17 +316,34 @@ export default defineNuxtConfig({
 })
 ```
 
+#### 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
+  }
+})
+```
+
 #### Using External Plugin File
 
 ```ts
 // nuxt.config.ts
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
 import plugins from './server/plugins'
 
 export default defineNuxtConfig({
   grafserv: {
-    schema: 'server/schema.graphql',
-    resolvers: 'server/resolvers.ts',
+    type: 'postgraphile',
     preset: {
+      extends: [PostGraphileAmberPreset],
+      pgServices: [makePgService({ /* ... */ })],
       plugins
     }
   }
@@ -219,7 +374,10 @@ const authPlugin: GraphileConfig.Plugin = {
     middleware: {
       processGraphQLRequestBody: async (next, event) => {
         const token = event.request.headers.get('authorization')
-        // TODO: Validate token and add user to context
+        // Validate token and add user to context
+        if (!token) {
+          throw new Error('Unauthorized')
+        }
         return next()
       }
     }
@@ -236,166 +394,128 @@ export default [loggingPlugin, authPlugin]
 - `ruruHTML` - Customize Ruru IDE HTML generation
 - `onSubscribe` - Handle GraphQL subscriptions
 
-## Advanced Usage
-
-### PostGraphile Integration
+## 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.
+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.
 
-#### Setup with PostGraphile
-
-1. Install PostGraphile:
+### Prerequisites
 
 ```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 }
+pnpm add postgraphile
 ```
 
-3. Configure Nuxt to use the PostGraphile schema:
+### Basic PostGraphile Setup
 
 ```typescript
 // nuxt.config.ts
-import { createPostGraphileSchema } from './server/graphql/schema'
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
 
 export default defineNuxtConfig({
   modules: ['@stonecrop/nuxt-grafserv'],
   grafserv: {
-    // Use PostGraphile schema provider function
-    schema: createPostGraphileSchema,
-    // No resolvers needed - PostGraphile generates everything
+    type: 'postgraphile',
+    preset: {
+      extends: [PostGraphileAmberPreset],
+      pgServices: [
+        makePgService({
+          connectionString: process.env.DATABASE_URL || 'postgresql://localhost/mydb',
+          schemas: ['public'],
+        }),
+      ],
+    },
     url: '/graphql',
-    graphiql: true, // Enable Ruru IDE
+    graphiql: true,
   }
 })
 ```
 
-#### Direct PostGraphile Instance Usage
+### PostGraphile with Custom Plugins
 
-You can also pass a PostGraphile instance directly:
+Enhance your PostGraphile setup with community plugins:
 
 ```typescript
 // nuxt.config.ts
-import { pgl } from './server/graphql/schema'
+import { PostGraphileAmberPreset } from 'postgraphile/presets/amber'
+import { makePgService } from 'postgraphile/adaptors/pg'
+import PgSimplifyInflectorPlugin from '@graphile-contrib/pg-simplify-inflector'
 
 export default defineNuxtConfig({
   grafserv: {
-    schema: pgl, // Pass PostGraphile instance directly
-    url: '/graphql',
+    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
+      },
+    },
   }
 })
 ```
 
-#### PostGraphile with Custom Plugins
-
-Enhance your PostGraphile setup with custom plugins:
+### Advanced PostGraphile Configuration
 
 ```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'],
-    },
-  ],
-  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'
+import { makePgService } from 'postgraphile/adaptors/pg'
 
 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, // Enable plan diagrams for debugging
-        context: {
-          // Custom context available in all resolvers
-          apiVersion: '1.0'
-        }
+        explain: true,
+        context: (requestContext) => ({
+          // Custom context for all resolvers
+          userId: requestContext.user?.id,
+        }),
       },
-      grafserv: {
-        graphqlOverGET: true,
-        maxRequestLength: 200000
-      }
-    }
+    },
   }
 })
 ```
 
+### Benefits of PostGraphile Integration
+
+- **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
+
 ### Accessing Grafserv Instance
 
-For advanced use cases, you can access the grafserv instance directly:
+For advanced use cases, you can access the grafserv instance directly in server routes:
 
 ```ts
 // server/api/custom.ts
@@ -406,10 +526,13 @@ export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig()
   const serv = await getGrafservInstance(config.grafserv)
 
-  // Access grafserv methods or configuration
-  const preset = serv.getPreset()
+  // Access grafserv methods
+  // Note: serv contains the grafserv instance with your schema
 
-  return { preset }
+  return {
+    status: 'GraphQL server is running',
+    endpoint: config.grafserv.url
+  }
 })
 ```
 

package/dist/module.d.mts

@@ -1,5 +1,4 @@
 import { NuxtModule } from '@nuxt/schema';
-import { PromiseOrDirect } from 'grafast';
 import { GraphQLSchema } from 'graphql';
 import { GraphileConfig } from 'graphile-config';
 
@@ -8,32 +7,110 @@ import { GraphileConfig } from 'graphile-config';
  */
 type SchemaProvider = () => GraphQLSchema | Promise<GraphQLSchema>;
 /**
- * PostGraphile instance interface (minimal type for compatibility)
+ * 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.
+ *
+ * @example
+ * ```typescript
+ * 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'],
+ *         }),
+ *       ],
+ *       plugins: [MyCustomPlugin],
+ *     },
+ *     url: '/graphql',
+ *     graphiql: true,
+ *   },
+ * })
+ * ```
  */
-interface PostGraphileInstance {
-    getSchema(): PromiseOrDirect<GraphQLSchema>;
-    getSchemaResult(): PromiseOrDirect<{
-        schema: GraphQLSchema;
-        resolvedPreset: GraphileConfig.ResolvedPreset;
-    }>;
+interface PostGraphileConfig {
+    /** Configuration type discriminator */
+    type: 'postgraphile';
+    /** PostGraphile preset configuration - passed to makeSchema() */
+    preset: GraphileConfig.Preset;
+    /** GraphQL endpoint URL (default: '/graphql/') */
+    url?: string;
+    /** Whether to enable GraphiQL IDE (default: true in dev, false in prod) */
+    graphiql?: boolean;
 }
 /**
- * Configuration for the Grafast module
+ * Schema configuration using GraphQL schema files or provider function
+ *
+ * Use this for custom GraphQL schemas with Grafast resolvers.
+ * Schema files (.graphql) are loaded and combined with resolver functions.
+ *
+ * @example
+ * ```typescript
+ * // Using schema files with resolvers
+ * export default defineNuxtConfig({
+ *   modules: ['@stonecrop/nuxt-grafserv'],
+ *   grafserv: {
+ *     type: 'schema',
+ *     schema: 'server/schema/**\/*.graphql',
+ *     resolvers: 'server/resolvers/index.ts',
+ *     url: '/graphql',
+ *     graphiql: true,
+ *   },
+ * })
+ *
+ * // Using schema provider function
+ * export default defineNuxtConfig({
+ *   grafserv: {
+ *     type: 'schema',
+ *     schema: async () => {
+ *       // Return a GraphQLSchema instance
+ *       return myCustomSchema
+ *     },
+ *   },
+ * })
+ * ```
  */
-interface ModuleOptions {
-    /** 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) */
+interface SchemaConfig {
+    /** Configuration type discriminator */
+    type: 'schema';
+    /**
+     * Path to schema file(s) or schema provider function
+     * - String: Single file path (e.g., 'server/schema/schema.graphql')
+     * - Array: Multiple file paths (e.g., ['server/schema/**\/*.graphql'])
+     * - Function: Returns a GraphQL schema directly
+     */
+    schema: string | string[] | SchemaProvider;
+    /**
+     * Path to resolvers file (optional)
+     * Only needed when using .graphql schema files.
+     * Should export Grafast resolver objects.
+     *
+     * @example 'server/resolvers/index.ts'
+     */
     resolvers?: string;
     /** GraphQL endpoint URL (default: '/graphql/') */
     url?: string;
     /** Whether to enable GraphiQL IDE (default: true in dev, false in prod) */
     graphiql?: boolean;
-    /** Custom Graphile preset to extend (for advanced grafast configuration) */
-    preset?: GraphileConfig.Preset;
 }
+/**
+ * Module configuration - use either PostGraphile preset or custom schema
+ *
+ * @see PostGraphileConfig for PostGraphile integration
+ * @see SchemaConfig for custom schemas with resolvers
+ */
+type ModuleOptions = PostGraphileConfig | SchemaConfig;
 
 declare const module$1: NuxtModule<ModuleOptions>;
 
 export { module$1 as default };
-export type { ModuleOptions, SchemaProvider };
+export type { ModuleOptions, PostGraphileConfig, SchemaConfig, SchemaProvider };

package/dist/module.json

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

package/dist/module.mjs

@@ -1,28 +1,59 @@
 import { join } from 'node:path';
 import { createRequire } from 'node:module';
-import { useLogger, defineNuxtModule, createResolver } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTemplate } from '@nuxt/kit';
 
 const logger = useLogger("@stonecrop/nuxt-grafserv");
+function validateConfig(options) {
+  if (!options.type) {
+    throw new Error(
+      `[@stonecrop/nuxt-grafserv] Configuration error: 'type' field is required. Must be either 'postgraphile' or 'schema'. 
+Example: grafserv: { type: 'postgraphile', preset: { ... } }`
+    );
+  }
+  if (options.type === "postgraphile") {
+    const config = options;
+    if (!config.preset) {
+      throw new Error(
+        `[@stonecrop/nuxt-grafserv] PostGraphile configuration error: 'preset' field is required when type is 'postgraphile'. 
+Example: { type: 'postgraphile', preset: { extends: [PostGraphileAmberPreset], ... } }`
+      );
+    }
+    if ("schema" in config || "resolvers" in config) {
+      logger.warn(
+        `PostGraphile configuration should not include 'schema' or 'resolvers' fields. The schema is generated from the 'preset' configuration.`
+      );
+    }
+  } else if (options.type === "schema") {
+    const config = options;
+    if (!config.schema) {
+      throw new Error(
+        `[@stonecrop/nuxt-grafserv] Schema configuration error: 'schema' field is required when type is 'schema'. 
+Example: { type: 'schema', schema: 'server/**/*.graphql', resolvers: 'server/resolvers/index.ts' }`
+      );
+    }
+    if ("preset" in config) {
+      logger.warn(
+        `Schema configuration should not include 'preset' field. Use type: 'postgraphile' for PostGraphile preset configuration.`
+      );
+    }
+  } else {
+    throw new Error(
+      `[@stonecrop/nuxt-grafserv] Configuration error: Invalid type '${options.type}'. Must be either 'postgraphile' or 'schema'.`
+    );
+  }
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "@stonecrop/nuxt-grafserv",
     configKey: "grafserv"
   },
-  defaults: (_nuxt) => ({
-    schema: "server/**/*.graphql",
-    resolvers: void 0,
-    // Optional - not needed for PostGraphile setups
-    url: "/graphql/",
-    graphiql: void 0,
-    // Will default based on dev mode
-    plugins: [],
-    preset: {
-      grafserv: {
-        websockets: false
-      }
-    }
-  }),
+  // No defaults - user must provide complete config with type discriminator
+  // Use undefined instead of {} to ensure user config is passed as-is
   setup(options, nuxt) {
+    if (Object.keys(options).length === 0) {
+      return;
+    }
+    validateConfig(options);
     const { resolve } = createResolver(import.meta.url);
     const require = createRequire(import.meta.url);
     nuxt.hook("nitro:config", (config) => {
@@ -44,36 +75,55 @@ const module$1 = defineNuxtModule({
       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,
-        // 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}'`;
+      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)}`;
+          }
+        });
+        config.runtimeConfig = config.runtimeConfig || {};
+        config.runtimeConfig.grafserv = {
+          type: "postgraphile",
+          url: options.url || "/graphql/",
+          graphiql: options.graphiql,
+          presetPath: template.dst
+        };
+      } else if (options.type === "schema") {
+        logger.info("Using schema configuration");
+        const resolverPath = options.resolvers ? resolveForVirtualModule(options.resolvers) : void 0;
+        if (resolverPath) {
+          logger.info(`Resolved resolver path: ${resolverPath}`);
+        } else {
+          logger.info("No resolvers configured");
+        }
+        let runtimeSchema;
+        if (typeof options.schema === "function") {
+          runtimeSchema = options.schema;
+          logger.info("Using schema provider function");
+        } 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 = {
+          type: "schema",
+          schema: runtimeSchema,
+          resolversPath: resolverPath,
+          url: options.url || "/graphql/",
+          graphiql: options.graphiql
+        };
+        config.virtual = config.virtual || {};
+        if (resolverPath) {
+          config.virtual["#internal/grafserv/resolvers"] = `export { default } from '${resolverPath}'`;
+        }
       }
       config.externals = config.externals || {};
       config.externals.external = config.externals.external || [];
@@ -119,7 +169,7 @@ const module$1 = defineNuxtModule({
       let cacheClearing = false;
       nuxt.hook("builder:watch", async (event, path) => {
         const isSchemaFile = path.endsWith(".graphql");
-        const isResolverFile = options.resolvers && path.includes(options.resolvers.replace("./", ""));
+        const isResolverFile = options.type === "schema" && options.resolvers && path.includes(options.resolvers.replace("./", ""));
         if (isSchemaFile || isResolverFile) {
           if (!cacheClearing) {
             cacheClearing = true;

package/dist/runtime/handler.js

@@ -13,69 +13,74 @@ 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 (isPostGraphileInstance(options.schema)) {
-    console.debug("[@stonecrop/nuxt-grafserv] Using PostGraphile instance for schema");
+  if (options.type === "postgraphile") {
+    console.debug("[@stonecrop/nuxt-grafserv] Creating schema from PostGraphile preset");
     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();
+      const { makeSchema } = await import("postgraphile");
+      const config = useRuntimeConfig();
+      if (config.grafserv.type !== "postgraphile") {
+        throw new Error("Expected PostGraphile configuration");
       }
-      console.debug("[@stonecrop/nuxt-grafserv] PostGraphile schema loaded successfully");
+      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");
     } catch (error) {
-      console.error("[@stonecrop/nuxt-grafserv] Error loading PostGraphile schema:", 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);
       throw error;
     }
-  } else if (typeof options.schema === "function") {
-    schema = await options.schema();
-  } else if (options.schema) {
-    const typeDefDocs = await loadTypeDefsFromFiles(options.schema);
-    const objects = {};
-    if (options.resolvers) {
-      try {
-        const resolverModule = await import("#internal/grafserv/resolvers");
-        const resolvers = resolverModule.default || resolverModule;
-        console.debug("[@stonecrop/nuxt-grafserv] Resolvers loaded:", Object.keys(resolvers));
-        for (const typeName of Object.keys(resolvers)) {
-          const typeResolvers = resolvers[typeName];
-          if (typeResolvers && typeof typeResolvers === "object" && "plans" in typeResolvers) {
-            objects[typeName] = typeResolvers;
-          } else {
-            objects[typeName] = { plans: typeResolvers };
+  } else if (options.type === "schema") {
+    if (typeof options.schema === "function") {
+      console.debug("[@stonecrop/nuxt-grafserv] Using schema provider function");
+      schema = await options.schema();
+    } else {
+      console.debug("[@stonecrop/nuxt-grafserv] Loading schema from file(s)");
+      const typeDefDocs = await loadTypeDefsFromFiles(options.schema);
+      const objects = {};
+      if (options.resolversPath) {
+        try {
+          const resolverModule = await import("#internal/grafserv/resolvers");
+          const resolvers = resolverModule.default || resolverModule;
+          console.debug("[@stonecrop/nuxt-grafserv] Resolvers loaded:", Object.keys(resolvers));
+          for (const typeName of Object.keys(resolvers)) {
+            const typeResolvers = resolvers[typeName];
+            if (typeResolvers && typeof typeResolvers === "object" && "plans" in typeResolvers) {
+              objects[typeName] = typeResolvers;
+            } else {
+              objects[typeName] = { plans: typeResolvers };
+            }
           }
+        } catch (e) {
+          console.error("[@stonecrop/nuxt-grafserv] Error loading resolvers:", e);
+          throw e;
         }
-      } catch (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");
+      }
+      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;
       }
-    } 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;
     }
   } else {
-    throw new Error(
-      "[@stonecrop/nuxt-grafserv] No schema provided. Configure schema path, provider function, or PostGraphile instance."
-    );
+    throw new Error(`[@stonecrop/nuxt-grafserv] Invalid configuration type: ${options.type}`);
   }
   cachedSchema = schema;
   return schema;
@@ -86,7 +91,7 @@ export async function getGrafservInstance(options) {
     return grafservInstance;
   }
   const schema = await getSchema(options);
-  grafservInstance = grafserv({ schema, preset: options.preset });
+  grafservInstance = grafserv({ schema });
   console.log("[@stonecrop/nuxt-grafserv] Grafserv instance created");
   return grafservInstance;
 }

package/dist/types.d.mts

@@ -1,3 +1,3 @@
 export { default } from './module.mjs'
 
-export { type ModuleOptions, type SchemaProvider } from './module.mjs'
+export { type ModuleOptions, type PostGraphileConfig, type SchemaConfig, type SchemaProvider } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/nuxt-grafserv",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Pluggable Grafserv GraphQL server as Nuxt Module",
   "license": "MIT",
   "type": "module",
@@ -42,12 +42,10 @@
     "@graphql-tools/wrap": "^11.1.4",
     "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.6"
+    "@stonecrop/graphql-middleware": "0.7.8"
   },
   "devDependencies": {
-    "@casl/ability": "^6.8.0",
     "@eslint/js": "^9.39.2",
     "@nuxt/devtools": "^3.1.1",
     "@nuxt/eslint-config": "^1.12.1",
@@ -67,13 +65,13 @@
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
     "vitest": "^4.0.17",
-    "vue-tsc": "^3.2.2",
-    "@stonecrop/casl-middleware": "0.7.6",
-    "@stonecrop/rockfoil": "0.7.6"
+    "vue-tsc": "^3.2.2"
   },
   "peerDependencies": {
-    "@stonecrop/casl-middleware": "0.7.6",
-    "@stonecrop/rockfoil": "0.7.6"
+    "@stonecrop/casl-middleware": "*",
+    "@stonecrop/rockfoil": "*",
+    "postgraphile": "^5.0.0-rc.4",
+    "graphile-config": "^1.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@stonecrop/casl-middleware": {
@@ -81,6 +79,12 @@
     },
     "@stonecrop/rockfoil": {
       "optional": true
+    },
+    "postgraphile": {
+      "optional": true
+    },
+    "graphile-config": {
+      "optional": true
     }
   },
   "scripts": {