graphile-query 2.6.0 → 4.0.1

package/esm/index.js

@@ -1,64 +1,194 @@
-import { graphql } from 'graphql';
-import { print } from 'graphql/language/printer';
-import { createPostGraphileSchema, withPostGraphileContext } from 'postgraphile';
-export const getSchema = async (pool, settings) => await createPostGraphileSchema(pool, settings.schema, settings);
+import { parse } from 'graphql';
+import { makeSchema } from 'graphile-build';
+import { defaultPreset as graphileBuildDefaultPreset } from 'graphile-build';
+import { defaultPreset as graphileBuildPgDefaultPreset, withPgClientFromPgService } from 'graphile-build-pg';
+import { makePgService } from 'graphile-settings';
+import { execute } from 'grafast';
+/**
+ * Minimal preset that provides core functionality without Node/Relay.
+ * This matches the pattern from graphile-settings.
+ */
+const MinimalPreset = {
+    extends: [graphileBuildDefaultPreset, graphileBuildPgDefaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+/**
+ * Create a GraphQL schema using PostGraphile v5's preset-based API.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration including database schemas and optional preset
+ * @returns Promise resolving to schema, resolved preset, and pgService
+ */
+export const getSchema = async (pool, settings) => {
+    const schemas = Array.isArray(settings.schema) ? settings.schema : [settings.schema];
+    // Create the pgService for database access
+    const pgService = makePgService({
+        pool,
+        schemas,
+    });
+    // Build the complete preset
+    const completePreset = {
+        extends: [
+            MinimalPreset,
+            ...(settings.preset?.extends ?? []),
+        ],
+        ...(settings.preset?.disablePlugins && { disablePlugins: settings.preset.disablePlugins }),
+        ...(settings.preset?.plugins && { plugins: settings.preset.plugins }),
+        ...(settings.preset?.schema && { schema: settings.preset.schema }),
+        ...(settings.preset?.grafast && { grafast: settings.preset.grafast }),
+        pgServices: [pgService],
+    };
+    // Use makeSchema from graphile-build to create the schema
+    const result = await makeSchema(completePreset);
+    return {
+        schema: result.schema,
+        resolvedPreset: result.resolvedPreset,
+        pgService,
+    };
+};
+/**
+ * GraphileQuery provides a way to execute GraphQL queries against a PostGraphile v5 schema.
+ *
+ * This is the full-featured version that supports pgSettings generation from requests.
+ */
 export class GraphileQuery {
     pool;
     schema;
     settings;
-    constructor({ schema, pool, settings }) {
+    resolvedPreset;
+    pgService;
+    constructor({ schema, pool, settings, resolvedPreset, pgService }) {
         if (!schema)
             throw new Error('requires a schema');
         if (!pool)
             throw new Error('requires a pool');
         if (!settings)
             throw new Error('requires graphile settings');
+        if (!resolvedPreset)
+            throw new Error('requires resolvedPreset');
+        if (!pgService)
+            throw new Error('requires pgService');
         this.pool = pool;
         this.schema = schema;
         this.settings = settings;
+        this.resolvedPreset = resolvedPreset;
+        this.pgService = pgService;
     }
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param options - Query options including query string, variables, and optional role
+     * @returns Promise resolving to the GraphQL execution result
+     */
     async query({ req = {}, query, variables, role }) {
-        const queryString = typeof query === 'string' ? query : print(query);
+        // Parse the query if it's a string
+        const document = typeof query === 'string' ? parse(query) : query;
+        // Generate pgSettings
         const { pgSettings: pgSettingsGenerator } = this.settings;
-        const pgSettings = role != null
-            ? { role }
-            : typeof pgSettingsGenerator === 'function'
-                ? await pgSettingsGenerator(req)
-                : pgSettingsGenerator;
-        return await withPostGraphileContext({
-            ...this.settings,
-            pgPool: this.pool,
-            pgSettings
-        }, async (context) => {
-            return await graphql({
-                schema: this.schema,
-                source: queryString,
-                contextValue: context,
-                variableValues: variables
-            });
+        let pgSettings = {};
+        if (role != null) {
+            pgSettings = { role };
+        }
+        else if (typeof pgSettingsGenerator === 'function') {
+            pgSettings = await pgSettingsGenerator(req);
+        }
+        // Build context with withPgClient using withPgClientFromPgService
+        const withPgClientKey = this.pgService.withPgClientKey ?? 'withPgClient';
+        const contextValue = {
+            pgSettings,
+            [withPgClientKey]: withPgClientFromPgService.bind(null, this.pgService),
+        };
+        // Execute using grafast
+        const result = await execute({
+            schema: this.schema,
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset: this.resolvedPreset,
         });
+        // Handle streaming results
+        if (Symbol.asyncIterator in result) {
+            throw new Error('Streaming results (subscriptions) are not supported');
+        }
+        return result;
     }
 }
+/**
+ * GraphileQuerySimple provides a simplified way to execute GraphQL queries.
+ *
+ * This version doesn't support pgSettings generation from requests - it's meant
+ * for simple use cases where you just need to run queries.
+ */
 export class GraphileQuerySimple {
     pool;
     schema;
-    constructor({ schema, pool }) {
+    resolvedPreset;
+    pgService;
+    constructor({ schema, pool, resolvedPreset, pgService }) {
         if (!schema)
             throw new Error('requires a schema');
         if (!pool)
             throw new Error('requires a pool');
+        if (!resolvedPreset)
+            throw new Error('requires resolvedPreset');
+        if (!pgService)
+            throw new Error('requires pgService');
         this.pool = pool;
         this.schema = schema;
+        this.resolvedPreset = resolvedPreset;
+        this.pgService = pgService;
     }
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param query - GraphQL query string or DocumentNode
+     * @param variables - Optional query variables
+     * @returns Promise resolving to the GraphQL execution result
+     */
     async query(query, variables) {
-        const queryString = typeof query === 'string' ? query : print(query);
-        return await withPostGraphileContext({ pgPool: this.pool }, async (context) => {
-            return await graphql({
-                schema: this.schema,
-                source: queryString,
-                contextValue: context,
-                variableValues: variables
-            });
+        // Parse the query if it's a string
+        const document = typeof query === 'string' ? parse(query) : query;
+        // Build context with withPgClient using withPgClientFromPgService
+        const withPgClientKey = this.pgService.withPgClientKey ?? 'withPgClient';
+        const contextValue = {
+            [withPgClientKey]: withPgClientFromPgService.bind(null, this.pgService),
+        };
+        // Execute using grafast
+        const result = await execute({
+            schema: this.schema,
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset: this.resolvedPreset,
         });
+        // Handle streaming results
+        if (Symbol.asyncIterator in result) {
+            throw new Error('Streaming results (subscriptions) are not supported');
+        }
+        return result;
     }
 }
+/**
+ * Helper function to create a GraphileQuery instance with schema creation.
+ *
+ * This is a convenience function that combines getSchema and GraphileQuery creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuery instance
+ */
+export const createGraphileQuery = async (pool, settings) => {
+    const { schema, resolvedPreset, pgService } = await getSchema(pool, settings);
+    return new GraphileQuery({ schema, pool, settings, resolvedPreset, pgService });
+};
+/**
+ * Helper function to create a GraphileQuerySimple instance with schema creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuerySimple instance
+ */
+export const createGraphileQuerySimple = async (pool, settings) => {
+    const { schema, resolvedPreset, pgService } = await getSchema(pool, settings);
+    return new GraphileQuerySimple({ schema, pool, resolvedPreset, pgService });
+};

package/index.d.ts

@@ -1,36 +1,122 @@
-import { ExecutionResult, GraphQLSchema } from 'graphql';
-import { Pool } from 'pg';
-import { PostGraphileOptions } from 'postgraphile';
-interface GraphileSettings extends PostGraphileOptions {
+import type { ExecutionResult, GraphQLSchema, DocumentNode } from 'graphql';
+import type { GraphileConfig } from 'graphile-config';
+import { makePgService } from 'graphile-settings';
+import type { Pool } from 'pg';
+/**
+ * Settings for creating a GraphQL schema with PostGraphile v5.
+ */
+export interface GraphileSettings {
+    /** Database schema(s) to expose */
     schema: string | string[];
+    /** Optional preset to extend the minimal preset */
+    preset?: GraphileConfig.Preset;
+    /** Function to generate pgSettings from a request object */
+    pgSettings?: (req: unknown) => Record<string, string> | Promise<Record<string, string>>;
 }
-export declare const getSchema: (pool: Pool, settings: GraphileSettings) => Promise<GraphQLSchema>;
-interface GraphileQueryParams {
+/**
+ * Result from getSchema containing the schema and resolved preset.
+ */
+export interface SchemaResult {
+    schema: GraphQLSchema;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
+    pgService: ReturnType<typeof makePgService>;
+}
+/**
+ * Create a GraphQL schema using PostGraphile v5's preset-based API.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration including database schemas and optional preset
+ * @returns Promise resolving to schema, resolved preset, and pgService
+ */
+export declare const getSchema: (pool: Pool, settings: GraphileSettings) => Promise<SchemaResult>;
+/**
+ * Parameters for creating a GraphileQuery instance.
+ */
+export interface GraphileQueryParams {
     schema: GraphQLSchema;
     pool: Pool;
     settings: GraphileSettings;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
+    pgService: ReturnType<typeof makePgService>;
 }
-interface QueryOptions {
-    req?: any;
-    query: string;
-    variables?: Record<string, any>;
+/**
+ * Options for executing a GraphQL query.
+ */
+export interface QueryOptions {
+    /** Optional request object for pgSettings generation */
+    req?: unknown;
+    /** GraphQL query string or DocumentNode */
+    query: string | DocumentNode;
+    /** Query variables */
+    variables?: Record<string, unknown>;
+    /** PostgreSQL role to use for the query */
     role?: string;
 }
+/**
+ * GraphileQuery provides a way to execute GraphQL queries against a PostGraphile v5 schema.
+ *
+ * This is the full-featured version that supports pgSettings generation from requests.
+ */
 export declare class GraphileQuery {
     private pool;
     private schema;
     private settings;
-    constructor({ schema, pool, settings }: GraphileQueryParams);
+    private resolvedPreset;
+    private pgService;
+    constructor({ schema, pool, settings, resolvedPreset, pgService }: GraphileQueryParams);
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param options - Query options including query string, variables, and optional role
+     * @returns Promise resolving to the GraphQL execution result
+     */
     query({ req, query, variables, role }: QueryOptions): Promise<ExecutionResult>;
 }
-interface GraphileQuerySimpleParams {
+/**
+ * Parameters for creating a GraphileQuerySimple instance.
+ */
+export interface GraphileQuerySimpleParams {
     schema: GraphQLSchema;
     pool: Pool;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
+    pgService: ReturnType<typeof makePgService>;
 }
+/**
+ * GraphileQuerySimple provides a simplified way to execute GraphQL queries.
+ *
+ * This version doesn't support pgSettings generation from requests - it's meant
+ * for simple use cases where you just need to run queries.
+ */
 export declare class GraphileQuerySimple {
     private pool;
     private schema;
-    constructor({ schema, pool }: GraphileQuerySimpleParams);
-    query(query: string, variables?: Record<string, any>): Promise<ExecutionResult>;
+    private resolvedPreset;
+    private pgService;
+    constructor({ schema, pool, resolvedPreset, pgService }: GraphileQuerySimpleParams);
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param query - GraphQL query string or DocumentNode
+     * @param variables - Optional query variables
+     * @returns Promise resolving to the GraphQL execution result
+     */
+    query(query: string | DocumentNode, variables?: Record<string, unknown>): Promise<ExecutionResult>;
 }
-export {};
+/**
+ * Helper function to create a GraphileQuery instance with schema creation.
+ *
+ * This is a convenience function that combines getSchema and GraphileQuery creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuery instance
+ */
+export declare const createGraphileQuery: (pool: Pool, settings: GraphileSettings) => Promise<GraphileQuery>;
+/**
+ * Helper function to create a GraphileQuerySimple instance with schema creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuerySimple instance
+ */
+export declare const createGraphileQuerySimple: (pool: Pool, settings: GraphileSettings) => Promise<GraphileQuerySimple>;

package/index.js

@@ -1,70 +1,202 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphileQuerySimple = exports.GraphileQuery = exports.getSchema = void 0;
+exports.createGraphileQuerySimple = exports.createGraphileQuery = exports.GraphileQuerySimple = exports.GraphileQuery = exports.getSchema = void 0;
 const graphql_1 = require("graphql");
-const printer_1 = require("graphql/language/printer");
-const postgraphile_1 = require("postgraphile");
-const getSchema = async (pool, settings) => await (0, postgraphile_1.createPostGraphileSchema)(pool, settings.schema, settings);
+const graphile_build_1 = require("graphile-build");
+const graphile_build_2 = require("graphile-build");
+const graphile_build_pg_1 = require("graphile-build-pg");
+const graphile_settings_1 = require("graphile-settings");
+const grafast_1 = require("grafast");
+/**
+ * Minimal preset that provides core functionality without Node/Relay.
+ * This matches the pattern from graphile-settings.
+ */
+const MinimalPreset = {
+    extends: [graphile_build_2.defaultPreset, graphile_build_pg_1.defaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+/**
+ * Create a GraphQL schema using PostGraphile v5's preset-based API.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration including database schemas and optional preset
+ * @returns Promise resolving to schema, resolved preset, and pgService
+ */
+const getSchema = async (pool, settings) => {
+    const schemas = Array.isArray(settings.schema) ? settings.schema : [settings.schema];
+    // Create the pgService for database access
+    const pgService = (0, graphile_settings_1.makePgService)({
+        pool,
+        schemas,
+    });
+    // Build the complete preset
+    const completePreset = {
+        extends: [
+            MinimalPreset,
+            ...(settings.preset?.extends ?? []),
+        ],
+        ...(settings.preset?.disablePlugins && { disablePlugins: settings.preset.disablePlugins }),
+        ...(settings.preset?.plugins && { plugins: settings.preset.plugins }),
+        ...(settings.preset?.schema && { schema: settings.preset.schema }),
+        ...(settings.preset?.grafast && { grafast: settings.preset.grafast }),
+        pgServices: [pgService],
+    };
+    // Use makeSchema from graphile-build to create the schema
+    const result = await (0, graphile_build_1.makeSchema)(completePreset);
+    return {
+        schema: result.schema,
+        resolvedPreset: result.resolvedPreset,
+        pgService,
+    };
+};
 exports.getSchema = getSchema;
+/**
+ * GraphileQuery provides a way to execute GraphQL queries against a PostGraphile v5 schema.
+ *
+ * This is the full-featured version that supports pgSettings generation from requests.
+ */
 class GraphileQuery {
     pool;
     schema;
     settings;
-    constructor({ schema, pool, settings }) {
+    resolvedPreset;
+    pgService;
+    constructor({ schema, pool, settings, resolvedPreset, pgService }) {
         if (!schema)
             throw new Error('requires a schema');
         if (!pool)
             throw new Error('requires a pool');
         if (!settings)
             throw new Error('requires graphile settings');
+        if (!resolvedPreset)
+            throw new Error('requires resolvedPreset');
+        if (!pgService)
+            throw new Error('requires pgService');
         this.pool = pool;
         this.schema = schema;
         this.settings = settings;
+        this.resolvedPreset = resolvedPreset;
+        this.pgService = pgService;
     }
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param options - Query options including query string, variables, and optional role
+     * @returns Promise resolving to the GraphQL execution result
+     */
     async query({ req = {}, query, variables, role }) {
-        const queryString = typeof query === 'string' ? query : (0, printer_1.print)(query);
+        // Parse the query if it's a string
+        const document = typeof query === 'string' ? (0, graphql_1.parse)(query) : query;
+        // Generate pgSettings
         const { pgSettings: pgSettingsGenerator } = this.settings;
-        const pgSettings = role != null
-            ? { role }
-            : typeof pgSettingsGenerator === 'function'
-                ? await pgSettingsGenerator(req)
-                : pgSettingsGenerator;
-        return await (0, postgraphile_1.withPostGraphileContext)({
-            ...this.settings,
-            pgPool: this.pool,
-            pgSettings
-        }, async (context) => {
-            return await (0, graphql_1.graphql)({
-                schema: this.schema,
-                source: queryString,
-                contextValue: context,
-                variableValues: variables
-            });
+        let pgSettings = {};
+        if (role != null) {
+            pgSettings = { role };
+        }
+        else if (typeof pgSettingsGenerator === 'function') {
+            pgSettings = await pgSettingsGenerator(req);
+        }
+        // Build context with withPgClient using withPgClientFromPgService
+        const withPgClientKey = this.pgService.withPgClientKey ?? 'withPgClient';
+        const contextValue = {
+            pgSettings,
+            [withPgClientKey]: graphile_build_pg_1.withPgClientFromPgService.bind(null, this.pgService),
+        };
+        // Execute using grafast
+        const result = await (0, grafast_1.execute)({
+            schema: this.schema,
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset: this.resolvedPreset,
         });
+        // Handle streaming results
+        if (Symbol.asyncIterator in result) {
+            throw new Error('Streaming results (subscriptions) are not supported');
+        }
+        return result;
     }
 }
 exports.GraphileQuery = GraphileQuery;
+/**
+ * GraphileQuerySimple provides a simplified way to execute GraphQL queries.
+ *
+ * This version doesn't support pgSettings generation from requests - it's meant
+ * for simple use cases where you just need to run queries.
+ */
 class GraphileQuerySimple {
     pool;
     schema;
-    constructor({ schema, pool }) {
+    resolvedPreset;
+    pgService;
+    constructor({ schema, pool, resolvedPreset, pgService }) {
         if (!schema)
             throw new Error('requires a schema');
         if (!pool)
             throw new Error('requires a pool');
+        if (!resolvedPreset)
+            throw new Error('requires resolvedPreset');
+        if (!pgService)
+            throw new Error('requires pgService');
         this.pool = pool;
         this.schema = schema;
+        this.resolvedPreset = resolvedPreset;
+        this.pgService = pgService;
     }
+    /**
+     * Execute a GraphQL query.
+     *
+     * @param query - GraphQL query string or DocumentNode
+     * @param variables - Optional query variables
+     * @returns Promise resolving to the GraphQL execution result
+     */
     async query(query, variables) {
-        const queryString = typeof query === 'string' ? query : (0, printer_1.print)(query);
-        return await (0, postgraphile_1.withPostGraphileContext)({ pgPool: this.pool }, async (context) => {
-            return await (0, graphql_1.graphql)({
-                schema: this.schema,
-                source: queryString,
-                contextValue: context,
-                variableValues: variables
-            });
+        // Parse the query if it's a string
+        const document = typeof query === 'string' ? (0, graphql_1.parse)(query) : query;
+        // Build context with withPgClient using withPgClientFromPgService
+        const withPgClientKey = this.pgService.withPgClientKey ?? 'withPgClient';
+        const contextValue = {
+            [withPgClientKey]: graphile_build_pg_1.withPgClientFromPgService.bind(null, this.pgService),
+        };
+        // Execute using grafast
+        const result = await (0, grafast_1.execute)({
+            schema: this.schema,
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset: this.resolvedPreset,
         });
+        // Handle streaming results
+        if (Symbol.asyncIterator in result) {
+            throw new Error('Streaming results (subscriptions) are not supported');
+        }
+        return result;
     }
 }
 exports.GraphileQuerySimple = GraphileQuerySimple;
+/**
+ * Helper function to create a GraphileQuery instance with schema creation.
+ *
+ * This is a convenience function that combines getSchema and GraphileQuery creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuery instance
+ */
+const createGraphileQuery = async (pool, settings) => {
+    const { schema, resolvedPreset, pgService } = await (0, exports.getSchema)(pool, settings);
+    return new GraphileQuery({ schema, pool, settings, resolvedPreset, pgService });
+};
+exports.createGraphileQuery = createGraphileQuery;
+/**
+ * Helper function to create a GraphileQuerySimple instance with schema creation.
+ *
+ * @param pool - PostgreSQL connection pool
+ * @param settings - Schema configuration
+ * @returns Promise resolving to a GraphileQuerySimple instance
+ */
+const createGraphileQuerySimple = async (pool, settings) => {
+    const { schema, resolvedPreset, pgService } = await (0, exports.getSchema)(pool, settings);
+    return new GraphileQuerySimple({ schema, pool, resolvedPreset, pgService });
+};
+exports.createGraphileQuerySimple = createGraphileQuerySimple;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "graphile-query",
-  "version": "2.6.0",
+  "version": "4.0.1",
   "author": "Constructive <developers@constructive.io>",
-  "description": "graphile query",
+  "description": "Execute GraphQL queries against PostGraphile v5 schemas",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
@@ -29,21 +29,29 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "graphql": "15.10.1",
+    "grafast": "^1.0.0-rc.4",
+    "graphile-build": "^5.0.0-rc.3",
+    "graphile-build-pg": "^5.0.0-rc.3",
+    "graphile-config": "1.0.0-rc.3",
+    "graphile-settings": "^4.0.1",
+    "graphql": "^16.9.0",
     "pg": "^8.17.1",
-    "postgraphile": "^4.14.1"
+    "postgraphile": "^5.0.0-rc.4"
   },
   "devDependencies": {
     "@types/pg": "^8.16.0",
-    "makage": "^0.1.12"
+    "makage": "^0.1.10",
+    "pgsql-test": "^4.0.0"
   },
   "keywords": [
     "graphql",
     "query",
     "builder",
     "graphile",
+    "postgraphile",
+    "v5",
     "constructive",
     "pgpm"
   ],
-  "gitHead": "048188f6b43ffaa6146e7694b2b0d35d34cb2945"
+  "gitHead": "c05d6bd3dfa36690aefe21079042666dfae801a1"
 }