fragment-dev 1.4.6 → 2.1.0

data/lib/queries.graphql

@@ -24,9 +24,7 @@ mutation StoreSchema($schema: SchemaInput!) {
   }
 }
 
-mutation DeleteSchema(
-  $schema: SchemaMatchInput!
-) {
+mutation DeleteSchema($schema: SchemaMatchInput!) {
   deleteSchema(schema: $schema) {
     __typename
     ... on DeleteSchemaResult {
@@ -77,9 +75,7 @@ mutation CreateLedger(
   }
 }
 
-mutation DeleteLedger(
-  $ledger: LedgerMatchInput!
-) {
+mutation DeleteLedger($ledger: LedgerMatchInput!) {
   deleteLedger(ledger: $ledger) {
     __typename
     ... on DeleteLedgerResult {
@@ -98,6 +94,52 @@ mutation DeleteLedger(
   }
 }
 
+mutation AddLedgerEntries($entries: [AddLedgerEntryInput!]!) {
+  addLedgerEntries(entries: $entries) {
+    __typename
+    ... on AddLedgerEntriesResult {
+      results {
+        isIkReplay
+        entry {
+          type
+          id
+          ik
+          posted
+          created
+        }
+        lines {
+          id
+          amount
+          account {
+            path
+          }
+        }
+      }
+    }
+    ... on AddLedgerEntriesError {
+      code
+      message
+      retryable
+      errors {
+        ik
+        code
+        message
+        retryable
+      }
+    }
+    ... on BadRequestError {
+      code
+      message
+      retryable
+    }
+    ... on InternalError {
+      code
+      message
+      retryable
+    }
+  }
+}
+
 mutation AddLedgerEntry(
   $ik: SafeString!
   $ledgerIk: SafeString!
@@ -151,9 +193,7 @@ mutation AddLedgerEntry(
   }
 }
 
-mutation ReverseLedgerEntry(
-  $id: ID!
-) {
+mutation ReverseLedgerEntry($id: ID!) {
   reverseLedgerEntry(id: $id) {
     __typename
     ... on ReverseLedgerEntryResult {
@@ -208,14 +248,8 @@ mutation ReverseLedgerEntry(
   }
 }
 
-mutation MigrateLedgerEntry(
-  $id: ID!
-  $newLedgerEntry: LedgerEntryInput!
-) {
-  migrateLedgerEntry(input: {
-    id: $id
-    newLedgerEntry: $newLedgerEntry
-  }) {
+mutation MigrateLedgerEntry($id: ID!, $newLedgerEntry: LedgerEntryInput!) {
+  migrateLedgerEntry(input: { id: $id, newLedgerEntry: $newLedgerEntry }) {
     __typename
     ... on MigrateLedgerEntryResult {
       reversingLedgerEntry {
@@ -689,6 +723,8 @@ query ListLedgerAccountBalances(
   $balanceCurrency: CurrencyMatchInput
   $balanceAt: LastMoment
   $ownBalanceConsistencyMode: ReadBalanceConsistencyMode
+  $childBalanceConsistencyMode: ReadBalanceConsistencyMode
+  $balanceConsistencyMode: ReadBalanceConsistencyMode
 ) {
   ledger(ledger: { ik: $ledgerIk }) {
     id
@@ -707,8 +743,16 @@ query ListLedgerAccountBalances(
           at: $balanceAt
           consistencyMode: $ownBalanceConsistencyMode
         )
-        childBalance(currency: $balanceCurrency, at: $balanceAt)
-        balance(currency: $balanceCurrency, at: $balanceAt)
+        childBalance(
+          currency: $balanceCurrency
+          at: $balanceAt
+          consistencyMode: $childBalanceConsistencyMode
+        )
+        balance(
+          currency: $balanceCurrency
+          at: $balanceAt
+          consistencyMode: $balanceConsistencyMode
+        )
       }
       pageInfo {
         hasNextPage
@@ -727,6 +771,8 @@ query ListMultiCurrencyLedgerAccountBalances(
   $before: String
   $balanceAt: LastMoment
   $ownBalancesConsistencyMode: ReadBalanceConsistencyMode
+  $childBalancesConsistencyMode: ReadBalanceConsistencyMode
+  $balancesConsistencyMode: ReadBalanceConsistencyMode
 ) {
   ledger(ledger: { ik: $ledgerIk }) {
     id
@@ -752,7 +798,10 @@ query ListMultiCurrencyLedgerAccountBalances(
             amount
           }
         }
-        childBalances(at: $balanceAt) {
+        childBalances(
+          at: $balanceAt
+          consistencyMode: $childBalancesConsistencyMode
+        ) {
           nodes {
             currency {
               code
@@ -761,7 +810,7 @@ query ListMultiCurrencyLedgerAccountBalances(
             amount
           }
         }
-        balances(at: $balanceAt) {
+        balances(at: $balanceAt, consistencyMode: $balancesConsistencyMode) {
           nodes {
             currency {
               code
@@ -815,24 +864,7 @@ query GetLedgerAccountBalance(
   $ledgerIk: SafeString!
   $balanceCurrency: CurrencyMatchInput
   $balanceAt: LastMoment
-  $ownBalanceConsistencyMode: ReadBalanceConsistencyMode
-) {
-  ledgerAccount(ledgerAccount: { ledger: { ik: $ledgerIk }, path: $path }) {
-    id
-    path
-    ownBalance(
-      currency: $balanceCurrency
-      at: $balanceAt
-      consistencyMode: $ownBalanceConsistencyMode
-    )
-  }
-}
-
-query GetLedgerAccountBalanceWithChildRollup(
-  $path: String!
-  $ledgerIk: SafeString!
-  $balanceCurrency: CurrencyMatchInput
-  $balanceAt: LastMoment
+  $balanceConsistencyMode: ReadBalanceConsistencyMode
 ) {
   ledgerAccount(ledgerAccount: { ledger: { ik: $ledgerIk }, path: $path }) {
     id
@@ -840,11 +872,11 @@ query GetLedgerAccountBalanceWithChildRollup(
     balance(
       currency: $balanceCurrency
       at: $balanceAt
+      consistencyMode: $balanceConsistencyMode
     )
   }
 }
 
-
 query GetSchema($key: SafeString!, $version: Int) {
   schema(schema: { key: $key, version: $version }) {
     key
@@ -912,21 +944,23 @@ query ListLedgerEntryGroupBalances(
   $last: Int
   $filter: LedgerEntryGroupBalanceFilterSet
 ) {
-  ledgerEntryGroup(ledgerEntryGroup: {
-    ledger: { ik: $ledgerIk },
-    key: $groupKey,
-    value: $groupValue,
-  }) {
+  ledgerEntryGroup(
+    ledgerEntryGroup: {
+      ledger: { ik: $ledgerIk }
+      key: $groupKey
+      value: $groupValue
+    }
+  ) {
     key
     value
     created
     balances(
-      after: $after,
-      before: $before,
-      first: $first,
-      last: $last,
-      filter: $filter,
-    ){
+      after: $after
+      before: $before
+      first: $first
+      last: $last
+      filter: $filter
+    ) {
       nodes {
         account {
           path
@@ -1020,12 +1054,8 @@ query GetEntriesToMigrateForLedgerEntryDataMigration(
   ledger(ledger: { ik: $ledgerIk }) {
     ledgerEntryDataMigrations(
       filter: {
-        entryType: {
-          equalTo: $entryType
-        }
-        typeVersion: {
-          equalTo: $typeVersion
-        }
+        entryType: { equalTo: $entryType }
+        typeVersion: { equalTo: $typeVersion }
       }
     ) {
       nodes {
@@ -1049,7 +1079,7 @@ query GetEntriesToMigrateForLedgerEntryDataMigration(
                 id
                 amount
                 account {
-                    path
+                  path
                 }
               }
             }
@@ -1136,18 +1166,14 @@ query GetEntriesToMigrateForLedgerAccountDataMigration(
 ) {
   ledger(ledger: { ik: $ledgerIk }) {
     ledgerAccountDataMigrations(
-      filter: {
-        accountPath: {
-          equalTo: $accountPath
-        }
-      }
+      filter: { accountPath: { equalTo: $accountPath } }
     ) {
       nodes {
         ledgerEntries(
-         first: $first
-         after: $after
-         last: $last
-         before: $before
+          first: $first
+          after: $after
+          last: $last
+          before: $before
         ) {
           nodes {
             id
@@ -1181,17 +1207,17 @@ query GetEntriesToMigrateForLedgerAccountDataMigration(
 }
 
 mutation CreateCustomCurrency(
-  $id: SafeString!,
-  $name: String!,
-  $precision: Int!,
-  $customCode: String!,
+  $id: SafeString!
+  $name: String!
+  $precision: Int!
+  $customCode: String!
 ) {
   createCustomCurrency(
     customCurrency: {
-      customCurrencyId: $id,
-      name: $name,
-      precision: $precision,
-      customCode: $customCode,
+      customCurrencyId: $id
+      name: $name
+      precision: $precision
+      customCode: $customCode
     }
   ) {
     ... on CreateCustomCurrencyResult {

data/lib/tapioca/dsl/compilers/fragment_query_methods.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Tapioca::Dsl::Compilers)
+
+require 'fragment_client'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Declares the query and mutation methods {FragmentClient} answers to.
+      #
+      # `define_method_from_queries` creates one singleton method per operation on
+      # each client instance, so without this Sorbet reports `Method
+      # 'create_ledger' does not exist` for every one of them and a consumer has to
+      # write `T.unsafe(client)`.
+      #
+      # Covers the operations shipped in `queries.graphql`, plus any document
+      # passed to `FragmentClient.load_queries`. Operations in
+      # {FragmentClient::WRAPPED_OPERATIONS} are skipped: those have hand-written
+      # methods with real signatures already.
+      #
+      # `variables` is the operation's variables hash and stays untyped. Its keys
+      # are the GraphQL variable names verbatim, as the rest of this SDK passes
+      # them. The return type comes from `FragmentResponseTypes`.
+      class FragmentQueryMethods < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(FragmentClient) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            [FragmentClient]
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          methods = FragmentGraphQl.operations.keys.to_h do |operation|
+            [FragmentGraphQl.method_name_for(operation), operation]
+          end
+          methods.reject! { |name, _| FragmentClient::WRAPPED_OPERATIONS.include?(name) }
+          return if methods.empty?
+
+          root.create_path(constant) do |klass|
+            methods.keys.sort.each do |name|
+              klass.create_method(
+                name,
+                parameters: [create_param('variables', type: 'T::Hash[Symbol, T.untyped]')],
+                return_type: "::FragmentClient::Responses::#{methods.fetch(name)}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/fragment_response_types.rb

@@ -0,0 +1,222 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Tapioca::Dsl::Compilers)
+
+require 'fragment_client'
+require 'tapioca/dsl/helpers/graphql_sorbet_types'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Declares the response objects the query methods return, so that
+      # `client.get_ledger(...).data.ledger.name` typechecks.
+      #
+      # graphql-client builds those objects at runtime from anonymous classes whose
+      # fields are served by `method_missing`, so there is nothing to reflect on.
+      # The shape is instead derived statically from each operation's selection set
+      # and the pinned Schema -- the same two inputs graphql-client itself uses,
+      # which is what makes the declared types agree with the runtime.
+      #
+      # In particular graphql-client refuses at runtime to read a field the
+      # operation did not select (`ImplicitlyFetchedFieldError`), so a type derived
+      # from the selection set cannot promise more than the runtime allows.
+      #
+      # Emitted under `FragmentClient::Responses::<Operation>`, one nested class per
+      # selection level.
+      class FragmentResponseTypes < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(FragmentClient) } }
+
+        # Scalar names this Schema uses, mapped for `GraphqlSorbetTypes`.
+        SCALARS = T.let(
+          {
+            'String' => '::String', 'ID' => '::String', 'SafeString' => '::String',
+            'ParameterizedString' => '::String', 'Date' => '::String',
+            'DateTime' => '::String', 'FirstMoment' => '::String',
+            'LastMoment' => '::String', 'Period' => '::String',
+            'PeriodFilter' => '::String', 'UTCOffset' => '::String',
+            'Int96' => '::String', 'Int' => '::Integer', 'Float' => '::Float',
+            'Boolean' => 'T::Boolean', 'JSON' => 'T.untyped', 'Parameters' => 'T.untyped'
+          }.freeze,
+          T::Hash[String, String]
+        )
+
+        RESPONSES_NAMESPACE = 'FragmentClient::Responses'
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            [FragmentClient]
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          operations = FragmentGraphQl.operations
+          return if operations.empty?
+
+          root.create_module(RESPONSES_NAMESPACE) do |namespace|
+            operations.keys.sort.each do |name|
+              declare_operation(namespace, name, T.must(operations[name]))
+            end
+          end
+        end
+
+        private
+
+        sig do
+          params(namespace: RBI::Scope, name: String,
+                 operation: GraphQL::Language::Nodes::OperationDefinition).void
+        end
+        def declare_operation(namespace, name, operation)
+          root_type = operation.operation_type == 'mutation' ? schema.mutation : schema.query
+          return if root_type.nil?
+
+          namespace.create_class(name) do |response|
+            response.create_method('data', return_type: "T.nilable(#{RESPONSES_NAMESPACE}::#{name}::Data)")
+            response.create_method('errors', return_type: 'T.untyped')
+            response.create_method('original_hash', return_type: 'T::Hash[String, T.untyped]')
+            declare_object(response, 'Data', operation.selections, root_type)
+          end
+        end
+
+        # One nested class per selection level. `path` is its fully qualified name,
+        # which children extend so nested references resolve.
+        sig do
+          params(parent: RBI::Scope, class_name: String, selections: T::Array[T.untyped],
+                 graphql_type: T.untyped).void
+        end
+        def declare_object(parent, class_name, selections, graphql_type)
+          fields = collect_fields(selections, graphql_type)
+
+          parent.create_class(class_name) do |scope|
+            fields.each do |field|
+              scope.create_method(field.fetch(:method), return_type: field.fetch(:type),
+                                                        comments: field.fetch(:comments))
+              nested = field[:nested]
+              next unless nested
+
+              declare_object(scope, nested.fetch(:class_name), nested.fetch(:selections),
+                             nested.fetch(:type))
+            end
+          end
+        end
+
+        # Flatten a selection set into field descriptors, following inline fragments.
+        #
+        # A union or interface selection contributes every branch's fields, each
+        # made nilable: graphql-client returns one object whatever the `__typename`,
+        # and only the branch that matched carries values.
+        sig do
+          params(selections: T::Array[T.untyped], graphql_type: T.untyped, force_nilable: T::Boolean,
+                 taken: T::Set[String])
+            .returns(T::Array[T::Hash[Symbol, T.untyped]])
+        end
+        def collect_fields(selections, graphql_type, force_nilable: false, taken: Set.new)
+          selections.flat_map do |selection|
+            case selection
+            when GraphQL::Language::Nodes::Field
+              field = describe_field(selection, graphql_type, force_nilable, taken)
+              field ? [field] : []
+            when GraphQL::Language::Nodes::InlineFragment
+              branch = selection.type ? lookup_type(selection.type.name) : graphql_type
+              next [] if branch.nil?
+
+              collect_fields(selection.selections, branch, force_nilable: true, taken: taken)
+            else
+              []
+            end
+          end
+        end
+
+        sig do
+          params(selection: GraphQL::Language::Nodes::Field, graphql_type: T.untyped,
+                 force_nilable: T::Boolean, taken: T::Set[String])
+            .returns(T.nilable(T::Hash[Symbol, T.untyped]))
+        end
+        def describe_field(selection, graphql_type, force_nilable, taken)
+          name = selection.alias || selection.name
+          method = ActiveSupport::Inflector.underscore(name)
+          return nil if taken.include?(method)
+
+          taken << method
+          return { method: method, type: '::String', comments: [], nested: nil } if name == '__typename'
+
+          field = graphql_type.respond_to?(:fields) ? graphql_type.fields[selection.name] : nil
+          return { method: method, type: 'T.untyped', comments: [], nested: nil } if field.nil?
+
+          build_field(selection, field, method, name, force_nilable, taken)
+        end
+
+        sig do
+          params(selection: GraphQL::Language::Nodes::Field, field: T.untyped, method: String,
+                 name: String, force_nilable: T::Boolean, taken: T::Set[String])
+            .returns(T::Hash[Symbol, T.untyped])
+        end
+        def build_field(selection, field, method, name, force_nilable, taken)
+          unwrapped = field.type.unwrap
+          nilable = force_nilable || !field.type.non_null?
+
+          if selection.selections.empty?
+            return { method: method, type: wrap(scalar_type(unwrapped), field.type, nilable),
+                     comments: [comment("`#{name}`: #{field.type.to_type_signature}")], nested: nil }
+          end
+
+          class_name = ActiveSupport::Inflector.camelize(method)
+          class_name = "#{class_name}Object" if taken.include?("class:#{class_name}")
+          taken << "class:#{class_name}"
+
+          { method: method, type: wrap(class_name, field.type, nilable),
+            comments: [comment("`#{name}`: #{field.type.to_type_signature}")],
+            nested: { class_name: class_name, selections: selection.selections,
+                      type: unwrapped } }
+        end
+
+        # Apply the GraphQL type's list and nullability wrappers to `inner`.
+        #
+        # `[Ledger!]!` becomes `T::Array[X]`, `[Ledger]` becomes
+        # `T::Array[T.nilable(X)]`. `T.untyped` already includes nil, so it is never
+        # wrapped again.
+        sig { params(inner: String, graphql_type: T.untyped, nilable: T::Boolean).returns(String) }
+        def wrap(inner, graphql_type, nilable)
+          bare = graphql_type.non_null? ? graphql_type.of_type : graphql_type
+          type = if bare.list?
+                   "T::Array[#{nilable_unless(inner, bare.of_type.non_null?)}]"
+                 else
+                   inner
+                 end
+          nilable_unless(type, !nilable)
+        end
+
+        sig { params(type: String, non_null: T::Boolean).returns(String) }
+        def nilable_unless(type, non_null)
+          non_null || type == 'T.untyped' ? type : "T.nilable(#{type})"
+        end
+
+        sig { params(unwrapped: T.untyped).returns(String) }
+        def scalar_type(unwrapped)
+          Helpers::GraphqlSorbetTypes.translate(unwrapped.graphql_name, scalars: SCALARS)
+        end
+
+        sig { params(name: String).returns(T.untyped) }
+        def lookup_type(name)
+          schema.types[name]
+        end
+
+        sig { returns(T.untyped) }
+        def schema
+          FragmentGraphQl::FragmentSchema
+        end
+
+        sig { params(text: String).returns(RBI::Comment) }
+        def comment(text)
+          RBI::Comment.new(text)
+        end
+      end
+    end
+  end
+end