Conditional dereferencing of elements

[mrr11k]

Hi,

I have an array of objects and references where I need to deref the references only. I modified the pokemon playground and changed one of types references to an object here.

Of course dereferencing the whole types[] field doesn't work, because it also tries to deref a non-reference.
So I would like to deref based on the type. Is something like this somehow possible?

runQuery(
  q.star
  .filterByType("pokemon")
  .slice(0, 8)
  .project(sub => ({
    name: z.string(),
    attack: sub.field("base.Attack", z.number()),
    types: sub.field("types[]").project(sub => ({
      ...sub.conditionalByType({
        reference: {
          '...': sub.deref(),
        },
        MyType: {
          '...': true,
        },
      }),
    })),
  }))
);

Here is the raw GROQ query I would like to build with Groqd:

*[_type == pokemon]{
  "types": types[]{
    _type == 'reference' => @->{
      ...,
    },
    _type != 'reference' => @
  },
}

[scottrippey]

With the current API, the best way I can think to do this is to use the selectByType function::

  q.star.filterByType("test").project(sub => ({
    items: sub.field("items[]")
		.project(item => ({
          // Project to a temporary object:
	      selected: item.selectByType(
            {
    	      reference: (item) => item.raw("@").deref(),
	        }, item.raw("@")
          )
    })).field("selected") // and unwrap the object
  }))

But I'm eager to think of a better way to handle this...

[scottrippey]

I see 2 issues standing in the way:

1. We don't have a strongly-typed version of the "self" operator @. This could be added like sub.self.
2. Currently, the conditionalByType method only supports a "projection object" for each result (like reference: { ... }). This could be expanded to support a query instead, like reference: (sub) => sub.self.deref()

So the proposed syntax would be:

    types: sub.field("types[]").project(sub => ({
      ...sub.conditionalByType({
        reference: sub => sub.self.deref(),
        MyType: sub => sub.self,
      }),
    })),

[mrr11k]

With the current API, the best way I can think to do this is to use the selectByType function::

  q.star.filterByType("test").project(sub => ({
    items: sub.field("items[]")
		.project(item => ({
          // Project to a temporary object:
	      selected: item.selectByType(
            {
    	      reference: (item) => item.raw("@").deref(),
	        }, item.raw("@")
          )
    })).field("selected") // and unwrap the object
  }))

But I'm eager to think of a better way to handle this...

That looks decently. :)
I solved it for now by using .raw for the whole of types.

      types: q.raw(`types[]{
        _type ==
        "reference" => @->{
          ...,
        },
        _type != "reference" => @
      }`)

[scottrippey]

Yep that's a good workaround too. Exactly what raw was made for.

[scottrippey]

This is officially supported now! With #378 and #376 .

You can do the following: Link to arcade

  q.star
   .filterByType("pokemon")
   .project(q => ({
     name: z.string(),
     types: q.field("types[]").project(q => ({
       ...q.conditionalByType({
         reference: q => q.field("@").deref(),
         link: q => q.field("@"),
       }),
     })),
   }))

Notice the q.field("@") syntax, which is strongly-typed!

[mrr11k]

Yes, i saw it. Awesome work, thanks! 🙌