Method constructor

sdk/typescript/src/module/executor.ts:146–244

(
    private readonly executor: Executor,
    private readonly module: DaggerModule,
    private readonly ifaceName: string,
    private readonly ifaceId: string,
    private readonly fcts: DaggerInterfaceFunctions,
  )

  private _ctx: Context

  constructor(
    private readonly executor: Executor,
    private readonly module: DaggerModule,
    private readonly ifaceName: string,
    private readonly ifaceId: string,
    private readonly fcts: DaggerInterfaceFunctions,
  ) {
    this._ctx = new Context([], new Connection(dag.getGQLClient()))

    // Load the interface by its identifier via node(id:)
    this._ctx = this._ctx.selectNode(ifaceId, ifaceName)

    Object.entries(fcts).forEach(([name, fct]) => {
      const argKeys = Object.keys(fct.arguments)

      // Dynamically adding functions of the interface and it's resolvers.
      // @ts-ignore
      this[name] = async (...args: any[]) => {
        // Fill up arguments of that function.
        const argsPayload = {}
        for (let i = 0; i < argKeys.length; i++) {
          if (args[i] !== undefined) {
            // @ts-ignore
            argsPayload[argKeys[i]] = args[i]
          }
        }

        this._ctx = this._ctx.select(name, argsPayload)

        // If the function is returning an IDable, we don't need to execute it
        // since it will be resolved later.
        if (
          fct.returnType!.kind === TypeDefKind.InterfaceKind ||
          fct.returnType!.kind === TypeDefKind.ObjectKind
        ) {
          return this
        }

        // If the function is returning a list, we may need to load the sub-objects
        if (fct.returnType!.kind === TypeDefKind.ListKind) {
          const listTypeDef = (fct.returnType as TypeDef<TypeDefKind.ListKind>)
            .typeDef

          // If the list is an object or an interface, then we need to load the sub-objects.
          if (
            listTypeDef.kind === TypeDefKind.ObjectKind ||
            listTypeDef.kind === TypeDefKind.InterfaceKind
          ) {
            const typedef = listTypeDef as
              | TypeDef<TypeDefKind.ObjectKind>
              | TypeDef<TypeDefKind.InterfaceKind>

            // Resolves the call to get the list of IDs to load
            const ids = await this._ctx
              .select("id")
              .execute<Array<{ id: string }>>()

            // If the return type is an interface defined by that module, we need to load it through