hasura-node-types/lib/types.d.ts

Add Hasura types, event trigger and action wrapper for common web frameworks

import { Logger } from "./utils";
export declare const AuthorizationHeader = "authorization";
export declare const XHasuraAdminSecret = "x-hasura-admin-secret";
export declare const XHasuraRole = "x-hasura-role";
export declare const XHasuraUserID = "x-hasura-user-id";
export declare const ContentType = "content-type";
export declare const ContentTypeJson = "application/json";
export declare const HASURA_ROLE_ADMIN = "admin";
export declare const HASURA_ACTION_SUCCESS_STATUS = 200;
export declare const HASURA_ACTION_ERROR_STATUS = 400;
export declare const HASURA_EVENT_SUCCESS_STATUS = 200;
export declare const HASURA_EVENT_ERROR_STATUS = 400;
export declare const HASURA_SCHEDULED_TRIGGER_SUCCESS_STATUS = 200;
export declare const HASURA_SCHEDULED_TRIGGER_ERROR_STATUS = 400;
export declare const VALIDATION_ERROR = "validation_error";
export declare type AnyRecord = Record<string, any>;
export declare type BaseSessionVariables<R extends string = string> = {
    readonly [XHasuraRole]: R;
    readonly [XHasuraUserID]?: string;
    readonly [key: string]: string;
};
export declare type SessionVariables<T = BaseSessionVariables> = T | null;
export declare const INSERT = "INSERT";
export declare const UPDATE = "UPDATE";
export declare const DELETE = "DELETE";
export declare const MANUAL = "MANUAL";
export declare type HasuraEventOpName = typeof INSERT | typeof UPDATE | typeof DELETE | typeof MANUAL;
export declare type IHasuraEvent<OP extends HasuraEventOpName, O = AnyRecord, N = AnyRecord, S = SessionVariables> = {
    readonly session_variables: S;
    readonly op: OP;
    readonly data: {
        readonly old: O;
        readonly new: N;
    };
    readonly trace_context: {
        trace_id: string;
        span_id: string;
    };
};
export declare type HasuraEventInsert<N extends AnyRecord = AnyRecord, S extends SessionVariables = SessionVariables> = IHasuraEvent<typeof INSERT, null, N, S>;
export declare type HasuraEventUpdate<N extends AnyRecord = AnyRecord, S extends SessionVariables = SessionVariables> = IHasuraEvent<typeof UPDATE, N, N, S>;
export declare type HasuraEventDelete<N extends AnyRecord = AnyRecord, S extends SessionVariables = SessionVariables> = IHasuraEvent<typeof DELETE, N, null, S>;
export declare type HasuraEventManual<N extends AnyRecord = AnyRecord, S extends SessionVariables = SessionVariables> = IHasuraEvent<typeof MANUAL, null, N, S>;
export declare type HasuraEventInfo<N = string> = {
    readonly name: N;
};
export declare type HasuraEvent<N extends AnyRecord = AnyRecord, S extends SessionVariables = SessionVariables> = HasuraEventInsert<N, S> | HasuraEventUpdate<N, S> | HasuraEventDelete<N, S> | HasuraEventManual<N, S>;
export declare type HasuraEventTriggerTable = {
    readonly schema: string;
    readonly name: string;
};
export declare type HasuraEventPayload<E extends IHasuraEvent<HasuraEventOpName> = HasuraEvent, N = string> = {
    readonly event: E;
    readonly created_at: string;
    readonly id: string;
    readonly trigger: HasuraEventInfo<N>;
    readonly table: HasuraEventTriggerTable;
    readonly delivery_info: {
        max_retries: number;
        current_retry: number;
    };
};
export declare type HasuraEventHandler<EV extends HasuraEvent = HasuraEvent, R extends AnyRecord = AnyRecord, N extends string = string, Ctx extends BaseHasuraContext = BaseHasuraContext> = (ctx: Ctx, payload: HasuraEventPayload<EV, N>) => Promise<R>;
export declare type HasuraEventHandlerMap<H extends HasuraEventHandler = HasuraEventHandler> = Record<string, H>;
export declare type HasuraActionPayload<T = AnyRecord, A = string, S = SessionVariables> = {
    readonly action: {
        readonly name: A;
    };
    readonly session_variables: S;
    readonly input: T;
    readonly request_query: string;
};
export declare type HasuraActionErrorResponse = {
    readonly code?: string;
    readonly message: string;
    readonly extensions?: {
        readonly code?: string;
        readonly [key: string]: string;
    };
};
export declare class HasuraActionError extends Error implements HasuraActionErrorResponse {
    readonly message: string;
    readonly extensions?: {
        readonly code?: string;
        readonly [key: string]: string;
    };
    readonly details?: any;
    constructor({ code, message, extensions, details, }: HasuraActionErrorResponse & {
        readonly details?: any;
    });
}
export declare type BaseHasuraContext<L extends Logger = Logger> = {
    readonly logger: L;
    readonly debug: boolean;
};
export declare type HasuraActionHandler<P extends HasuraActionPayload = HasuraActionPayload, R extends AnyRecord = AnyRecord, Ctx extends BaseHasuraContext = BaseHasuraContext> = (ctx: Ctx, payload: P) => Promise<R>;
export declare type HasuraActionHandlerMap<H extends HasuraActionHandler = HasuraActionHandler> = {
    readonly [key: string]: H;
};
export declare type HasuraScheduledTriggerPayload<P = Record<string, any>> = {
    readonly id: string;
    readonly name: string;
    readonly payload: P;
    readonly scheduled_time: string;
};
export declare type HasuraScheduledTriggerHandler<P extends AnyRecord = AnyRecord, R = unknown, Ctx extends BaseHasuraContext = BaseHasuraContext> = (ctx: Ctx, payload: HasuraScheduledTriggerPayload<P>) => Promise<R>;
export declare type HasuraScheduledTriggerHandlerMap<H extends HasuraScheduledTriggerHandler = HasuraScheduledTriggerHandler> = Record<string, H>;
export declare type WithHasura<H, Ctx extends BaseHasuraContext> = {
    readonly useActions: (handlers: HasuraActionHandlerMap<HasuraActionHandler<HasuraActionPayload, AnyRecord, Ctx>>) => H;
    readonly useAction: <P extends HasuraActionPayload = HasuraActionPayload, R extends AnyRecord = AnyRecord>(handler: HasuraActionHandler<P, R, Ctx>) => H;
    readonly useEvents: (handlers: HasuraEventHandlerMap<HasuraEventHandler<HasuraEvent, AnyRecord, string, Ctx>>) => H;
    readonly useEvent: <EV extends HasuraEvent = HasuraEvent, R extends AnyRecord = AnyRecord, N extends string = string>(handler: HasuraEventHandler<EV, R, N>) => H;
    readonly useScheduledTriggers: (handlers: HasuraScheduledTriggerHandlerMap<HasuraScheduledTriggerHandler<HasuraScheduledTriggerPayload, unknown, Ctx>>) => H;
    readonly useScheduledTrigger: <P extends HasuraScheduledTriggerPayload = HasuraScheduledTriggerPayload, R = unknown>(handler: HasuraScheduledTriggerHandler<P, R, Ctx>) => H;
};
export declare type WithHasuraOptions<Ctx extends AnyRecord = AnyRecord, L extends Logger = Logger> = {
    readonly logger?: L;
    readonly debug?: boolean;
    readonly logRequestBody?: boolean;
    readonly logResponseData?: boolean;
    readonly context?: Ctx;
};