Extending base schemas with strict in-union matching as an alternative strategy for nested (discriminated) unions?

[TyIsI]

Sorry for the ten thousandth post on this, but in the process of getting myself acquainted with the concepts and how zod implements this.

After having seen and read the various issues/discussions/pull requests, I wasn't sure if I should add my comments to the open issue (#3407), so I opted to post it here for discussion.
My gut feeling is most of the existing issues could be served by being able to match on multiple (optional) keys, but as I'm not familiar enough with zod, I am not sure if that's a viable strategy to implement and I did not want to add to the noise on that particular open issue.

In the mean time, considering that unions are evaluated in order, I'm pursuing this strategy and I wanted to get some opinions on this.

For a common type with and optional mutually exclusive index (either readwrite or rw is to be used optionally but not concurrently), I'm testing the following:

interface MountBindCommon {
    type: 'bind'
    source: string
    target: string
    from?: string
}

interface MountBindReadWrite extends MountBindCommon {
    readwrite: boolean
}

interface MountBindRW extends MountBindCommon {
    rw: boolean
}

type MountBind = MountBindCommon | MountBindReadWrite | MountBindRW

const zMountBindCommon = z.object({
    type: z.literal('bind'),
    source: z.string(),
    target: z.string(),
    from: z.string().optional()
})

const zMountBindReadWrite = zMountBindCommon.extend({
    readwrite: z.boolean()
})

const zMountBindRW = zMountBindCommon.extend({
    rw: z.boolean()
})

const zMountBind = z.union([zMountBindReadWrite.strict(), zMountBindRW.strict(), zMountBindCommon.strict()])

const zMountCache = z.object({ type: z.literal('cache') })

// ... define other schema types

const zMountOpts = z.union([
    zMountBindReadWrite.strict(),
    zMountBindRW.strict(),
    zMountBindCommon.strict(),
    zMountCache.strict()
])

And for the following test data and linked Jest tests, it holds up.

const tests: Record<string, MountBind | object> = {}

tests.common = { type: 'bind', source: '/source', target: '/target' } // Pass on zMountBindCommon

tests.rw1 = { ...tests.common, rw: false } // 
tests.rw2 = { ...tests.common, rw: true }

tests.readwrite1 = { ...tests.common, readwrite: false }
tests.readwrite2 = { ...tests.common, readwrite: true }

tests.collision1 = { ...tests.common, rw: false, readwrite: false } // Fail always
tests.collision2 = { ...tests.common, rw: true, readwrite: true } // Fail always
tests.collision3 = { ...tests.common, rw: false, readwrite: true } // Fail always
tests.collision4 = { ...tests.common, rw: true, readwrite: false } // Fail always

tests.cache = { type: 'cache' } // Fail when not zMountCache

tests.invalid = { type: 'invalid' } // Fail always

Results from testing :

Test Suites: 1 passed, 1 total
Tests:       66 passed, 66 total

Full code in gist:
https://gist.github.com/TyIsI/a05bae503144028bc6fc44f573917018

Immediate caveats that come to mind are:

• situations where there are optional fields/props (but I think that could be solved with picks over refine?)
• ensuring ordering (could this be solved through optimization of the arguments to union as a method at invocation time? - as opposed to parsing time)

This at least solves my issue in the short term (and I can take the performance penalty for this particular use-case).
I figured I would post this for feedback.

[TyIsI]

Also, if I'm talking out my wrong end, please kindly let me know.