@graphoria/server 0.1.0

package/dist/src/configuration/getSchemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configuration/getSchemas/index.ts"],"names":[],"mappings":"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"}

package/dist/src/configuration/getSchemas/mergeEntities/index.d.ts

@@ -0,0 +1,412 @@
+import type { EntitiesOfRole } from "../../../databases/high-level-operations";
+import type { RemoteSchemaResolved } from "../../../remoteSchemas/types";
+import type { VirtualColumn } from "../../../types/configuration";
+import type { TableResolver } from "../../../types/db";
+import type { ResolverRegistry } from "../../../types/resolver";
+import { EntitySource } from "../../../types/resolver";
+export declare const mergeEntities: (entityOfRole: EntitiesOfRole, hasAuth?: boolean, includeAI?: boolean) => {
+    entityOfRole: EntitiesOfRole;
+    ai: boolean;
+    queriesMap: Record<string, TableResolver>;
+    mutationsMap: Record<string, {
+        db: {
+            name: string;
+            enabled: boolean;
+            type: "mssql" | "mysql" | "pg";
+            connection: {
+                host: string;
+                port: number;
+                user: string;
+                password: string;
+                database: string;
+            };
+            fieldNaming: string;
+            repository?: import("../../../config").CustomRepositoryFactory<import("../../../config").DatabaseType> | undefined;
+            onConnect?: import("../../../config").OnConnectHandler<import("../../../config").DatabaseType> | undefined;
+            schema?: {
+                database: Record<string, {
+                    columns: {
+                        name: string;
+                        dataType: string;
+                        isNullable: boolean;
+                        description: string | null;
+                        virtual?: boolean | undefined;
+                        function?: string | undefined;
+                        params?: string[] | undefined;
+                        expression?: string | undefined;
+                    }[];
+                    relationships: {
+                        schema: string;
+                        name: string;
+                        columns: {
+                            source: string;
+                            target: string;
+                        }[];
+                    }[];
+                    columnDescriptions: Record<string, string>;
+                    description?: string | undefined;
+                }>;
+                excludedTables: string[];
+            } | undefined;
+            connectionOptions?: {
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+                maxLifetime: number;
+                tls: boolean;
+                prepare: boolean;
+                bigint: boolean;
+            } | {
+                pool: {
+                    max: number;
+                    min: number;
+                    idleTimeout: number;
+                };
+                connectionTimeout: number;
+                requestTimeout: number;
+                encrypt: boolean;
+                trustServerCertificate: boolean;
+                trustedConnection: boolean;
+                parseJSON: boolean;
+            } | undefined;
+        };
+        internalName: string;
+        resolverName: string;
+        dottedName: string;
+        dashedName: string;
+        dashedNameLS: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        parameters: {
+            name: string;
+            dataType: string | null;
+            maxLength: number;
+            precision: number;
+            scale: number;
+        }[];
+        signature?: string | undefined;
+        type?: string | undefined;
+    }>;
+    queuesMap: Record<string, {
+        name: string;
+        resolverName: string;
+        routingKey: string;
+        options?: {
+            persistent?: boolean;
+            headers?: Record<string, string>;
+        };
+    }>;
+    remoteQueriesMap: Record<string, {
+        remoteSchema: RemoteSchemaResolved;
+        originalFieldName: string;
+    }>;
+    remoteMutationsMap: Record<string, {
+        remoteSchema: RemoteSchemaResolved;
+        originalFieldName: string;
+    }>;
+    remoteSchemas: RemoteSchemaResolved[];
+    remoteRESTApis: import("../../../remoteREST").RemoteRESTResolved[];
+    tables: TableResolver[];
+    storedProcedures: {
+        db: {
+            name: string;
+            enabled: boolean;
+            type: "mssql" | "mysql" | "pg";
+            connection: {
+                host: string;
+                port: number;
+                user: string;
+                password: string;
+                database: string;
+            };
+            fieldNaming: string;
+            repository?: import("../../../config").CustomRepositoryFactory<import("../../../config").DatabaseType> | undefined;
+            onConnect?: import("../../../config").OnConnectHandler<import("../../../config").DatabaseType> | undefined;
+            schema?: {
+                database: Record<string, {
+                    columns: {
+                        name: string;
+                        dataType: string;
+                        isNullable: boolean;
+                        description: string | null;
+                        virtual?: boolean | undefined;
+                        function?: string | undefined;
+                        params?: string[] | undefined;
+                        expression?: string | undefined;
+                    }[];
+                    relationships: {
+                        schema: string;
+                        name: string;
+                        columns: {
+                            source: string;
+                            target: string;
+                        }[];
+                    }[];
+                    columnDescriptions: Record<string, string>;
+                    description?: string | undefined;
+                }>;
+                excludedTables: string[];
+            } | undefined;
+            connectionOptions?: {
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+                maxLifetime: number;
+                tls: boolean;
+                prepare: boolean;
+                bigint: boolean;
+            } | {
+                pool: {
+                    max: number;
+                    min: number;
+                    idleTimeout: number;
+                };
+                connectionTimeout: number;
+                requestTimeout: number;
+                encrypt: boolean;
+                trustServerCertificate: boolean;
+                trustedConnection: boolean;
+                parseJSON: boolean;
+            } | undefined;
+        };
+        internalName: string;
+        resolverName: string;
+        dottedName: string;
+        dashedName: string;
+        dashedNameLS: string;
+        dottedQuotedName: string;
+        schemaName: string;
+        schema: string;
+        name: string;
+        parameters: {
+            name: string;
+            dataType: string | null;
+            maxLength: number;
+            precision: number;
+            scale: number;
+        }[];
+        signature?: string | undefined;
+        type?: string | undefined;
+    }[];
+    queues: (({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("../../../config").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "rabbitmq";
+        connection: string | {
+            hostname: string;
+            port: number;
+            vhost: string;
+            username?: string | undefined;
+            password?: string | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("../../../config").SubscriberHandler;
+        }>;
+    }) | ({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("../../../config").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "kafka";
+        connection: string | {
+            brokers: string | string[];
+            ssl: boolean;
+            clientId?: string | undefined;
+            sasl?: {
+                mechanism: "plain" | "scram-sha-256" | "scram-sha-512";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("../../../config").SubscriberHandler;
+        }>;
+    }))[];
+    operations: Record<string, {
+        graphql: {
+            enabled: boolean;
+            name?: string | undefined;
+        };
+        description?: string | undefined;
+        query?: string | undefined;
+        handler?: import("../../../config").OperationHandler<any, any, any> | undefined;
+        input?: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>> | undefined;
+        output?: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>> | undefined;
+        hooks?: {
+            init?: import("../../../config").OperationInitHook<any> | undefined;
+            beforeRequest?: import("../../../config").OperationBeforeRequestHook<any, any, any> | undefined;
+            afterRequest?: import("../../../config").OperationAfterRequestHook<any> | undefined;
+        } | undefined;
+        rest?: {
+            path: string;
+            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+            pathParams?: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> | undefined;
+            queryParams?: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> | undefined;
+            body?: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> | undefined;
+        } | undefined;
+        cache?: {
+            updateAgeOnHas: boolean;
+            ttlAutopurge: boolean;
+            max?: number | undefined;
+            maxSize?: number | undefined;
+            ttl?: number | undefined;
+            allowStale?: boolean | undefined;
+            updateAgeOnGet?: boolean | undefined;
+        } | undefined;
+    }>;
+    resolverRegistry: ResolverRegistry;
+    /**
+     * Get the source type for a resolver name
+     * Returns undefined if not found in registry
+     */
+    getResolverSource: (resolverName: string) => EntitySource | undefined;
+    /**
+     * Get the full resolver entry for a resolver name
+     */
+    getResolverEntry: (resolverName: string) => import("../../../types/resolver").ResolverEntry;
+    getForeignKeysBetweenTables: (table1: string, table2: string) => {
+        relationships: {
+            internalName: string;
+            fromInternalName: string;
+            toInternalName: string;
+            fromResolverName: string;
+            toResolverName: string;
+            schema: string;
+            name: string;
+            columns: {
+                source: string;
+                target: string;
+            }[];
+        }[];
+        relationshipsReversed: {
+            internalName: string;
+            fromInternalName: string;
+            toInternalName: string;
+            fromResolverName: string;
+            toResolverName: string;
+            schema: string;
+            name: string;
+            columns: {
+                source: string;
+                target: string;
+            }[];
+        }[];
+    };
+    isVirtualColumn: (table: string, column: string) => VirtualColumn | undefined;
+    getColumnTypeForOpenApi: (table: string, column: string) => string;
+};
+export type MergedEntities = ReturnType<typeof mergeEntities>;
+export { EntitySource } from "../../../types/resolver";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/configuration/getSchemas/mergeEntities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/configuration/getSchemas/mergeEntities/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EAAqB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,EAAE,YAAY,EAAuB,MAAM,yBAAyB,CAAC;AAmB5E,eAAO,MAAM,aAAa,GACxB,cAAc,cAAc,EAC5B,UAAS,OAAe,EACxB,YAAW,OAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAyBY,CAAC;mBAAkB,CAAC;;;;sBAoDxC,oBAAoB;2BAAqB,MAAM;;;sBAI/C,oBAAoB;2BAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5D3D,CAAF;uBAGE,CADH;0BAAqB,CAAC;;;;;;uBAED,CAAA;8BAAc,CAAC;2BAAkB,CAAC;;;;;;iBAErC,CAAC;mBAAqB,CAAC;;;;;wBAK7B,CAAC;uBAAW,CAAC;0BACrB,CAAC;;mBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAZ3B,CAAF;uBAGE,CADH;0BAAqB,CAAC;;;;;;uBAED,CAAA;8BAAc,CAAC;2BAAkB,CAAC;;;;;;iBAErC,CAAC;mBAAqB,CAAC;;;;;wBAK7B,CAAC;uBAAW,CAAC;0BACrB,CAAC;;mBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoH/B;;;OAGG;sCAC+B,MAAM,KAAG,YAAY,GAAG,SAAS;IAGnE;;OAEG;qCAC8B,MAAM;0CAGD,MAAM,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUnC,MAAM,UAAU,MAAM,KAAG,aAAa,GAAG,SAAS;qCAM1C,MAAM,UAAU,MAAM;CAU1D,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/src/configuration/getSchemas/type-definition-generator/index.d.ts

@@ -0,0 +1,16 @@
+import type { OpenAPIV3_1 } from "openapi-types";
+import { type MergedEntities } from "../mergeEntities";
+export declare const mapJSONSchemaToGraphQLType: (schema: OpenAPIV3_1.SchemaObject) => string;
+export declare const mapSQLTypeToGraphQLType: (sqlType: string | null) => string;
+export declare const mapSQLTypeToConditionType: (sqlType: string) => string;
+export declare const lj: <T>(keys: T[], cb?: (value: T) => string) => string;
+export declare const generateTableType: (mergedEntities: MergedEntities) => string;
+export declare const generateWhereInputType: (mergedEntities: MergedEntities) => string;
+export declare const generateOrderByInputType: (mergedEntities: MergedEntities) => string;
+export declare const generateAggregationTypes: (mergedEntities: MergedEntities) => string;
+export declare const generateAuthTypes: (hasRoles?: boolean) => "" | "\n  type AuthUser {\n    id: Int\n    username: String\n    role: String\n  }\n  type AuthToken {\n    access_token: String\n    expires_in: Int\n    role: String\n  }\n  ";
+export declare const generateQueryType: (mergedEntities: MergedEntities, hasRoles?: boolean) => string;
+export declare const generateSubscriptionType: (mergedEntities: MergedEntities) => string;
+export declare const generateMutationType: (mergedEntities: MergedEntities, hasRoles?: boolean) => string;
+export declare const generateTypeDefs: (mergedEntities: MergedEntities, hasAuth?: boolean) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/configuration/getSchemas/type-definition-generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/configuration/getSchemas/type-definition-generator/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,eAAO,MAAM,0BAA0B,GAAI,QAAQ,WAAW,CAAC,YAAY,KAAG,MAsB7E,CAAC;AAGF,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,GAAG,IAAI,KAAG,MAiBhE,CAAC;AAGF,eAAO,MAAM,yBAAyB,GAAI,SAAS,MAAM,KAAG,MAe3D,CAAC;AAGF,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,WASzD,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,cAAc,WAwB7D,CAAC;AAEJ,eAAO,MAAM,sBAAsB,GAAI,gBAAgB,cAAc,WAqBlE,CAAC;AAGJ,eAAO,MAAM,wBAAwB,GAAI,gBAAgB,cAAc,WAQpE,CAAC;AAKJ,eAAO,MAAM,wBAAwB,GAAI,gBAAgB,cAAc,WAsCtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,WAAU,OAAe,uLAcnD,CAAC;AAET,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,cAAc,EAAE,WAAU,OAAe,WA8B1F,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,gBAAgB,cAAc,WAyBtE,CAAC;AAgDF,eAAO,MAAM,oBAAoB,GAAI,gBAAgB,cAAc,EAAE,WAAU,OAAe,WA0G7F,CAAC;AAiFF,eAAO,MAAM,gBAAgB,GAAI,gBAAgB,cAAc,EAAE,UAAS,OAAe,WAc3E,CAAC"}

package/dist/src/configuration/getSchemas/type-definition-generator/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/configuration/getSchemas/type-definition-generator/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../src/configuration/getSchemas/type-definition-generator/index.test.ts"],"names":[],"mappings":""}

package/dist/src/configuration/gql/buildExecute.d.ts

@@ -0,0 +1,31 @@
+import type { SessionContext } from "../../utils/sessionVariables";
+import type { HandleGraphQLRequest } from "./handleGraphQLRequestFactory";
+export type ExecuteOptions = {
+    role?: string;
+    session?: SessionContext;
+};
+type RolesWithGqlHandler = Record<string, {
+    handlers: {
+        gql: HandleGraphQLRequest;
+    };
+}>;
+/**
+ * Wrap the per-role GraphQL handlers in a single `execute(query, variables, opts)`
+ * function — the same orchestration the `/graphql` POST route performs (introspection
+ * / no-data short-circuits, validation, dispatch) minus the HTTP layer. Lets callers
+ * run a query in-process without standing up a server.
+ *
+ * @param roles - The analyzed-configuration role map (`analyzedConfiguration.roles`).
+ * @param defaultRole - Role used when `opts.role` is omitted (the server passes its
+ *   superadmin role, so in-process execution runs with full privileges).
+ */
+export declare const buildExecute: (roles: RolesWithGqlHandler, defaultRole: string) => (query: string, variables?: Record<string, unknown>, opts?: ExecuteOptions) => Promise<{
+    data: any;
+} | {
+    errors: {
+        message: string;
+        locations: readonly import("graphql").SourceLocation[] | undefined;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=buildExecute.d.ts.map

package/dist/src/configuration/gql/buildExecute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildExecute.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/buildExecute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B,CAAC;AAEF,KAAK,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE;QAAE,GAAG,EAAE,oBAAoB,CAAA;KAAE,CAAA;CAAE,CAAC,CAAC;AAEvF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,mBAAmB,EAAE,aAAa,MAAM,MAExE,OAAO,MAAM,EACb,YAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACvC,OAAM,cAAmB;;;;;;;EA6B5B,CAAC"}

package/dist/src/configuration/gql/buildExecute.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buildExecute.test.d.ts.map

package/dist/src/configuration/gql/buildExecute.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildExecute.test.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/buildExecute.test.ts"],"names":[],"mappings":""}

package/dist/src/configuration/gql/gqlAuthOperations.d.ts

@@ -0,0 +1,9 @@
+import type { BunRequest } from "bun";
+import type { SelectionAnalysis } from "../../analyzeQuery/types";
+import type { Auth } from "../../types/configuration";
+import type { SessionContext } from "../../utils/sessionVariables";
+export declare const handleAuthMutation: (field: SelectionAnalysis, variables: Record<string, unknown>, auth: Auth | null, req?: BunRequest, session?: SessionContext) => Promise<{
+    data: object;
+}>;
+export declare const handleAuthMeQuery: (field: SelectionAnalysis, session?: SessionContext) => Record<string, unknown>;
+//# sourceMappingURL=gqlAuthOperations.d.ts.map

package/dist/src/configuration/gql/gqlAuthOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gqlAuthOperations.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/gqlAuthOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAOnE,eAAO,MAAM,kBAAkB,GAC7B,OAAO,iBAAiB,EACxB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,MAAM,IAAI,GAAG,IAAI,EACjB,MAAM,UAAU,EAChB,UAAU,cAAc,KACvB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAuH1B,CAAC;AAGF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,iBAAiB,EACxB,UAAU,cAAc,KACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAQxB,CAAC"}

package/dist/src/configuration/gql/gqlAuthOperations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gqlAuthOperations.test.d.ts.map

package/dist/src/configuration/gql/gqlAuthOperations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gqlAuthOperations.test.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/gqlAuthOperations.test.ts"],"names":[],"mappings":""}

package/dist/src/configuration/gql/handleGraphQLRequestFactory.d.ts

@@ -0,0 +1,28 @@
+import type { BunRequest } from "bun";
+import type { GraphQLError } from "graphql";
+import type { AnalysisResult } from "../../analyzeQuery/types";
+import type { GetGQLEntitiesReturn } from "../../configuration/getSchemas";
+import type { MergedEntities } from "../../configuration/getSchemas/mergeEntities";
+import type { Auth } from "../../types/configuration";
+import type { SessionContext } from "../../utils/sessionVariables";
+export declare const handleGraphQLRequestFactory: (entities: MergedEntities, gqlEntities: GetGQLEntitiesReturn, auth?: Auth | null) => {
+    isIntrospectionQuery: (query: string) => boolean;
+    isNoDataQuery: (query: string) => boolean;
+    introspectionResult: {
+        data: import("graphql").IntrospectionQuery;
+    };
+    noDataResult: {
+        data: {
+            _no_data: string;
+        };
+    };
+    hasErrors: (query: string) => {
+        hasErrors: boolean;
+        validationErrors: readonly GraphQLError[];
+    };
+    handler: (query: string | AnalysisResult, variables?: Record<string, unknown>, req?: BunRequest, session?: SessionContext) => Promise<{
+        data: any;
+    }>;
+};
+export type HandleGraphQLRequest = ReturnType<typeof handleGraphQLRequestFactory>;
+//# sourceMappingURL=handleGraphQLRequestFactory.d.ts.map

package/dist/src/configuration/gql/handleGraphQLRequestFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGraphQLRequestFactory.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/handleGraphQLRequestFactory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,0BAA0B,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAiBnE,eAAO,MAAM,2BAA2B,GACtC,UAAU,cAAc,EACxB,aAAa,oBAAoB,EACjC,OAAM,IAAI,GAAG,IAAW;kCAuKQ,MAAM;2BAKb,MAAM;;;;;;;;;uBAOV,MAAM;;;;qBAuBhB,MAAM,GAAG,cAAc,cACnB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAC5B,UAAU,YACN,cAAc,KAEvB,OAAO,CAAC;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC;CA+K5B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/src/configuration/gql/handleGraphQLRequestFactory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=handleGraphQLRequestFactory.test.d.ts.map

package/dist/src/configuration/gql/handleGraphQLRequestFactory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGraphQLRequestFactory.test.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/handleGraphQLRequestFactory.test.ts"],"names":[],"mappings":""}

package/dist/src/configuration/gql/handleGraphQLSubscriptionFactory.d.ts

@@ -0,0 +1,19 @@
+import type { ServerWebSocket, WebSocketHandler } from "bun";
+import type { AnalyzedConfiguration } from "../../configuration";
+export declare const queryEventEmitter: {
+    addConnection: (queryName: string, id: string, ws: ServerWebSocket<unknown>, poll?: import("../../subscriptions").DatabasePoller) => void;
+    removeConnection: (ws: ServerWebSocket<unknown>) => void;
+    sendDataByQueryNameToSingleClient: (queryName: string, ws: ServerWebSocket<unknown>, id: string) => void;
+    sendDataUpdate: (queryName: string, data: object) => void;
+    hasConnection: (queryName: string) => boolean;
+    getConnectionCount: (queryName: string) => number;
+    setData: (queryName: string, data: object) => void;
+    setPoll: (queryName: string, poll: import("../../subscriptions").DatabasePoller) => void;
+    setResponseKey: (queryName: string, key: string) => void;
+    setDataTransform: (queryName: string, transform: (data: unknown) => unknown) => void;
+    registerFieldMapping: (fieldKey: string, subscriptionKey: string) => void;
+    sendErrorToSingleClient: (ws: ServerWebSocket<unknown>, id: string, errors: readonly import("graphql").GraphQLError[]) => void;
+    removeSubscription: (ws: ServerWebSocket<unknown>, subscriptionId: string) => void;
+};
+export declare const websocketHandlerFactory: (roles: AnalyzedConfiguration["roles"]) => WebSocketHandler<unknown>;
+//# sourceMappingURL=handleGraphQLSubscriptionFactory.d.ts.map

package/dist/src/configuration/gql/handleGraphQLSubscriptionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGraphQLSubscriptionFactory.d.ts","sourceRoot":"","sources":["../../../../src/configuration/gql/handleGraphQLSubscriptionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAWjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;CAA4B,CAAC;AAwM3D,eAAO,MAAM,uBAAuB,GAClC,OAAO,qBAAqB,CAAC,OAAO,CAAC,KACpC,gBAAgB,CAAC,OAAO,CAkC1B,CAAC"}