re: recursive type expansion

[refactorized]

Hi again,

I was trying to implement types using the reference expanding utility type you provided yesterday (thanks again) here:
#175 (comment)

But when I apply it to a type that comes out of the codegen, I just get the same type back. It seems that I have to union the type from the codegen with Record<string, unknown> to get the type to resolve correctly. Otherwise the last conditional fails, and I just get the type back.

type ResolvedSanityReferences<T> =
  // match `SanityKeyedReference` and unwrap via `infer U`
  T extends SanityKeyedReference<infer U>
    ? U
    : // match `SanityReference` and unwrap via `infer U`
    T extends SanityReference<infer U>
    ? U
    : // match arrays, unwrap with `T[number]`,
    // recursively run through `ResolvedSanityReferences`
    // then re-wrap in an another array
    T extends any[]
    ? Array<ResolvedSanityReferences<T[number]>>
    : // match objects, then utilize map types to
    // recursively run children through `ResolvedSanityReferences`
    T extends Record<string, unknown>
    ? {[P in keyof T]: ResolvedSanityReferences<T[P]>} // <-------------------- not matching
    : T;

I'm not sure why this doesn't work. As far as I can tell, the generated type should fulfill Record<string, unknown> but I am a little unsure about how unknown gets treated in type math. The following is what my code looks like now, and it works, but do you know any way I can use it without unioning the generated type?

import type {TextAndImageBlock} from '@schema/types';
import type {ResolvedSanityReferences} from '@data/types';

type TextAndImageBlockData = ResolvedSanityReferences<
  TextAndImageBlock & Record<string, unknown>
>;

const test = (a: TextAndImageBlockData) => {
  let b = a.desktopImage.asset.assetId;  // <----------- asset is properly de-referenced here
};

export default TextAndImageBlockData;

[ricokahler]

could you provide the generated types along with the use case that doesn't work? I can better help debug then

[ricokahler]

so i tried always using the mapped type (instead of matching conditionally on Record<string, unknown>` and i think that works

see here

here's the updated type

type ResolvedSanityReferences<T> =
    // match `SanityKeyedReference` and unwrap via `infer U`
    T extends SanityKeyedReference<infer U>
    ? U

    // match `SanityReference` and unwrap via `infer U`
    : T extends SanityReference<infer U>
    ? U

    // match arrays, unwrap with `T[number]`,
    // recursively run through `ResolvedSanityReferences`
    // then re-wrap in an another array
    : T extends any[]
    ? Array<ResolvedSanityReferences<T[number]>>

    // finally utilize mapped types to
    // recursively run children through `ResolvedSanityReferences`
    : { [P in keyof T]: ResolvedSanityReferences<T[P]> }

[refactorized]

Yep! That works. Makes sense since my union was making that last clause tautological anyways. Thanks a bunch!

[refactorized]

Future iteration of this stack will likely involve more verbose groq queries which explicitly expand references using select and project logic, and lean on 1.0+ versions of sanity-codegen with its query based generation. I will be watching this repo closely.

[nahtnam]

Hello! Sorry to bring up an old thread, but I noticed that this breaks when you have an array of references and inside that you have an array of references. I tried to play around with the type but I couldn't figure it out

Here is a reproduction. Keep an eye on the broken and Broken values

Do either of you have any idea?

cc @ricokahler

[nahtnam]

This is the solution i came up with:

type ResolvedSanityReferences<T> =
    // match `SanityKeyedReference` and unwrap via `infer U`
    T extends SanityKeyedReference<infer U>
    ? ResolvedSanityReferences<U>

    // match `SanityReference` and unwrap via `infer U`
    : T extends SanityReference<infer U>
    ? ResolvedSanityReferences<U>

    // match arrays, unwrap with `T[number]`,
    // recursively run through `ResolvedSanityReferences`
    // then re-wrap in an another array
    : T extends any[]
    ? Array<ResolvedSanityReferences<T[number]>>

    // finally utilize mapped types to
    // recursively run children through `ResolvedSanityReferences`
    : { [P in keyof T]: ResolvedSanityReferences<T[P]> }

Simply added ResolvedSanityReferences around the first two cases as well. That makes it recursive on the inner references as well