haveapi-typescript-client 0.31.0

data/lib/haveapi/typescript_client/generator.rb

@@ -0,0 +1,176 @@
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+
+module HaveAPI::TypeScriptClient
+  class Generator
+    ROOT = File.expand_path('../../..', __dir__)
+    OWNER_FILE = '.haveapi-generated.json'.freeze
+    OWNER = 'haveapi-typescript-client'.freeze
+    CONFIG = { runtime_import: 'haveapi-client' }.freeze
+
+    def self.source_files
+      Dir.chdir(ROOT) do
+        Dir['bin/**/*', 'lib/**/*.rb', 'template/**/*', 'Gemfile', '*.gemspec', 'Rakefile']
+          .select { |path| File.file?(path) }.sort
+      end
+    end
+
+    def self.source_digest
+      digest = Digest::SHA256.new
+      source_files.each do |path|
+        digest.update(path).update("\0").update(File.binread(File.join(ROOT, path))).update("\0")
+      end
+      digest.update('haveapi/schema').update("\0").update(Snapshot.canonical(HaveAPI::Schema.source_identity)).update("\0")
+      digest.hexdigest
+    end
+
+    def initialize(schema:, config: CONFIG)
+      unless config == CONFIG
+        raise Error, 'unsupported generator configuration'
+      end
+
+      @schema = Snapshot.validate(schema)
+      @ir = IR.build(schema)
+      @config = CONFIG
+    end
+
+    def generate(output:, check: false)
+      output = File.expand_path(output)
+      validate_destination(output)
+      require_relative 'emitter'
+      files = Emitter.new(@ir, @config).files
+      validate_files(files)
+      manifest = {
+        'owner' => OWNER, 'format' => 1, 'generator_version' => VERSION,
+        'generator_source_sha256' => self.class.source_digest,
+        'schema_sha256' => Snapshot.sha256(@schema), 'api_version' => @schema.fetch('api_version'),
+        'protocol_version' => @schema.fetch('protocol_version'), 'profile' => @schema.fetch('profile'),
+        'config' => @config.transform_keys(&:to_s), 'coverage' => coverage,
+        'files' => files.sort.to_h.transform_values { |content| Digest::SHA256.hexdigest(content) }
+      }
+      candidate = files.merge(OWNER_FILE => Snapshot.canonical(manifest))
+      return true if equal_tree?(output, candidate)
+      raise Error, 'generated tree is stale; regenerate without --check' if check
+
+      install(output, candidate)
+      true
+    end
+
+    private
+
+    def coverage
+      count_resources = lambda do |map|
+        map.values.sum { |resource| 1 + count_resources.call(resource.fetch('resources')) }
+      end
+      count_actions = lambda do |map|
+        map.values.sum { |resource| resource.fetch('actions').length + count_actions.call(resource.fetch('resources')) }
+      end
+      application = @schema.fetch('description').fetch('resources')
+      auth = @schema.fetch('description').fetch('authentication').values.map { |config| config.fetch('resources', {}) }
+      {
+        'application_resource_count' => count_resources.call(application),
+        'application_action_count' => @ir.fetch(:actions).length,
+        'authentication_resource_count' => auth.sum { |map| count_resources.call(map) },
+        'authentication_action_count' => auth.sum { |map| count_actions.call(map) },
+        'authentication_exclusion' => 'Authentication resources are retained and validated; the existing runtime owns their API-root routes.'
+      }
+    end
+
+    def safe_relative?(path)
+      path.is_a?(String) && !path.empty? && !path.start_with?('/') && !path.include?('\\') &&
+        !path.match?(/[\x00-\x1f\x7f]/) && path.split('/').none? { |part| ['', '.', '..'].include?(part) }
+    end
+
+    def validate_files(files)
+      raise Error, 'emitter must return a nonempty file map including index.ts' unless files.is_a?(Hash) && files.has_key?('index.ts')
+
+      files.each do |path, content|
+        unless safe_relative?(path) && path != OWNER_FILE && content.is_a?(String) &&
+               content.encoding == Encoding::UTF_8 && content.valid_encoding? && !content.include?("\r") && content.end_with?("\n")
+          raise Error, "unsafe generated file or non-UTF-8/LF content: #{path.inspect}"
+        end
+
+        fail_conflict = files.keys.any? { |other| other != path && path.start_with?("#{other}/") }
+        raise Error, "generated file/directory conflict: #{path}" if fail_conflict
+      end
+    end
+
+    def validate_destination(output)
+      unless File.basename(output) == 'generated' && File.basename(File.dirname(output)) == 'src'
+        raise Error, 'output must be the exclusively generated src/generated directory'
+      end
+
+      cursor = output
+      loop do
+        raise Error, 'generated destination contains a symlink' if File.symlink?(cursor)
+        break if cursor == File.dirname(cursor)
+
+        cursor = File.dirname(cursor)
+      end
+      return unless File.exist?(output)
+      raise Error, 'generated destination is not a directory' unless File.directory?(output)
+
+      files = tree_files(output)
+      return if files.empty? && Dir.empty?(output)
+
+      marker = File.join(output, OWNER_FILE)
+      raise Error, 'nonempty destination has no generator ownership manifest' unless File.file?(marker)
+
+      owner = JSON.parse(File.read(marker))
+      unless owner['owner'] == OWNER && owner['format'] == 1 && owner['files'].is_a?(Hash) &&
+             owner['files'].all? { |path, hash| safe_relative?(path) && path != OWNER_FILE && hash.is_a?(String) && hash.match?(/\A[0-9a-f]{64}\z/) }
+        raise Error, 'invalid generator ownership manifest'
+      end
+
+      unknown = files - owner.fetch('files').keys - [OWNER_FILE]
+      raise Error, "destination contains files not owned by generator: #{unknown.join(', ')}" unless unknown.empty?
+    rescue JSON::ParserError
+      raise Error, 'invalid generator ownership JSON'
+    end
+
+    def tree_files(root)
+      return [] unless File.directory?(root)
+
+      Dir.glob('**/*', File::FNM_DOTMATCH, base: root).reject { |path| %w[. ..].include?(File.basename(path)) }.filter_map do |path|
+        full = File.join(root, path)
+        raise Error, "generated directory contains a symlink: #{path}" if File.symlink?(full)
+        next if File.directory?(full)
+        raise Error, "generated directory contains a nonregular file: #{path}" unless File.file?(full)
+
+        path
+      end.sort
+    end
+
+    def equal_tree?(output, candidate)
+      tree_files(output) == candidate.keys.sort && candidate.all? do |path, content|
+        File.binread(File.join(output, path)) == content.b
+      end
+    end
+
+    def install(output, candidate)
+      previous = tree_files(output)
+      FileUtils.mkdir_p(output)
+      # Each file replacement is atomic. The manifest is installed last so an
+      # interrupted regeneration is recognized as drift by the next --check.
+      candidate.reject { |path, _content| path == OWNER_FILE }.each { |path, content| write_file(output, path, content) }
+      (previous - candidate.keys).each { |path| File.unlink(File.join(output, path)) }
+      write_file(output, OWNER_FILE, candidate.fetch(OWNER_FILE))
+      Dir.glob('**/*', base: output).sort.reverse_each do |path|
+        full = File.join(output, path)
+        Dir.rmdir(full) if File.directory?(full) && Dir.empty?(full)
+      end
+    end
+
+    def write_file(output, path, content)
+      target = File.join(output, path)
+      FileUtils.mkdir_p(File.dirname(target))
+      Tempfile.create(['.haveapi-', '.tmp'], File.dirname(target)) do |temp|
+        temp.binmode
+        temp.write(content)
+        temp.close
+        File.rename(temp.path, target)
+      end
+    end
+  end
+end

data/lib/haveapi/typescript_client/ir.rb

@@ -0,0 +1,202 @@
+module HaveAPI::TypeScriptClient
+  class IR
+    TYPES = %w[String Text Integer Float Boolean Datetime Resource Custom].freeze
+    LAYOUTS = %w[object object_list hash hash_list].freeze
+    METHODS = %w[GET DELETE POST PUT PATCH].freeze
+
+    def self.build(snapshot)
+      new(snapshot).build
+    end
+
+    def initialize(snapshot)
+      @snapshot = Snapshot.validate(snapshot)
+      @exports = Naming::Scope.new(Naming::EXPORT_RESERVED)
+      @actions = []
+    end
+
+    def build
+      description = @snapshot.fetch('description')
+      namespace = description.dig('meta', 'namespace')
+      fail_at('invalid metadata namespace', %w[meta namespace]) unless namespace.is_a?(String) && !namespace.empty?
+      fail_at('reserved metadata namespace', %w[meta namespace]) if Naming::RESERVED.include?(namespace)
+
+      resources = walk(description.fetch('resources'), [])
+      description.fetch('authentication').sort.each do |provider, config|
+        next unless config.has_key?('resources')
+
+        # Validate separately: these API-root routes belong to the runtime's
+        # authentication implementation, outside the version-root executor.
+        self.class.new(@snapshot).send(:walk, config['resources'], ['authentication', provider], authentication: true)
+      end
+      freeze_data({
+        api_version: @snapshot.fetch('api_version'), schema_sha256: Snapshot.sha256(@snapshot),
+        metadata_namespace: namespace, resources: resources,
+        actions: @actions.sort_by { |action| action[:schema_path] }
+      })
+    end
+
+    private
+
+    def fail_at(message, path)
+      raise Error, "#{message} at #{path.join('/')}"
+    end
+
+    def walk(map, parents, authentication: false)
+      fail_at('resources must be an object', parents) unless map.is_a?(Hash)
+
+      scope = Naming::Scope.new
+      map.sort.map do |name, desc|
+        path = parents + [name]
+        fail_at('resource must be an object', path) unless desc.is_a?(Hash)
+
+        accessor = authentication && parents.length == 2 ? Naming.identifier(path.join('__')) : Naming.identifier(name)
+        scope.add(accessor, path.join('/'))
+        export = Naming.export(path)
+        @exports.add("#{export}Resource", "#{path.join('/')} (Resource)")
+        children = walk(desc.fetch('resources'), path, authentication:)
+        member_scope = Naming::Scope.new
+        children.each { |child| member_scope.add(child[:accessor_name], child[:schema_path].join('/')) }
+        action_map = desc.fetch('actions')
+        fail_at('actions must be an object', path) unless action_map.is_a?(Hash)
+
+        actions = action_map.sort.map { |action_name, action| action_record(action_name, action, path, member_scope, authentication:) }
+        { schema_path: path, export_name: export, accessor_name: accessor, children:, actions: }
+      end
+    rescue KeyError => e
+      fail_at("missing #{e.key}", parents)
+    end
+
+    def action_record(name, desc, parents, scope, authentication:)
+      path = parents + [name]
+      fail_at('action must be an object', path) unless desc.is_a?(Hash)
+      accessor = scope.add(Naming.identifier(name), path.join('/'))
+      export = Naming.export(path)
+      %w[Path Input Output GlobalInput GlobalOutput ObjectInput ObjectOutput Options].each do |suffix|
+        @exports.add("#{export}#{suffix}", "#{path.join('/')} (#{suffix})")
+      end
+      aliases = desc.fetch('aliases', [])
+      fail_at('aliases must be an array of strings', path) unless aliases.is_a?(Array) && aliases.all?(String)
+      aliases.each { |item| scope.add(Naming.identifier(item), (path + ['alias', item]).join('/')) }
+      %w[auth blocking].each do |key|
+        next unless desc.has_key?(key)
+
+        fail_at("#{key} must be boolean or null", path) unless [true, false, nil].include?(desc[key])
+      end
+      route = route(desc['path'], path, authentication:)
+      placeholders = route.scan(/\{([^}]+)\}/).flatten.uniq
+      placeholder_scope = Naming::Scope.new
+      placeholders.each { |item| placeholder_scope.add(Naming.identifier(item), (path + ['path', item]).join('/')) }
+      action = {
+        schema_path: path, export_name: export, accessor_name: accessor, aliases:, method: desc['method'],
+        path_template: route, placeholders:, auth: desc.fetch('auth', true) != false, blocking: desc['blocking'] == true,
+        input: io(desc['input'], path + ['input'], input: true), output: io(desc['output'], path + ['output'])
+      }
+      metadata = desc['meta'] || {}
+      fail_at('metadata must be an object', path + ['meta']) unless metadata.is_a?(Hash)
+      unknown = metadata.keys - %w[global object]
+      fail_at("unsupported metadata roles #{unknown.join(', ')}", path + ['meta']) unless unknown.empty?
+      %w[global object].each do |role|
+        group = metadata[role] || {}
+        fail_at('metadata role must be an object', path + ['meta', role]) unless group.is_a?(Hash)
+        %w[input output].each do |direction|
+          action[:"#{role}_#{direction}"] = io(group[direction], path + ['meta', role, direction], input: direction == 'input', metadata: true)
+        end
+      end
+      if %w[GET OPTIONS].include?(desc['method']) && action[:object_input]
+        fail_at('unsupported query object-input metadata', path + %w[meta object input])
+      end
+      fail_at('unsupported HTTP method', path) unless METHODS.include?(desc['method'])
+      namespace = @snapshot.fetch('description').fetch('meta').fetch('namespace')
+      if action[:object_input] && action[:input]&.fetch(:parameters)&.any? { |field| [field[:wire_name], field[:emitted_name]].include?(namespace) }
+        fail_at('object metadata namespace collides with input field', path + ['input', namespace])
+      end
+      if action[:object_output] && action[:output]&.fetch(:parameters)&.any? { |field| field[:wire_name] == namespace }
+        fail_at('object metadata namespace collides with output field', path + ['output', namespace])
+      end
+      @actions << action
+      action
+    end
+
+    def io(desc, path, input: false, metadata: false)
+      return nil if desc.nil? || desc == { 'parameters' => {} }
+
+      fail_at('IO must be an object', path) unless desc.is_a?(Hash)
+      fail_at('unsupported Custom IO format', path) if desc.has_key?('format')
+      fail_at('unsupported layout', path) unless LAYOUTS.include?(desc['layout'])
+      if input && desc['layout'].end_with?('_list')
+        fail_at('unsupported input list', path)
+      end
+      namespace = desc['namespace']
+      unless namespace == false || (namespace.is_a?(String) && !namespace.empty?)
+        fail_at('unsupported namespace', path)
+      end
+      fail_at('unsupported output namespace=false', path) if !input && !metadata && namespace == false
+      parameters = desc['parameters']
+      fail_at('parameters must be an object', path) unless parameters.is_a?(Hash)
+      scope = Naming::Scope.new
+      fields = parameters.sort.map { |name, parameter| parameter_record(name, parameter, path, scope) }
+      { layout: desc['layout'], namespace:, parameters: fields }
+    end
+
+    def parameter_record(name, desc, parents, scope)
+      path = parents + [name]
+      fail_at('parameter must be an object', path) unless desc.is_a?(Hash)
+      fail_at("unsupported parameter type #{desc['type'].inspect}", path) unless TYPES.include?(desc['type'])
+      %w[required nullable protected].each do |key|
+        next unless desc.has_key?(key)
+
+        fail_at("#{key} must be boolean or null", path) unless [true, false, nil].include?(desc[key])
+      end
+      validators = desc.fetch('validators', {})
+      fail_at('validators must be an object', path) unless validators.is_a?(Hash)
+      association = nil
+      if desc['type'] == 'Resource'
+        resource = desc['resource']
+        unless resource.is_a?(Array) && !resource.empty? && resource.all? { |item| item.is_a?(String) && !item.empty? } &&
+               %w[value_id value_label].all? { |key| desc[key].is_a?(String) && !desc[key].empty? }
+          fail_at('invalid resource association', path)
+        end
+        association = { resource_path: resource, value_id: desc['value_id'], value_label: desc['value_label'] }
+      end
+      {
+        wire_name: name, emitted_name: scope.add(Naming.identifier(name), path.join('/')), kind: desc['type'],
+        required: desc['required'] == true, nullable: desc['nullable'] == true, protected: desc['protected'] == true,
+        association:, validators:
+      }
+    end
+
+    def route(path, schema_path, authentication:)
+      fail_at('unsafe action path', schema_path) unless path.is_a?(String) && Snapshot.safe_path?(path)
+      mount = @snapshot.fetch('mount_path')
+      fail_at('action path escapes capture mount', schema_path) unless path.start_with?(mount)
+      relative = path.delete_prefix(mount)
+      version = "v#{@snapshot.fetch('api_version')}"
+      segments = relative.split('/', -1)
+      if segments.first == version
+        segments.shift
+      elsif !authentication
+        fail_at('action path differs from selected API version', schema_path)
+      elsif segments.first&.match?(/\Av\d+(?:\.\d+)*\z/)
+        fail_at('authentication action selects another API version', schema_path)
+      end
+      relative = segments.join('/')
+      unless !relative.empty? && relative.split('/').all? { |segment| segment.empty? || segment.match?(/\A(?:[a-zA-Z0-9_.%~-]+|\{[a-zA-Z0-9_-]+\})\z/) }
+        fail_at('unsupported action path template', schema_path)
+      end
+      "/#{relative}"
+    end
+
+    def freeze_data(value)
+      case value
+      when Hash
+        value.each do |key, item|
+          freeze_data(key)
+          freeze_data(item)
+        end
+      when Array
+        value.each { |item| freeze_data(item) }
+      end
+      value.freeze
+    end
+  end
+end

data/lib/haveapi/typescript_client/naming.rb

@@ -0,0 +1,38 @@
+module HaveAPI::TypeScriptClient
+  module Naming
+    RESERVED = %w[then constructor prototype __proto__].freeze
+    EXPORT_RESERVED = %w[createClient RequestExecutor ClientOptions JsonValue API_VERSION SCHEMA_SHA256 RequestOptions executeAction].freeze
+
+    def self.identifier(name)
+      raise Error, 'schema name must be a nonempty string' unless name.is_a?(String) && !name.empty?
+
+      value = name.gsub(/[^a-zA-Z0-9_$]/, '_')
+      value = "_#{value}" unless value.match?(/\A[a-zA-Z_$]/)
+      value
+    end
+
+    def self.export(path)
+      path.map do |name|
+        parts = name.split(/[^a-zA-Z0-9]+/).reject(&:empty?)
+        value = parts.map { |part| part[0].upcase + part[1..] }.join
+        value = "_#{value}" unless value.match?(/\A[a-zA-Z_$]/)
+        value
+      end.join('__')
+    end
+
+    class Scope
+      def initialize(reserved = RESERVED)
+        @names = reserved.to_h { |name| [name, "reserved helper #{name}"] }
+      end
+
+      def add(name, path)
+        if @names.has_key?(name)
+          raise Error, "name collision for #{name}: #{@names.fetch(name)} and #{path}"
+        end
+
+        @names[name] = path
+        name
+      end
+    end
+  end
+end

data/lib/haveapi/typescript_client/snapshot.rb

@@ -0,0 +1,32 @@
+begin
+  require 'haveapi/schema'
+rescue LoadError
+  raise HaveAPI::TypeScriptClient::Error,
+        'shared haveapi-client schema API is unavailable; prepare the component bundle from this source release'
+end
+
+module HaveAPI::TypeScriptClient
+  # Keep the generator API/error boundary while sharing one portable format.
+  module Snapshot
+    unless defined?(HaveAPI::Schema::Snapshot) && HaveAPI::Schema.respond_to?(:source_identity)
+      raise Error, 'loaded haveapi-client does not provide the required shared schema API'
+    end
+
+    KEYS = HaveAPI::Schema::Snapshot::KEYS
+    PROSE = HaveAPI::Schema::Snapshot::PROSE
+
+    %i[canonical canonical_value sha256 load validate sanitize from_description from_envelope version! endpoint! safe_path? safe_segments? child_context sanitization_context machine_endpoint! validate_machine_endpoint validate_machine_endpoints].each do |name|
+      define_singleton_method(name) do |*args, **kwargs, &block|
+        HaveAPI::Schema::Snapshot.public_send(name, *args, **kwargs, &block)
+      rescue HaveAPI::Schema::Error => e
+        raise Error, e.message
+      end
+    end
+
+    def self.fetch(**)
+      HaveAPI::Schema::Capture.fetch(**)
+    rescue HaveAPI::Schema::Error => e
+      raise Error, e.message
+    end
+  end
+end

data/lib/haveapi/typescript_client/version.rb

@@ -0,0 +1,5 @@
+module HaveAPI
+  module TypeScriptClient
+    VERSION = '0.31.0'.freeze
+  end
+end

data/lib/haveapi/typescript_client.rb

@@ -0,0 +1,12 @@
+require_relative 'typescript_client/version'
+
+module HaveAPI
+  module TypeScriptClient
+    class Error < StandardError; end
+  end
+end
+
+require_relative 'typescript_client/snapshot'
+require_relative 'typescript_client/naming'
+require_relative 'typescript_client/ir'
+require_relative 'typescript_client/generator'

data/template/action.ts.erb

@@ -0,0 +1,13 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+import type {RequestSpec, RequestResult} from <%= literal(@runtime_import) %>;
+import {executeAction} from <%= literal(relative_import('runtime.ts')) %>;
+import type {JsonValue, RequestExecutor} from <%= literal(relative_import('runtime.ts')) %>;
+
+<%= action_declarations(@record) %>
+
+const descriptor = <%= literal(action_definition(@record)) %> as const;
+
+/** Internal operation binding; public callers use createClient. */
+export function createAction(execute: RequestExecutor): (options<%= '?' unless options_required?(@record) %>: <%= action_type(@record, 'Options') %>) => Promise<RequestResult<<%= action_type(@record, 'Output') %>>> {
+  return (options: <%= action_type(@record, 'Options') %><%= ' = {}' unless options_required?(@record) %>) => executeAction<<%= action_type(@record, 'Output') %>>(execute, descriptor, options);
+}

data/template/api.ts.erb

@@ -0,0 +1,28 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+import type {ClientOptions} from './runtime.js';
+<% @ir.fetch(:resources).each_with_index do |resource, index| -%>
+import {createResource as resource<%= index %>} from <%= literal(relative_import(@resource_paths.fetch(resource.fetch(:schema_path)))) %>;
+import type {<%= resource.fetch(:export_name) %>Resource} from <%= literal(relative_import(@resource_paths.fetch(resource.fetch(:schema_path)))) %>;
+<% end -%>
+export type * from './types.js';
+
+export const API_VERSION = <%= literal(@ir.fetch(:api_version)) %>;
+export const SCHEMA_SHA256 = <%= literal(@ir.fetch(:schema_sha256)) %>;
+
+/**
+ * Bind to an executor already targeting the selected API version, for example
+ * spec => asyncClient.request(spec) with base https://host/mount/vVERSION.
+ * Generated output types do not validate response application fields at runtime.
+ * Authentication and completion remain with the consumer's HaveAPI runtime.
+ */
+export function createClient({execute}: ClientOptions): {
+<% @ir.fetch(:resources).each do |resource| -%>
+  readonly <%= literal(resource.fetch(:accessor_name)) %>: <%= resource.fetch(:export_name) %>Resource;
+<% end -%>
+} {
+  return {
+<% @ir.fetch(:resources).each_with_index do |resource, index| -%>
+    <%= literal(resource.fetch(:accessor_name)) %>: resource<%= index %>(execute),
+<% end -%>
+  };
+}

data/template/index.ts.erb

@@ -0,0 +1,3 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+export * from './api.js';
+export type {ClientOptions, JsonValue, RequestExecutor} from './runtime.js';

data/template/resource.ts.erb

@@ -0,0 +1,30 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+import type {RequestResult} from <%= literal(@runtime_import) %>;
+import type {RequestExecutor} from <%= literal(relative_import('runtime.ts')) %>;
+<% @record.fetch(:children).each_with_index do |child, index| -%>
+import {createResource as child<%= index %>} from <%= literal(relative_import(@resource_paths.fetch(child.fetch(:schema_path)))) %>;
+import type {<%= child.fetch(:export_name) %>Resource} from <%= literal(relative_import(@resource_paths.fetch(child.fetch(:schema_path)))) %>;
+<% end -%>
+<% @record.fetch(:actions).each_with_index do |action, index| -%>
+import {createAction as bind<%= index %>} from <%= literal(relative_import(@action_paths.fetch(action.fetch(:schema_path)))) %>;
+import type {<%= action_type(action, 'Options') %>, <%= action_type(action, 'Output') %>} from <%= literal(relative_import(@action_paths.fetch(action.fetch(:schema_path)))) %>;
+<% end -%>
+
+<%= resource_declaration(@record) %>
+
+/** Internal resource composition; public callers use createClient. */
+export function createResource(execute: RequestExecutor): <%= @record.fetch(:export_name) %>Resource {
+<% @record.fetch(:actions).each_with_index do |_action, index| -%>
+  const action<%= index %> = bind<%= index %>(execute);
+<% end -%>
+  return {
+<% @record.fetch(:children).each_with_index do |child, index| -%>
+    <%= literal(child.fetch(:accessor_name)) %>: child<%= index %>(execute),
+<% end -%>
+<% @record.fetch(:actions).each_with_index do |action, index| -%>
+<% action_names(action).each do |name| -%>
+    <%= literal(name) %>: action<%= index %>,
+<% end -%>
+<% end -%>
+  };
+}