postgraphile

statusCode: number;

end: (moreBody?: Buffer | string | null) => void;

endWithStream: () => PassThrough;

abstract getNodeServerRequest: () => IncomingMessage;

abstract getNodeServerResponse: () => ServerResponse;

abstract setBody: (body: Stream | Buffer | string | undefined) => void;

setHeader: (header: string, value: string) => void;

abstract setHeaders: (statusCode: number, headers: Headers) => void;

constructor(request: CompatFastifyRequest, reply: CompatFastifyReply);

endWithStream: () => PassThrough;

getNodeServerRequest: () => IncomingMessage;

getNodeServerResponse: () => ServerResponse;

setBody: (body: Stream | Buffer | string | undefined) => void;

setHeaders: (statusCode: number, headers: Headers) => void;

constructor(ctx: CompatKoaContext, next: CompatKoaNext);

endWithStream: () => PassThrough;

getNextCallback: () => CompatKoaNext;

getNodeServerRequest: () => IncomingMessage;

getNodeServerResponse: () => ServerResponse;

setBody: (body: Stream | Buffer | string | undefined) => void;

setHeaders: (statusCode: number, headers: Headers) => void;

constructor(
    req: IncomingMessage,
    res: ServerResponse,
    next: (e?: 'route' | Error) => void
);

getNextCallback: () => (e?: Error | 'route' | undefined) => void;

getNodeServerRequest: () => IncomingMessage;

getNodeServerResponse: () => ServerResponse;

setBody: (body: Stream | Buffer | string | undefined) => void;

setHeaders: (statusCode: number, headers: Headers) => void;

getGqlSchema: () => Promise<GraphQLSchema>;

pgPool: Pool;

shutdownActions: ShutdownActions;

extensions?: {
    [s: string]: any;
};

locations: ReadonlyArray<SourceLocation> | void;

message: string;

path: ReadonlyArray<string | number> | void;

eventStreamRoute: string;

eventStreamRouteHandler: ((res: PostGraphileResponse) => Promise<void>) | null;

faviconRouteHandler: ((res: PostGraphileResponse) => Promise<void>) | null;

formatError: (e: GraphQLError) => GraphQLFormattedErrorExtended;

getGraphQLSchema: () => Promise<GraphQLSchema>;

graphiqlRoute: string;

graphiqlRouteHandler: ((res: PostGraphileResponse) => Promise<void>) | null;

graphqlRoute: string;

graphqlRouteHandler: (res: PostGraphileResponse) => Promise<void>;

handleErrors: (
    errors: ReadonlyArray<GraphQLError>,
    req: Request,
    res: Response
) => ReadonlyArray<GraphQLError | GraphQLErrorExtended>;

options: CreateRequestHandlerOptions;

pgPool: Pool;

release: () => Promise<void>;

withPostGraphileContextFromReqRes: (
    req: Request,
    res: Response,
    moreOptions: any,
    fn: (ctx: mixed) => any
) => Promise<any>;

(req: Request, res: Response, next?: (error?: mixed) => void): Promise<void>;

(
    ctx: {
        req: Request;
        res: Response;
    },
    next: () => void
): Promise<void>;

additionalGraphQLContextFromRequest?: (
    req: Request,
    res: Response
) => Promise<Record<string, any>>;

allowExplain?: DirectOrCallback<Request, boolean>;

appendPlugins?: Array<Plugin>;

bodySizeLimit?: string;

classicIds?: boolean;

disableDefaultMutations?: boolean;

disableQueryLog?: boolean;

dynamicJson?: boolean;

enableCors?: boolean;

enableQueryBatching?: boolean;

enhanceGraphiql?: boolean;

eventStreamRoute?: string;

exportGqlSchemaPath?: string;

exportJsonSchemaPath?: string;

extendedErrors?: Array<string>;

externalEventStreamRoute?: string;

externalGraphqlRoute?: string;

externalUrlBase?: string;

graphiql?: boolean;

graphiqlCredentials?: 'include' | 'omit' | 'same-origin';

graphiqlRoute?: string;

graphqlRoute?: string;

handleErrors?: (
    errors: ReadonlyArray<GraphQLError>,
    req: Request,
    res: Response
) => ReadonlyArray<GraphQLError | GraphQLErrorExtended>;

ignoreIndexes?: boolean;

ignoreRBAC?: boolean;

includeExtensionResources?: boolean;

jwtAudiences?: Array<string>;

jwtPgTypeIdentifier?: string;

jwtPublicKey?: jwt.Secret | jwt.GetPublicKeyOrSecret;

jwtRole?: Array<string>;

jwtSecret?: Exclude<jwt.Secret, KeyObject>;

jwtSignOptions?: jwt.SignOptions;

jwtVerifyOptions?: jwt.VerifyOptions;

legacyJsonUuid?: boolean;

legacyRelations?: 'only' | 'deprecated' | 'omit';

live?: boolean;

ownerConnectionString?: string;

pgDefaultRole?: string;

pgSettings?: DirectOrCallback<
    Request,
    {
        [key: string]: mixed;
    }
>;

pluginHook?: PluginHookFn;

prependPlugins?: Array<Plugin>;

queryCacheMaxSize?: number;

readCache?: string | Record<string, any>;

replaceAllPlugins?: Array<Plugin>;

retryOnInitFail?:
    | boolean
    | ((error: Error, attempts: number) => boolean | Promise<boolean>);

setofFunctionsContainNulls?: boolean;

showErrorStack?: boolean | 'json';

simpleCollections?: 'omit' | 'both' | 'only';

skipPlugins?: Array<Plugin>;

sortExport?: boolean;

subscriptions?: boolean;

watchPg?: boolean;

websocketMiddlewares?: Array<Middleware<Request, Response>>;

websocketOperations?: 'all' | 'subscriptions';

websockets?: ('v0' | 'v1')[];

writeCache?: string;

'cli:flags:add:deprecated'?: HookFn<AddFlagFn>;

'cli:flags:add:errorHandling'?: HookFn<AddFlagFn>;

'cli:flags:add:jwt'?: HookFn<AddFlagFn>;

'cli:flags:add:noServer'?: HookFn<AddFlagFn>;

'cli:flags:add:plugins'?: HookFn<AddFlagFn>;

'cli:flags:add:schema'?: HookFn<AddFlagFn>;

'cli:flags:add:standard'?: HookFn<AddFlagFn>;

'cli:flags:add:webserver'?: HookFn<AddFlagFn>;

'cli:flags:add:workarounds'?: HookFn<AddFlagFn>;

'cli:flags:add'?: HookFn<AddFlagFn>;

'cli:greeting'?: HookFn<Array<string | null | void>>;

'cli:library:options'?: HookFn<
    PostGraphileOptions,
    {
        config: any;
        cliOptions: any;
    }
>;

'cli:server:created'?: HookFn<Server>;

'cli:server:middleware'?: HookFn<HttpRequestHandler>;

'postgraphile:graphiql:html'?: HookFn<string>;

'postgraphile:http:end'?: HookFn<PostGraphileHTTPEnd>;

'postgraphile:http:eventStreamRouteHandler'?: HookFn<
    IncomingMessage,
    {
        options: CreateRequestHandlerOptions;
        response: PostGraphileResponse;
    }
>;

'postgraphile:http:faviconRouteHandler'?: HookFn<
    IncomingMessage,
    {
        options: CreateRequestHandlerOptions;
        response: PostGraphileResponse;
    }
>;

'postgraphile:http:graphiqlRouteHandler'?: HookFn<
    IncomingMessage,
    {
        options: CreateRequestHandlerOptions;
        response: PostGraphileResponse;
    }
>;

'postgraphile:http:graphqlRouteHandler'?: HookFn<
    IncomingMessage,
    {
        options: CreateRequestHandlerOptions;
        response: PostGraphileResponse;
    }
>;

'postgraphile:http:handler'?: HookFn<IncomingMessage>;

'postgraphile:http:result'?: HookFn<PostGraphileHTTPResult>;

'postgraphile:httpParamsList'?: HookFn<Array<Record<string, any>>>;

'postgraphile:liveSubscribe:executionResult'?: HookFn<
    PromiseOrValue<
        graphql.ExecutionResult<
            {
                [key: string]: any;
            },
            {
                [key: string]: any;
            }
        >
    >,
    {
        schema: graphql.GraphQLSchema;
        document: graphql.DocumentNode;
        rootValue: any;
        contextValue: any;
        variableValues:
            | {
                  [key: string]: any;
              }
            | undefined;
        operationName: string | undefined;
        fieldResolver:
            | graphql.GraphQLFieldResolver<
                  any,
                  any,
                  {
                      [argName: string]: any;
                  }
              >
            | undefined;
        subscribeFieldResolver:
            | graphql.GraphQLFieldResolver<
                  any,
                  any,
                  {
                      [argName: string]: any;
                  }
              >
            | undefined;
    }
>;

'postgraphile:middleware'?: HookFn<HttpRequestHandler>;

'postgraphile:options'?: HookFn<PostGraphileOptions>;

'postgraphile:validationRules:static'?: HookFn<typeof graphql.specifiedRules>;

'postgraphile:validationRules'?: HookFn<typeof graphql.specifiedRules>;

'postgraphile:ws:onOperation'?: HookFn<ExecutionParams>;

'postgraphile:ws:onSubscribe'?: HookFn<
    graphql.ExecutionArgs & {
        document: graphql.DocumentNode | null;
    },
    {
        context: graphqlWs.Context<any, GraphQLWSContextExtra>;
        message: graphqlWs.SubscribeMessage;
        options: CreateRequestHandlerOptions;
    }
>;

init?: HookFn<
    null,
    {
        version: string;
        graphql: typeof import('graphql');
    }
>;

pluginHook?: HookFn<PluginHookFn>;

withPostGraphileContext?: HookFn<WithPostGraphileContextFn>;

explain?: boolean;

jwtAudiences?: Array<string>;

jwtPublicKey?: jwt.Secret | jwt.GetPublicKeyOrSecret;

jwtRole?: Array<string>;

jwtSecret?: Exclude<jwt.Secret, KeyObject>;

jwtToken?: string;

jwtVerifyOptions?: jwt.VerifyOptions;

operationName?: string;

pgDefaultRole?: string;

pgForceTransaction?: boolean;

pgPool: Pool;

pgSettings?: {
    [key: string]: mixed;
};

queryDocumentAst?: DocumentNode;

singleStatement?: boolean;

variables?: any;