Nested morph with union of object : T | T[ ] => T[]

[Baben01]

Issue: Handling morph operations on data that can be either an object or array

Problem Description

I'm attempting to perform a morph operation on data that can be either an object (T) or an array (T[]) while applying all nested morphs declared on the object. I'm encountering an error when trying to handle this case.

Code Example

// This is the object, that can have nested properties with specific morphs
const myData = type({
  'bool': type('string').pipe(v => v === 'true'),
})

const toArray = <T>(data: T | T[]) => Array.isArray(data) ? data : [data]

const myType = type({
  'props?': "string",
  'objectArray?': type(myData, '=>', v => toArray(v)).or([type(myData.array()), "=>", v => toArray(v)])
})

Error

When running this code, I receive the following error:

ParseError: An unordered union of a type including a morph and a type with overlapping input is indeterminate:
Left: (In: { bool: string }) => Out<unknown>
Right: (In: { bool: string }[]) => Out<unknown>

Context

I've searched for solutions in the documentation, issues, and Discord. I understand the error is caused by using a union type with overlapping rules as explained in the union documentation.

This pattern is necessary for my use case because my XML parser returns either an object or a list depending on the number of elements. It also returns booleans as strings that need to be converted to actual boolean values.

Question

How can I properly handle this kind of transformation while avoiding the overlapping input error?

[ssalbdivad]

If you reference the same morph directly, it's safe:

const myType = type({
	"props?": "string",
	"objectArray?": type(myData, "=>", toArray).or([
		type(myData.array()),
		"=>",
		toArray
	])
})

Referencing a morph directly (as opposed to wrapping in another anonymous arrow function) allows introspection to determine the types are equivalent.

There's actually a builtin Array.liftFrom keyword for this:

const myType = type({
	"props?": "string",
	"objectArray?": type.keywords.Array.liftFrom(myData)
})

Unfortunately, it runs into the same issue you mentioned.

I've created an issue to track identifying that case as safe from Array.liftFrom:

#1375

[Baben01]

Thanks a lot for the quick reply. I had some issue when using type(myData, "=>", toArray) because the result type was infered as unknown[]. I did some test and discover that when I use a morph function with generic, the generic is not infered, unless I use a new anonymous arrow function.

My solution was to specify the type when using my toArray function in the morph and I finally make it work. I put my solution here.

import { type } from 'arktype'

const toArray = <T>(data: T | T[]): Array<T> => {
  return (Array.isArray(data) ? data : [data])
}

const nested = type({
  'isOk': type('string').pipe(v => v === 'true'),
})

const myData = type({
  'bool': type('string').pipe(v => v === 'true'),
  'other?': nested.pipe(toArray<typeof nested.infer>, nested.array()).or(type(nested.array()).pipe(toArray<typeof nested.infer>, nested.array()))
})

const myType = type({
  'props?': type("string").pipe(v => v === 'true'),
  "objectArray?": myData.pipe(toArray<typeof myData.infer>, myData.array()).or(type(myData.array()).pipe(toArray<typeof myData.infer>, myData.array()))
})

// type MyTypeInfer = {
//   props?: boolean | undefined;
//   objectArray?: {
//       bool: boolean;
//       other?: {
//           isOk: boolean;
//       }[] | undefined;
//   }[] | undefined;
// }
type MyTypeInfer = typeof myType.infer


const testMyData2 = {
  'props': 'false',
  'objectArray': [{ 'bool': 'true', other: { isOk: 'true' } }, { 'bool': 'false', other: [{ isOk: 'true' }, { isOk: 'false'}] }]
}
const t2 = myType(testMyData2)
console.log(JSON.stringify(t2, null, 2))
// OUTPUT:
// {
//   "props": false,
//   "objectArray": [
//     {
//       "bool": true,
//       "other": [
//         {
//           "isOk": true
//         }
//       ]
//     },
//     {
//       "bool": false,
//       "other": [
//         {
//           "isOk": true
//         },
//         {
//           "isOk": false
//         }
//       ]
//     }
//   ]
// }
  
const testMyData3 = {
  'props': 'false',
  'objectArray': { 'bool': 'true', other: { isOk: 'true' } }
}
const t3 = myType(testMyData3)
console.log(JSON.stringify(t3, null, 2))
// OUTPUT:
// {
//   "props": false,
//   "objectArray": [
//     {
//       "bool": true,
//       "other": [
//         {
//           "isOk": true
//         }
//       ]
//     }
//   ]
// }