hasura/graphql-engine
1
0
Fork 0
mirror of https://github.com/hasura/graphql-engine.git synced 2024-12-15 09:22:43 +03:00
Code Issues Projects Releases Wiki Activity
3427488c68
graphql-engine/server/graphql-engine.cabal
Vamshi Surabhi a01d1188f2 scaffolding for remote-schemas module 
The main aim of the PR is:

1. To set up a module structure for 'remote-schemas' package.
2. Move parts by the remote schema codebase into the new module structure to validate it.

## Notes to the reviewer

Why a PR with large-ish diff?

1. We've been making progress on the MM project but we don't yet know long it is going to take us to get to the first milestone. To understand this better, we need to figure out the unknowns as soon as possible. Hence I've taken a stab at the first two items in the [end-state](https://gist.github.com/0x777/ca2bdc4284d21c3eec153b51dea255c9) document to figure out the unknowns. Unsurprisingly, there are a bunch of issues that we haven't discussed earlier. These are documented in the 'open questions' section.

1. The diff is large but that is only code moved around and I've added a section that documents how things are moved. In addition, there are fair number of PR comments to help with the review process.

## Changes in the PR

### Module structure

Sets up the module structure as follows:

```
Hasura/
  RemoteSchema/
    Metadata/
      Types.hs
    SchemaCache/
      Types.hs
      Permission.hs
      RemoteRelationship.hs
      Build.hs
    MetadataAPI/
      Types.hs
      Execute.hs
```

### 1. Types representing metadata are moved

Types that capture metadata information (currently scattered across several RQL modules) are moved into `Hasura.RemoteSchema.Metadata.Types`.

- This new module only depends on very 'core' modules such as
  `Hasura.Session` for the notion of roles and `Hasura.Incremental` for `Cacheable` typeclass.

- The requirement on database modules is avoided by generalizing the remote schemas metadata to accept an arbitrary 'r' for a remote relationship
  definition.

### 2. SchemaCache related types and build logic have been moved

Types that represent remote schemas information in SchemaCache are moved into `Hasura.RemoteSchema.SchemaCache.Types`.

Similar to `H.RS.Metadata.Types`, this module depends on 'core' modules except for `Hasura.GraphQL.Parser.Variable`. It has something to do with remote relationships but I haven't spent time looking into it. The validation of 'remote relationships to remote schema' is also something that needs to be looked at.

Rips out the logic that builds remote schema's SchemaCache information from the monolithic `buildSchemaCacheRule` and moves it into `Hasura.RemoteSchema.SchemaCache.Build`. Further, the `.SchemaCache.Permission` and `.SchemaCache.RemoteRelationship` have been created from existing modules that capture schema cache building logic for those two components.

This was a fair amount of work. On main, currently remote schema's SchemaCache information is built in two phases - in the first phase, 'permissions' and 'remote relationships' are ignored and in the second phase they are filled in.

While remote relationships can only be resolved after partially resolving sources and other remote schemas, the same isn't true for permissions. Further, most of the work that is done to resolve remote relationships can be moved to the first phase so that the second phase can be a very simple traversal.

This is the approach that was taken - resolve permissions and as much as remote relationships information in the first phase.

### 3. Metadata APIs related types and build logic have been moved

The types that represent remote schema related metadata APIs and the execution logic have been moved to `Hasura.RemoteSchema.MetadataAPI.Types` and `.Execute` modules respectively.

## Open questions:

1. `Hasura.RemoteSchema.Metadata.Types` is so called because I was hoping that all of the metadata related APIs of remote schema can be brought in at `Hasura.RemoteSchema.Metadata.API`. However, as metadata APIs depended on functions from `SchemaCache` module (see [1](ceba6d6226/server/src-lib/Hasura/RQL/DDL/RemoteSchema.hs (L55)) and [2](ceba6d6226/server/src-lib/Hasura/RQL/DDL/RemoteSchema.hs (L91)), it made more sense to create a separate top-level module for `MetadataAPI`s.

   Maybe we can just have `Hasura.RemoteSchema.Metadata` and get rid of the extra nesting or have `Hasura.RemoteSchema.Metadata.{Core,Permission,RemoteRelationship}` if we want to break them down further.

1. `buildRemoteSchemas` in `H.RS.SchemaCache.Build` has the following type:

   ```haskell
   buildRemoteSchemas ::
     ( ArrowChoice arr,
       Inc.ArrowDistribute arr,
       ArrowWriter (Seq CollectedInfo) arr,
       Inc.ArrowCache m arr,
       MonadIO m,
       HasHttpManagerM m,
       Inc.Cacheable remoteRelationshipDefinition,
       ToJSON remoteRelationshipDefinition,
       MonadError QErr m
     ) =>
     Env.Environment ->
     ( (Inc.Dependency (HashMap RemoteSchemaName Inc.InvalidationKey), OrderedRoles),
       [RemoteSchemaMetadataG remoteRelationshipDefinition]
     )
       `arr` HashMap RemoteSchemaName (PartiallyResolvedRemoteSchemaCtxG remoteRelationshipDefinition, MetadataObject)
   ```

   Note the dependence on `CollectedInfo` which is defined as

   ```haskell
   data CollectedInfo
     = CIInconsistency InconsistentMetadata
     | CIDependency
         MetadataObject
         -- ^ for error reporting on missing dependencies
         SchemaObjId
         SchemaDependency
     deriving (Eq)
   ```

   this pretty much means that remote schemas is dependent on types from databases, actions, ....

   How do we fix this? Maybe introduce a typeclass such as `ArrowCollectRemoteSchemaDependencies` which is defined in `Hasura.RemoteSchema` and then implemented in graphql-engine?

1. The dependency on `buildSchemaCacheFor` in `.MetadataAPI.Execute` which has the following signature:

   ```haskell
   buildSchemaCacheFor ::
     (QErrM m, CacheRWM m, MetadataM m) =>
     MetadataObjId ->
     MetadataModifier ->
   ```

   This can be easily resolved if we restrict what the metadata APIs are allowed to do. Currently, they operate in an unfettered access to modify SchemaCache (the `CacheRWM` constraint):

   ```haskell
   runAddRemoteSchema ::
     ( QErrM m,
       CacheRWM m,
       MonadIO m,
       HasHttpManagerM m,
       MetadataM m,
       Tracing.MonadTrace m
     ) =>
     Env.Environment ->
     AddRemoteSchemaQuery ->
     m EncJSON
   ```

   This should instead be changed to restrict remote schema APIs to only modify remote schema metadata (but has access to the remote schemas part of the schema cache), this dependency is completely removed.

   ```haskell
   runAddRemoteSchema ::
     ( QErrM m,
       MonadIO m,
       HasHttpManagerM m,
       MonadReader RemoteSchemasSchemaCache m,
       MonadState RemoteSchemaMetadata m,
       Tracing.MonadTrace m
     ) =>
     Env.Environment ->
     AddRemoteSchemaQuery ->
     m RemoteSchemeMetadataObjId
   ```

   The idea is that the core graphql-engine would call these functions and then call
   `buildSchemaCacheFor`.

PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6291
GitOrigin-RevId: 51357148c6404afe70219afa71bd1d59bdf4ffc6
2022-10-21 03:15:04 +00:00

1170 lines
47 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

cabal-version: 2.2
name: graphql-engine
version: 1.0.0
synopsis: GraphQL API over Postgres
homepage: https://www.hasura.io
license: Apache-2.0
author: Vamshi Surabhi
maintainer: vamshi@hasura.io
copyright: Hasura Inc.
category: Database
build-type: Simple
extra-source-files:
-- We use TH to bake in the server’s version number at compile time. In order
-- for recompilation detection to work correctly (especially in the presence
-- of caching) we need to both communicate this data via a file (referenced in
-- TH with addDependentFile) /and/ add that file to this section of the cabal
-- file. See: https://github.com/haskell/cabal/issues/4746
--
-- This file is intentionally .gitignore'd
CURRENT_VERSION
-- These are files referenced by functions from 'file-embed' which uses
-- addDependentFile internally and has the same issue as above:
-- To easily rebuild this list, use the command 'find server/src-rsr -type f | sort'.
src-rsr/catalog_version.txt
src-rsr/catalog_versions.txt
src-rsr/citus_table_metadata.sql
src-rsr/clear_system_metadata.sql
src-rsr/cockroach_table_metadata.sql
src-rsr/console.html
src-rsr/drop_pg_source.sql
src-rsr/init_pg_source.sql
src-rsr/initialise.sql
src-rsr/introspection.json
src-rsr/migrations/08_to_1.sql
src-rsr/migrations/10_to_11.sql
src-rsr/migrations/11_to_12.sql
src-rsr/migrations/12_to_13.sql
src-rsr/migrations/13_to_12.sql
src-rsr/migrations/13_to_14.sql
src-rsr/migrations/14_to_13.sql
src-rsr/migrations/14_to_15.sql
src-rsr/migrations/15_to_14.sql
src-rsr/migrations/15_to_16.sql
src-rsr/migrations/16_to_15.sql
src-rsr/migrations/16_to_17.sql
src-rsr/migrations/17_to_16.sql
src-rsr/migrations/17_to_18.sql
src-rsr/migrations/18_to_17.sql
src-rsr/migrations/18_to_19.sql
src-rsr/migrations/19_to_18.sql
src-rsr/migrations/19_to_20.sql
src-rsr/migrations/1_to_2.sql
src-rsr/migrations/20_to_19.sql
src-rsr/migrations/20_to_21.sql
src-rsr/migrations/21_to_20.sql
src-rsr/migrations/21_to_22.sql
src-rsr/migrations/22_to_21.sql
src-rsr/migrations/22_to_23.sql
src-rsr/migrations/23_to_22.sql
src-rsr/migrations/23_to_24.sql
src-rsr/migrations/24_to_23.sql
src-rsr/migrations/24_to_25.sql
src-rsr/migrations/25_to_24.sql
src-rsr/migrations/25_to_26.sql
src-rsr/migrations/26_to_25.sql
src-rsr/migrations/26_to_27.sql
src-rsr/migrations/27_to_26.sql
src-rsr/migrations/27_to_28.sql
src-rsr/migrations/28_to_27.sql
src-rsr/migrations/28_to_29.sql
src-rsr/migrations/29_to_28.sql
src-rsr/migrations/29_to_30.sql
src-rsr/migrations/2_to_3.sql
src-rsr/migrations/30_to_29.sql
src-rsr/migrations/30_to_31.sql
src-rsr/migrations/31_to_30.sql
src-rsr/migrations/31_to_32.sql
src-rsr/migrations/32_to_31.sql
src-rsr/migrations/32_to_33.sql
src-rsr/migrations/33_to_32.sql
src-rsr/migrations/33_to_34.sql
src-rsr/migrations/34_to_33.sql
src-rsr/migrations/34_to_35.sql
src-rsr/migrations/35_to_34.sql
src-rsr/migrations/35_to_36.sql
src-rsr/migrations/36_to_35.sql
src-rsr/migrations/36_to_37.sql
src-rsr/migrations/37_to_36.sql
src-rsr/migrations/37_to_38.sql
src-rsr/migrations/38_to_37.sql
src-rsr/migrations/38_to_39.sql
src-rsr/migrations/39_to_38.sql
src-rsr/migrations/39_to_40.sql
src-rsr/migrations/40_to_39.sql
src-rsr/migrations/41_to_40.sql
src-rsr/migrations/41_to_42.sql
src-rsr/migrations/42_to_41.sql
src-rsr/migrations/42_to_43.sql
src-rsr/migrations/43_to_42.sql
src-rsr/migrations/43_to_44.sql
src-rsr/migrations/44_to_43.sql
src-rsr/migrations/44_to_45.sql
src-rsr/migrations/45_to_44.sql
src-rsr/migrations/45_to_46.sql
src-rsr/migrations/46_to_45.sql
src-rsr/migrations/46_to_47.sql
src-rsr/migrations/47_to_46.sql
src-rsr/migrations/4_to_5.sql
src-rsr/migrations/5_to_6.sql
src-rsr/migrations/6_to_7.sql
src-rsr/migrations/7_to_8.sql
src-rsr/migrations/8_to_9.sql
src-rsr/migrations/9_to_10.sql
src-rsr/mssql/drop_mssql_source.sql
src-rsr/mssql/init_mssql_source.sql
src-rsr/mssql/mssql_delete_trigger.sql.shakespeare
src-rsr/mssql/mssql_fetch_events.sql.shakespeare
src-rsr/mssql/mssql_insert_trigger.sql.shakespeare
src-rsr/mssql/mssql_source_migrations/1_to_2.sql
src-rsr/mssql/mssql_source_migrations/2_to_3.sql
src-rsr/mssql/mssql_table_metadata.sql
src-rsr/mssql/mssql_unlock_events.sql.shakespeare
src-rsr/mssql/mssql_update_trigger.sql.shakespeare
src-rsr/mysql_table_metadata.sql
src-rsr/pg_function_metadata.sql
src-rsr/pg_source_migrations/0_to_1.sql
src-rsr/pg_source_migrations/1_to_2.sql
src-rsr/pg_source_migrations/2_to_3.sql
src-rsr/pg_table_metadata.sql
src-rsr/table_meta.sql
src-rsr/trigger.sql.shakespeare
source-repository head
type: git
location: https://github.com/hasura/graphql-engine
flag profiling
description: Configures the project to be profiling-compatible
default: False
manual: True
-- A single flag to enable all optimization-related settings at once, for all
-- hasura code.
--
-- We share this flag name across our Haskell projects so we can switch it on or
-- off for all of them at in our Cabal project files.
flag optimize-hasura
description: Compile hasura code with appropriate optimizations
default: True
manual: False
flag ghci-load-test-with-lib
description: Allow running ghci on src-test but also load all of src-lib
default: False
manual: True
common common-all
ghc-options:
-foptimal-applicative-do
-Wall -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns -Wredundant-constraints
-- This is just to keep compile-times in check and might be adjusted later (See mono #2610):
-fmax-simplifier-iterations=2
-- Insisting on export lists might help with compile times, and help to document modules:
-Wmissing-export-lists
if flag(profiling)
cpp-options: -DPROFILING
if flag(optimize-hasura)
ghc-options:
-- This is for performance, and works in combination with '-fspecialise-aggressively'
-- in the graphql-engine 'executable' stanza below, and in any other dependent
-- executables (See mono #2610):
-fexpose-all-unfoldings
-O2
else
-- we just want to build fast:
ghc-options: -O0
default-language: Haskell2010
default-extensions:
AllowAmbiguousTypes
BangPatterns
BlockArguments
ConstraintKinds
DataKinds
DefaultSignatures
DeriveDataTypeable
DeriveFoldable
DeriveFunctor
DeriveGeneric
DeriveLift
DeriveTraversable
DerivingVia
FlexibleContexts
FlexibleInstances
FunctionalDependencies
GADTs
GeneralizedNewtypeDeriving
ImportQualifiedPost
InstanceSigs
LambdaCase
MultiParamTypeClasses
MultiWayIf
NamedFieldPuns
NoImplicitPrelude
OverloadedStrings
PackageImports
RankNTypes
RecordWildCards
RoleAnnotations
ScopedTypeVariables
StandaloneDeriving
StrictData
TupleSections
TypeApplications
TypeFamilies
TypeOperators
common common-exe
ghc-options:
-threaded -rtsopts
-- `-I0` disables idle GC. We do this in application code now. See 'ourIdleGC' for details.
-- `-T` is required to collect the stats we use in 'ourIdleGC'.
--
-- `-kc8K` helps limit memory consumption in websockets (perhaps elsewhere) by making the
-- cost of a thread's first (and probably only) stack overflow less severe.
-- See:https://github.com/hasura/graphql-engine/issues/5190
--
-- `--disable-delayed-os-memory-return` seems to help lower reported residency, in particular
-- in situations where we seem to be dealing with haskell heap fragmentation. This is more a
-- workaround for limitations in monitoring tools than anything...
"-with-rtsopts=-N -I0 -T -kc8K --disable-delayed-os-memory-return"
common lib-depends
build-depends: Spock-core
, aeson
, aeson-casing
, aeson-ordered
, attoparsec
, attoparsec-iso8601 >= 1.0
, autodocodec
, autodocodec-openapi3
, barbies
, base
, bytestring
, containers
, data-default
, deepseq
, dependent-map >=0.4 && <0.5
, dependent-sum
, dependent-sum-template
, either
, exceptions
, fast-logger
, dc-api
, free
, hashable
, hasura-error-message
, hasura-prelude
, hasura-schema-parsers
, http-client-tls
, http-conduit
, http-media
, http-types
, kan-extensions
, kriti-lang
, lifted-base
, monad-control
, monad-loops
, monad-validate
, mtl
, nonempty-containers
, openapi3
, optparse-applicative
, parsec
, pg-client
, postgresql-binary
, postgresql-libpq
, pretty-simple
, process
, profunctors
, refined
, retry
, safe-exceptions
, scientific
, semialign
, servant
, servant-client
, servant-client-core
, servant-openapi3
, some
, split
, template-haskell
, text
, text-builder >= 0.6
, th-lift
, these
, time >= 1.9
, time-compat
, transformers
, transformers-base
, unordered-containers >= 0.2.12
, url
, utf8-string
, validation
, vector
, vector-instances
, wai
, witch
, witherable >= 0.4
-- Encoder related
, uuid
, base16-bytestring
, cereal
, cryptohash-md5
-- Logging related
, network
, network-bsd
, byteorder
-- for parsing RSA keys
, cryptonite
-- for jwt verification
, jose
, pem
, x509
, asn1-encoding
, asn1-types
-- Server related
, warp
, lens
-- GraphQL related
, graphql-parser >=0.2 && <0.3
-- URL parser related
, network-uri >=2.6.3.0 && <2.7
, uri-encode
-- String related
, case-insensitive
, text-conversions
-- Http client
, wreq
, http-client
-- ordered map
, insert-ordered-containers
-- Parsing SemVer
, semver
-- Templating
, mustache
, file-embed
, shakespeare >= 2.0.22
--
, data-has
-- for src-exec
, yaml
, template-haskell >= 2.11
-- websockets interface related
, websockets>=0.12
, stm
, stm-containers
, list-t
, async
, lifted-async
, immortal < 0.3
-- logging related
, base64-bytestring >= 1.0
, auto-update
-- regex related
, regex-tdfa >=1.3.1 && <1.4
-- pretty printer
, ansi-wl-pprint
-- for capturing various metrics
, ekg-core
, ekg-json
, ekg-prometheus
-- metrics for CI integration
, ci-info
-- serve static files
, filepath >= 1.4
, mime-types >= 0.1
-- for handling posix signals for graceful shutdown
, unix
-- HTTP compression
, zlib
-- caching
, psqueues >= 0.2
-- testing
, QuickCheck
, quickcheck-instances
, directory
, random
, mmorph
, http-api-data
, lens-aeson
, semigroups >= 0.19.1
-- scheduled triggers
, cron >= 0.6.2
-- needed for deriving via
, semigroups >= 0.19
-- mssql support
, odbc
, resource-pool
-- bigquery support
, memory
, x509-store
, connection
, tls
, x509-validation
, data-default-class
, x509-system
, tagged
-- mysql
, mysql
, mysql-simple
-- dependency of vendored 'ip':
, wide-word
if !flag(profiling)
-- ghc-heap-view can't be built with profiling
build-depends: ghc-heap-view
library
import: common-all, lib-depends
hs-source-dirs: src-lib
exposed-modules: Autodocodec.Extended
, Control.Arrow.Extended
, Control.Arrow.Interpret
, Control.Arrow.Trans
, Control.Concurrent.Extended
, Control.Monad.Circular
, Control.Monad.Memoize
, Control.Monad.Stateless
, Control.Monad.Trans.Managed
, Control.Monad.Unique
, Data.Aeson.Extended
, Data.Aeson.KeyMap.Extended
, Data.Aeson.Kriti.Functions
, Data.Environment
, Data.HashMap.Strict.Extended
, Data.HashMap.Strict.Multi
, Data.HashMap.Strict.NonEmpty
, Data.HashMap.Strict.InsOrd.Autodocodec
, Data.HashMap.Strict.InsOrd.Extended
, Data.List.Extended
, Data.Parser.CacheControl
, Data.Parser.Expires
, Data.Parser.JSONPath
, Data.SqlCommenter
, Data.SerializableBlob
, Data.Text.Casing
, Data.Text.Extended
, Data.Text.NonEmpty
, Data.Trie
, Data.URL.Template
, Database.MSSQL.Transaction
, Database.MSSQL.Pool
, GHC.AssertNF.CPP
, GHC.Stats.Extended
, GHC.Generics.Extended
, Hasura.App
, Hasura.Metadata.Class
, Hasura.Base.Error
, Hasura.Base.Instances
, Hasura.Backends.BigQuery.Connection
, Hasura.Backends.BigQuery.Execute
, Hasura.Backends.BigQuery.DDL
, Hasura.Backends.BigQuery.DDL.BoolExp
, Hasura.Backends.BigQuery.DDL.RunSQL
, Hasura.Backends.BigQuery.DDL.Source
, Hasura.Backends.BigQuery.DDL.ComputedField
, Hasura.Backends.BigQuery.FromIr
, Hasura.Backends.BigQuery.Instances.API
, Hasura.Backends.BigQuery.Instances.Execute
, Hasura.Backends.BigQuery.Instances.Schema
, Hasura.Backends.BigQuery.Instances.SchemaCache
, Hasura.Backends.BigQuery.Instances.Transport
, Hasura.Backends.BigQuery.Instances.Types
, Hasura.Backends.BigQuery.Instances.Metadata
, Hasura.Backends.BigQuery.Meta
, Hasura.Backends.BigQuery.Name
, Hasura.Backends.BigQuery.Parser.Scalars
, Hasura.Backends.BigQuery.Plan
, Hasura.Backends.BigQuery.Source
, Hasura.Backends.BigQuery.ToQuery
, Hasura.Backends.BigQuery.Types
, Hasura.Backends.MSSQL.Connection
, Hasura.Backends.MSSQL.DDL
, Hasura.Backends.MSSQL.DDL.BoolExp
, Hasura.Backends.MSSQL.DDL.EventTrigger
, Hasura.Backends.MSSQL.DDL.RunSQL
, Hasura.Backends.MSSQL.DDL.Source
, Hasura.Backends.MSSQL.DDL.Source.Version
, Hasura.Backends.MSSQL.Execute.QueryTags
, Hasura.Backends.MSSQL.Execute.Delete
, Hasura.Backends.MSSQL.Execute.Insert
, Hasura.Backends.MSSQL.Execute.Update
, Hasura.Backends.MSSQL.FromIr
, Hasura.Backends.MSSQL.FromIr.Constants
, Hasura.Backends.MSSQL.FromIr.Delete
, Hasura.Backends.MSSQL.FromIr.Expression
, Hasura.Backends.MSSQL.FromIr.Insert
, Hasura.Backends.MSSQL.FromIr.MutationResponse
, Hasura.Backends.MSSQL.FromIr.Query
, Hasura.Backends.MSSQL.FromIr.SelectIntoTempTable
, Hasura.Backends.MSSQL.FromIr.Update
, Hasura.Backends.MSSQL.Instances.API
, Hasura.Backends.MSSQL.Instances.Execute
, Hasura.Backends.MSSQL.Instances.Metadata
, Hasura.Backends.MSSQL.Instances.Schema
, Hasura.Backends.MSSQL.Instances.SchemaCache
, Hasura.Backends.MSSQL.Instances.Transport
, Hasura.Backends.MSSQL.Instances.Types
, Hasura.Backends.MSSQL.Meta
, Hasura.Backends.MSSQL.Plan
, Hasura.Backends.MSSQL.Schema.IfMatched
, Hasura.Backends.MSSQL.SQL.Value
, Hasura.Backends.MSSQL.SQL.Error
, Hasura.Backends.MSSQL.ToQuery
, Hasura.Backends.MSSQL.Types
, Hasura.Backends.MSSQL.Types.Insert
, Hasura.Backends.MSSQL.Types.Instances
, Hasura.Backends.MSSQL.Types.Internal
, Hasura.Backends.MSSQL.Types.Update
, Hasura.Backends.Postgres.Connection
, Hasura.Backends.Postgres.Connection.MonadTx
, Hasura.Backends.Postgres.Connection.Settings
, Hasura.Backends.Postgres.DDL
, Hasura.Backends.Postgres.DDL.BoolExp
, Hasura.Backends.Postgres.DDL.ComputedField
, Hasura.Backends.Postgres.DDL.EventTrigger
, Hasura.Backends.Postgres.DDL.Function
, Hasura.Backends.Postgres.DDL.RunSQL
, Hasura.Backends.Postgres.DDL.Source
, Hasura.Backends.Postgres.DDL.Source.Version
, Hasura.Backends.Postgres.DDL.Table
, Hasura.Backends.Postgres.Execute.Subscription
, Hasura.Backends.Postgres.Execute.Insert
, Hasura.Backends.Postgres.Execute.Mutation
, Hasura.Backends.Postgres.Execute.Prepare
, Hasura.Backends.Postgres.Execute.Types
, Hasura.Backends.Postgres.Instances.API
, Hasura.Backends.Postgres.Instances.Execute
, Hasura.Backends.Postgres.Instances.Metadata
, Hasura.Backends.Postgres.Instances.Schema
, Hasura.Backends.Postgres.Instances.SchemaCache
, Hasura.Backends.Postgres.Instances.Transport
, Hasura.Backends.Postgres.Instances.Types
, Hasura.Backends.Postgres.Schema.OnConflict
, Hasura.Backends.Postgres.Schema.Select
, Hasura.Backends.Postgres.SQL.DML
, Hasura.Backends.Postgres.SQL.Error
, Hasura.Backends.Postgres.SQL.RenameIdentifiers
, Hasura.Backends.Postgres.SQL.Types
, Hasura.Backends.Postgres.SQL.Value
, Hasura.Backends.Postgres.Translate.BoolExp
, Hasura.Backends.Postgres.Translate.Column
, Hasura.Backends.Postgres.Translate.Delete
, Hasura.Backends.Postgres.Translate.Insert
, Hasura.Backends.Postgres.Translate.Mutation
, Hasura.Backends.Postgres.Translate.Returning
, Hasura.Backends.Postgres.Translate.Select
, Hasura.Backends.Postgres.Translate.Select.Aggregate
, Hasura.Backends.Postgres.Translate.Select.AnnotatedFieldJSON
, Hasura.Backends.Postgres.Translate.Select.Connection
, Hasura.Backends.Postgres.Translate.Select.Internal.Aliases
, Hasura.Backends.Postgres.Translate.Select.Internal.Extractor
, Hasura.Backends.Postgres.Translate.Select.Internal.GenerateSelect
, Hasura.Backends.Postgres.Translate.Select.Internal.Helpers
, Hasura.Backends.Postgres.Translate.Select.Internal.JoinTree
, Hasura.Backends.Postgres.Translate.Select.Internal.OrderBy
, Hasura.Backends.Postgres.Translate.Select.Internal.Process
, Hasura.Backends.Postgres.Translate.Select.Simple
, Hasura.Backends.Postgres.Translate.Select.Streaming
, Hasura.Backends.Postgres.Translate.Types
, Hasura.Backends.Postgres.Translate.Update
, Hasura.Backends.Postgres.Types.BoolExp
, Hasura.Backends.Postgres.Types.CitusExtraTableMetadata
, Hasura.Backends.Postgres.Types.ComputedField
, Hasura.Backends.Postgres.Types.Function
, Hasura.Backends.Postgres.Types.Column
, Hasura.Backends.Postgres.Types.Insert
, Hasura.Backends.Postgres.Types.Table
, Hasura.Backends.Postgres.Types.Update
, Hasura.Backends.MySQL.DataLoader.Execute
, Hasura.Backends.MySQL.DataLoader.Plan
, Hasura.Backends.MySQL.Types
, Hasura.Backends.MySQL.Types.Internal
, Hasura.Backends.MySQL.Types.Instances
, Hasura.Backends.MySQL.Plan
, Hasura.Backends.MySQL.FromIr
, Hasura.Backends.MySQL.Connection
, Hasura.Backends.MySQL.Meta
, Hasura.Backends.MySQL.Instances.Types
, Hasura.Backends.MySQL.Instances.Metadata
, Hasura.Backends.MySQL.Instances.Schema
, Hasura.Backends.MySQL.Instances.SchemaCache
, Hasura.Backends.MySQL.Instances.Execute
, Hasura.Backends.MySQL.Instances.Transport
, Hasura.Backends.MySQL.SQL
, Hasura.Backends.MySQL.ToQuery
, Hasura.Backends.MySQL.Instances.API
-- GraphQL Data Connector
, Hasura.Backends.DataConnector.Adapter.API
, Hasura.Backends.DataConnector.Adapter.Backend
, Hasura.Backends.DataConnector.Adapter.Execute
, Hasura.Backends.DataConnector.Adapter.ConfigTransform
, Hasura.Backends.DataConnector.Adapter.RunSQL
, Hasura.Backends.DataConnector.Adapter.Metadata
, Hasura.Backends.DataConnector.Adapter.Schema
, Hasura.Backends.DataConnector.Adapter.SchemaCache
, Hasura.Backends.DataConnector.Adapter.Transport
, Hasura.Backends.DataConnector.Adapter.Types
, Hasura.Backends.DataConnector.Agent.Client
, Hasura.Backends.DataConnector.Logging
, Hasura.Backends.DataConnector.Plan
-- Exposed for benchmark:
, Hasura.Cache.Bounded
, Hasura.Logging
, Hasura.HTTP
, Hasura.Incremental
, Hasura.Server.API.Backend
, Hasura.Server.API.Instances
, Hasura.Server.API.Metadata
, Hasura.Server.API.PGDump
, Hasura.Server.API.Query
, Hasura.Server.API.V2Query
, Hasura.Server.App
, Hasura.Server.Auth
, Hasura.Server.Compression
, Hasura.Server.Init
, Hasura.Server.Init.Arg
, Hasura.Server.Init.Arg.Command.Downgrade
, Hasura.Server.Init.Arg.Command.Serve
, Hasura.Server.Init.Arg.PrettyPrinter
, Hasura.Server.Init.Config
, Hasura.Server.Init.Env
, Hasura.Server.Init.Logging
, Hasura.Server.Limits
, Hasura.Server.Logging
, Hasura.Server.MetadataOpenAPI
, Hasura.Server.Migrate
, Hasura.Server.Name
, Hasura.Server.OpenAPI
, Hasura.Server.Rest
, Hasura.Server.Types
, Hasura.Server.Utils
, Hasura.Server.Version
, Hasura.EncJSON
, Hasura.GraphQL.Execute.Query
, Hasura.GraphQL.Logging
, Hasura.Incremental.Select
, Hasura.RQL.DML.Select
, Hasura.RQL.Types.Run
, Hasura.Session
, Hasura.Server.API.Config
, Hasura.Server.Metrics
, Hasura.Server.Prometheus
, Hasura.Server.Telemetry
, Hasura.Server.Telemetry.Types
, Hasura.Server.Telemetry.Counters
, Hasura.Server.Auth.JWT
, Hasura.GC
, Hasura.Incremental.Internal.Cache
, Hasura.Incremental.Internal.Dependency
, Hasura.Incremental.Internal.Rule
, Hasura.Server.Auth.WebHook
, Hasura.Server.Middleware
, Hasura.Server.Cors
, Hasura.Server.CheckUpdates
, Hasura.Server.SchemaCacheRef
, Hasura.Server.SchemaUpdate
, Hasura.Server.Migrate.LatestVersion
, Hasura.Server.Migrate.Version
, Hasura.Server.Migrate.Internal
, Hasura.Server.Auth.JWT.Internal
, Hasura.Server.Auth.JWT.Logging
, Hasura.RemoteSchema.Metadata.Base
, Hasura.RemoteSchema.Metadata.Customization
, Hasura.RemoteSchema.Metadata.Permission
, Hasura.RemoteSchema.Metadata.RemoteRelationship
, Hasura.RemoteSchema.Metadata.Core
, Hasura.RemoteSchema.Metadata
, Hasura.RemoteSchema.MetadataAPI.Core
, Hasura.RemoteSchema.MetadataAPI.Permission
, Hasura.RemoteSchema.MetadataAPI
, Hasura.RemoteSchema.SchemaCache.Types
, Hasura.RemoteSchema.SchemaCache.Permission
, Hasura.RemoteSchema.SchemaCache.RemoteRelationship
, Hasura.RemoteSchema.SchemaCache.Build
, Hasura.RemoteSchema.SchemaCache
, Hasura.RQL.Types.Action
, Hasura.RQL.Types.Allowlist
, Hasura.RQL.Types.ApiLimit
, Hasura.RQL.Types.Backend
, Hasura.RQL.Types.BoolExp
, Hasura.RQL.Types.Column
, Hasura.RQL.Types.Common
, Hasura.RQL.Types.ComputedField
, Hasura.RQL.Types.CustomTypes
, Hasura.RQL.Types.Endpoint
, Hasura.RQL.Types.Endpoint.Trie
, Hasura.RQL.Types.EventTrigger
, Hasura.RQL.Types.Eventing
, Hasura.RQL.Types.Eventing.Backend
, Hasura.RQL.Types.HealthCheck
, Hasura.RQL.Types.HealthCheckImplementation
, Hasura.RQL.Types.Function
, Hasura.RQL.Types.GraphqlSchemaIntrospection
, Hasura.RQL.Types.Instances
, Hasura.RQL.Types.Metadata
, Hasura.RQL.Types.Metadata.Backend
, Hasura.RQL.Types.Metadata.Common
, Hasura.RQL.Types.Metadata.Instances
, Hasura.RQL.Types.Metadata.Object
, Hasura.RQL.Types.Metadata.Serialization
, Hasura.RQL.Types.Network
, Hasura.RQL.Types.Permission
, Hasura.RQL.Types.QueryCollection
, Hasura.RQL.Types.QueryTags
, Hasura.RQL.Types.Relationships.Local
, Hasura.RQL.Types.Relationships.Remote
, Hasura.RQL.Types.Relationships.ToSource
, Hasura.RQL.Types.ResultCustomization
, Hasura.RQL.Types.Roles
, Hasura.RQL.Types.Roles.Internal
, Hasura.RQL.Types.ResizePool
, Hasura.RQL.Types.ScheduledTrigger
, Hasura.RQL.Types.SchemaCache
, Hasura.RQL.Types.SchemaCache.AggregationPredicates
, Hasura.RQL.Types.SchemaCache.Build
, Hasura.RQL.Types.SchemaCache.Instances
, Hasura.RQL.Types.SchemaCacheTypes
, Hasura.RQL.Types.Source
, Hasura.RQL.Types.SourceCustomization
, Hasura.RQL.Types.Subscription
, Hasura.RQL.Types.Table
, Hasura.RQL.DDL.Action
, Hasura.RQL.DDL.ApiLimit
, Hasura.RQL.DDL.ComputedField
, Hasura.RQL.DDL.CustomTypes
, Hasura.RQL.DDL.DataConnector
, Hasura.RQL.DDL.Endpoint
, Hasura.RQL.DDL.GraphqlSchemaIntrospection
, Hasura.RQL.DDL.InheritedRoles
, Hasura.RQL.DDL.Headers
, Hasura.RQL.DDL.Metadata
, Hasura.RQL.DDL.Metadata.Types
, Hasura.RQL.DDL.Permission
, Hasura.RQL.DDL.Permission.Internal
, Hasura.RQL.DDL.QueryCollection
, Hasura.RQL.DDL.QueryTags
, Hasura.RQL.DDL.Relationship
, Hasura.RQL.DDL.Relationship.Rename
, Hasura.RQL.DDL.RemoteRelationship
, Hasura.RQL.DDL.Webhook.Transform
, Hasura.RQL.DDL.Webhook.Transform.Body
, Hasura.RQL.DDL.Webhook.Transform.Class
, Hasura.RQL.DDL.Webhook.Transform.Headers
, Hasura.RQL.DDL.Webhook.Transform.Method
, Hasura.RQL.DDL.Webhook.Transform.QueryParams
, Hasura.RQL.DDL.Webhook.Transform.Response
, Hasura.RQL.DDL.Webhook.Transform.Request
, Hasura.RQL.DDL.Webhook.Transform.Validation
, Hasura.RQL.DDL.Webhook.Transform.Url
, Hasura.RQL.DDL.Webhook.Transform.WithOptional
, Hasura.RQL.DDL.SourceKinds
, Hasura.RQL.DDL.Schema
, Hasura.RQL.DDL.Schema.Cache
, Hasura.RQL.DDL.Schema.Cache.Common
, Hasura.RQL.DDL.Schema.Cache.Dependencies
, Hasura.RQL.DDL.Schema.Cache.Fields
, Hasura.RQL.DDL.Schema.Cache.Permission
, Hasura.RQL.DDL.Schema.Catalog
, Hasura.RQL.DDL.Schema.Diff
, Hasura.RQL.DDL.Schema.LegacyCatalog
, Hasura.RQL.DDL.Schema.Enum
, Hasura.RQL.DDL.Schema.Function
, Hasura.RQL.DDL.Schema.Rename
, Hasura.RQL.DDL.Schema.Table
, Hasura.RQL.DDL.Schema.Source
, Hasura.RQL.DDL.EventTrigger
, Hasura.RQL.DDL.ScheduledTrigger
, Hasura.RQL.DDL.Network
, Hasura.RQL.DML.Count
, Hasura.RQL.DML.Delete
, Hasura.RQL.DML.Insert
, Hasura.RQL.DML.Internal
, Hasura.RQL.DML.Update
, Hasura.RQL.DML.Types
, Hasura.RQL.IR.Action
, Hasura.RQL.IR.BoolExp
, Hasura.RQL.IR.BoolExp.AggregationPredicates
, Hasura.RQL.IR.Conflict
, Hasura.RQL.IR.Delete
, Hasura.RQL.IR.Insert
, Hasura.RQL.IR.OrderBy
, Hasura.RQL.IR.Returning
, Hasura.RQL.IR.Select
, Hasura.RQL.IR.RemoteSchema
, Hasura.RQL.IR.Update
, Hasura.RQL.IR.Value
, Hasura.RQL.IR.Root
, Hasura.RQL.IR
, Hasura.GraphQL.Analyse
, Hasura.GraphQL.ApolloFederation
, Hasura.GraphQL.Context
, Hasura.GraphQL.Execute
, Hasura.GraphQL.Execute.Action
, Hasura.GraphQL.Execute.Action.Subscription
, Hasura.GraphQL.Execute.Action.Types
, Hasura.GraphQL.Execute.Backend
, Hasura.GraphQL.Execute.Common
, Hasura.GraphQL.Execute.Inline
, Hasura.GraphQL.Execute.Instances
, Hasura.GraphQL.Execute.Subscription.Options
, Hasura.GraphQL.Execute.Subscription.Plan
, Hasura.GraphQL.Execute.Subscription.Poll
, Hasura.GraphQL.Execute.Subscription.Poll.Common
, Hasura.GraphQL.Execute.Subscription.Poll.LiveQuery
, Hasura.GraphQL.Execute.Subscription.Poll.StreamingQuery
, Hasura.GraphQL.Execute.Subscription.State
, Hasura.GraphQL.Execute.Subscription.TMap
, Hasura.GraphQL.Execute.Subscription.Types
, Hasura.GraphQL.Execute.Mutation
, Hasura.GraphQL.Execute.Remote
, Hasura.GraphQL.Execute.RemoteJoin
, Hasura.GraphQL.Execute.RemoteJoin.Types
, Hasura.GraphQL.Execute.RemoteJoin.Collect
, Hasura.GraphQL.Execute.RemoteJoin.Join
, Hasura.GraphQL.Execute.RemoteJoin.RemoteSchema
, Hasura.GraphQL.Execute.RemoteJoin.Source
, Hasura.GraphQL.Execute.Resolve
, Hasura.GraphQL.Execute.Types
, Hasura.GraphQL.Explain
, Hasura.GraphQL.Namespace
, Hasura.GraphQL.ParameterizedQueryHash
, Hasura.GraphQL.RemoteServer
, Hasura.GraphQL.Schema
, Hasura.GraphQL.Schema.Action
, Hasura.GraphQL.Schema.Backend
, Hasura.GraphQL.Schema.BoolExp
, Hasura.GraphQL.Schema.BoolExp.AggregationPredicates
, Hasura.GraphQL.Schema.Build
, Hasura.GraphQL.Schema.Common
, Hasura.GraphQL.Schema.Instances
, Hasura.GraphQL.Schema.Introspect
, Hasura.GraphQL.Schema.Mutation
, Hasura.GraphQL.Schema.NamingCase
, Hasura.GraphQL.Schema.Node
, Hasura.GraphQL.Schema.OrderBy
, Hasura.GraphQL.Schema.Options
, Hasura.GraphQL.Schema.Parser
, Hasura.GraphQL.Schema.Postgres
, Hasura.GraphQL.Schema.Relay
, Hasura.GraphQL.Schema.Remote
, Hasura.GraphQL.Schema.RemoteRelationship
, Hasura.GraphQL.Schema.Select
, Hasura.GraphQL.Schema.SubscriptionStream
, Hasura.GraphQL.Schema.Table
, Hasura.GraphQL.Schema.Typename
, Hasura.GraphQL.Schema.Update
, Hasura.GraphQL.Transport.Backend
, Hasura.GraphQL.Transport.HTTP
, Hasura.GraphQL.Transport.HTTP.Protocol
, Hasura.GraphQL.Transport.Instances
, Hasura.GraphQL.Transport.WSServerApp
, Hasura.GraphQL.Transport.WebSocket
, Hasura.GraphQL.Transport.WebSocket.Types
, Hasura.GraphQL.Transport.WebSocket.Protocol
, Hasura.GraphQL.Transport.WebSocket.Server
-- Metadata DTOs:
, Hasura.Metadata.DTO.Metadata
, Hasura.Metadata.DTO.MetadataV1
, Hasura.Metadata.DTO.MetadataV2
, Hasura.Metadata.DTO.MetadataV3
, Hasura.Metadata.DTO.Placeholder
, Hasura.Metadata.DTO.Utils
, Hasura.Eventing.Common
, Hasura.Eventing.EventTrigger
, Hasura.Eventing.HTTP
, Hasura.Eventing.ScheduledTrigger
, Hasura.Eventing.ScheduledTrigger.Types
, Hasura.Name
, Hasura.SQL.AnyBackend
, Hasura.SQL.Backend
, Hasura.SQL.BackendMap
, Hasura.SQL.Tag
, Hasura.SQL.GeoJSON
, Hasura.SQL.Time
, Hasura.SQL.Types
, Hasura.SQL.Value
, Hasura.SQL.WKT
, Hasura.Tracing
, Hasura.Tracing.TraceId
, Hasura.QueryTags
, Network.HTTP.Client.Transformable
, Network.HTTP.Client.Manager
, Network.HTTP.Client.DynamicTlsPermissions
, Network.HTTP.Client.Restricted
, Network.HTTP.Client.Blocklisting
, Network.HTTP.Client.CreateManager
, Network.URI.Extended
, Network.Wai.Extended
, Network.Wai.Handler.WebSockets.Custom
-- Our vendored bits of the 'ip' package, to avoid dependencies and ease 9.2 migration
-- We might see if maintainer is willing to split their package up so we can remove these:
, Net.IPv4
, Net.IPv6
executable graphql-engine
import: common-all, common-exe
if flag(optimize-hasura)
ghc-options:
-- This is for performance (See mono #2610):
-fspecialise-aggressively
hs-source-dirs: src-exec
main-is: Main.hs
build-depends: base
, graphql-engine
, bytestring
, ekg-core
, ekg-prometheus
, hasura-prelude
, kan-extensions
, pg-client
, refined
, text
, text-conversions
, time
, unix
-- The OpenAPI specification for metadata is experimental and incomplete. Please
-- do not incorporate it into essential workflows at this time.
executable emit-metadata-openapi
import: common-all
hs-source-dirs: src-emit-metadata-openapi
main-is: Main.hs
build-depends: base
, graphql-engine
, aeson-pretty
, bytestring
-- Ideally, we would not always import `lib-depends` here, and we would like to:
--
-- if flag(ghci-load-test-with-lib)
-- import: common-all, common-exe, lib-depends
-- else
-- import: common-all, common-exe
--
-- However, that doesn't work yet. See https://github.com/haskell/cabal/issues/8218
test-suite graphql-engine-tests
import: common-all, common-exe, lib-depends
build-tool-depends: hspec-discover:hspec-discover
type: exitcode-stdio-1.0
build-depends:
aeson
, aeson-pretty
, aeson-qq
, async
, attoparsec
, base
, bytestring
, case-insensitive
, containers
, cron
, dependent-map
, dependent-sum
, ekg-core
, dc-api
, free
, graphql-parser
, data-has
, hedgehog
, hspec >=2.8.3 && <3
, hspec-core >=2.8.3 && <3
, hspec-expectations
, hspec-expectations-json
, hspec-expectations-lifted
, hspec-hedgehog
, http-client
, http-client-tls
, http-types
, HUnit
, immortal
, insert-ordered-containers
, jose
, kan-extensions
, lens
, lens-aeson
, lifted-base
, list-t
, mmorph
, monad-control
, mtl
, natural-transformation >=0.4 && <0.5
, network-uri
, openapi3
, optparse-applicative
, pg-client
, postgresql-libpq
, process
, QuickCheck
, safe
, scientific
, split
, stm
, stm-containers
, template-haskell
, text
, time
, transformers
, transformers-base
, unordered-containers
, utf8-string
, uuid
, vector
, yaml
, shakespeare
-- mssql support
, odbc
, resource-pool
if !flag(ghci-load-test-with-lib)
build-depends: graphql-engine
hs-source-dirs: src-test
if flag(ghci-load-test-with-lib)
hs-source-dirs: src-lib
main-is: Main.hs
other-modules:
Control.Concurrent.ExtendedSpec
Control.Monad.CircularSpec
Control.Monad.MemoizationSpecDefinition
Control.Monad.MemoizeSpec
Control.Monad.TimeLimit
Data.HashMap.Strict.ExtendedSpec
Data.Parser.CacheControlSpec
Data.Parser.JSONPathSpec
Data.Parser.RemoteRelationshipSpec
Data.Parser.URLTemplateSpec
Data.Text.RawString
Data.TimeSpec
Data.TrieSpec
Database.MSSQL.TransactionSuite
Discover
Hasura.AppSpec
Hasura.Base.Error.TestInstances
Hasura.Backends.BigQuery.SourceSpec
Hasura.Backends.DataConnector.API.V0.AggregateSpec
Hasura.Backends.DataConnector.API.V0.CapabilitiesSpec
Hasura.Backends.DataConnector.API.V0.ColumnSpec
Hasura.Backends.DataConnector.API.V0.ConfigSchemaSpec
Hasura.Backends.DataConnector.API.V0.ExpressionSpec
Hasura.Backends.DataConnector.API.V0.OrderBySpec
Hasura.Backends.DataConnector.API.V0.QuerySpec
Hasura.Backends.DataConnector.API.V0.RelationshipsSpec
Hasura.Backends.DataConnector.API.V0.ScalarSpec
Hasura.Backends.DataConnector.API.V0.SchemaSpec
Hasura.Backends.DataConnector.API.V0.TableSpec
Hasura.Backends.MSSQL.ErrorSpec
Hasura.Backends.MySQL.DataLoader.ExecuteTests
Hasura.Backends.MySQL.TypesSpec
Hasura.Backends.Postgres.Execute.PrepareSpec
Hasura.Backends.Postgres.RQLGenerator
Hasura.Backends.Postgres.RQLGenerator.GenAnnSelectG
Hasura.Backends.Postgres.RQLGenerator.GenAssociatedTypes
Hasura.Backends.Postgres.RQLGenerator.GenSelectArgsG
Hasura.Backends.Postgres.RQLGenerator.GenSelectFromG
Hasura.Backends.Postgres.RQLGenerator.GenTablePermG
Hasura.Backends.Postgres.SQL.EDSL
Hasura.Backends.Postgres.SQL.Select.RenameIdentifiersSpec
Hasura.Backends.Postgres.SQL.ValueSpec
Hasura.Backends.Postgres.Translate.DeleteSpec
Hasura.Backends.Postgres.Translate.InsertSpec
Hasura.Backends.Postgres.Translate.UpdateSpec
Hasura.EncJSONSpec
Hasura.EventingSpec
Hasura.EventTriggerCleanupSuite
Hasura.Generator.Common
Hasura.GraphQL.NamespaceSpec
Hasura.GraphQL.Schema.BoolExp.AggregationPredicatesSpec
Hasura.GraphQL.Schema.Build.UpdateSpec
Hasura.GraphQL.Schema.Introspection
Hasura.GraphQL.Schema.RemoteTest
Hasura.IncrementalSpec
Hasura.Metadata.DTO.MetadataDTOSpec
Hasura.QuickCheck.Instances
Hasura.RQL.IR.Generator
Hasura.RQL.IR.SelectSpec
Hasura.RQL.MetadataSpec
Hasura.RQL.PermissionSpec
Hasura.RQL.Types.AllowlistSpec
Hasura.RQL.Types.CommonSpec
Hasura.RQL.Types.EndpointSpec
Hasura.RQL.Types.TableSpec
Hasura.RQL.WebhookTransformsSpec
Hasura.Server.Auth.JWTSpec
Hasura.Server.AuthSpec
Hasura.Server.InitSpec
Hasura.Server.Init.ArgSpec
Hasura.Server.MigrateSuite
Hasura.Server.Migrate.VersionSpec
Hasura.Server.TelemetrySpec
Hasura.Server.VersionSpec
Hasura.Server.InitSpec
Hasura.Server.Init.ArgSpec
Hasura.SessionSpec
Hasura.SQL.WKTSpec
Hasura.StreamingSubscriptionSuite
Hasura.Tracing.TraceIdSpec
Network.HTTP.Client.TransformableSpec
Test.Aeson.Expectation
Test.Aeson.Utils
Test.Backend.Postgres.Delete
Test.Backend.Postgres.Insert
Test.Backend.Postgres.Misc
Test.Backend.Postgres.Update
Test.Hspec.Extended
Test.Parser.Delete
Test.Parser.Expectation
Test.Parser.Field
Test.Parser.Insert
Test.Parser.Internal
Test.Parser.Monad
Test.QuickCheck.Extended
Test.SIString
Reference in New Issue View Git Blame Copy Permalink