Infer "out" type after morph in scope entry

[maurice]

Hi all,

I'm starting to need to do a little more than just the basics with arktype, eg, going from validation-only to transforming input to something simpler to deal with.

Specifically in my case I'm using arktype in the GUI to validate incoming messages from the server.

Our protocol is such that at startup the server sends a bunch of "complete" records and thereafter only sends deltas (just the changed fields).

The twist is that some of the fields in the "complete" record are optional. So naturally I'm modelling these with 'foo?': 'string' (for example) in arktype.

In order to "unset" an optional field in a delta message the server will send a null for that field. This is where I start getting into trouble, eg TS correctly complains about this

import { scope } from 'arktype';

export const types = scope({
  RecordType: '"A"|"B"|"C"',
  Record: {
    'id': 'string',
    'name': 'string',
    'type?': 'RecordType',
  },
  RecordDelta: {
    'id': 'string',
    'name?': 'string', // type is string because it's required in Record, so if present it must be a string
    'type?': 'RecordType | null', // type is nullable because it's optional in Record, so it can be "unset" via null
  },
}).export()

/*
type Record = {
    id: string;
    name: string;
    type?: "A" | "B" | "C";
}
*/
type Record = typeof types.Record.infer;

/*
type RecordDelta = {
    id: string;
    name?: string;
    type?: "A" | "B" | "C" | null;
}
*/
type RecordDelta = typeof types.RecordDelta.infer;

const r1: Record = { id: 'abc', name: 'Foo', type: 'A' };
const r2: RecordDelta = { id: 'abc', type: null };

const r3: Record = { ...r1, ...r2 }; // Types of property 'type' are incompatible. -> Type '"A" | "B" | "C" | null' is not assignable to type '"A" | "B" | "C"'.

I noticed the morph syntax in the docs so though I might use that but I'm having some issues

import { type, scope, ArkErrors } from 'arktype';

export const types = scope({
  RecordType: '"A"|"B"|"C"',
  Record: {
    'id': 'string',
    'name': 'string',
    'type?': 'RecordType',
  },
  RecordDelta: {
    'id': 'string',
    'name?': 'string',
    'type?': ['RecordType | null', '=>', (value) => value ?? undefined],
  },
}).export()

/*
type Record = {
    id: string;
    name: string;
    type?: "A" | "B" | "C";
}
*/
type Record = typeof types.Record.infer;

/*
type RecordDelta = {
    id: string;
    name?: string;
    type?: (In: "A" | "B" | "C" | null) => Out<"A" | "B" | "C" | undefined>;
}
*/
type RecordDelta = typeof types.RecordDelta.infer;

const r1: Record = { id: 'abc', name: 'Foo', type: 'A' };
const r2 = types.RecordDelta({ id: 'abc', type: null });

if (!(r2 instanceof ArkErrors)) {
  // Types of property 'type' are incompatible. -> Type '"A" | "B" | "C" | ((In: "A" | "B" | "C" | null) => Out<"A" | "B" | "C" | undefined>)' is not assignable to type '"A" | "B" | "C"'.
  const r3: Record = { ...r1, ...r2 };

/*
r3 {
  id: "abc",
  name: "Foo",
  type: undefined,
} 
*/
  console.log('r3', r3);
}

The morph is doing what I want at runtime (see console log at the end), but at compile-time typeof types.RecordDelta.infer seems to produce an "input" type rather than the valid output type I would expect. That means I get a TypeScript error when trying to spread it into another Record value.

Am I doing something wrong here?

A follow-on question I would have is that there are lot of optional fields in my real types and I'd rather not copy-paste the same (pure) boilerplate morph function for every one. Is there some way I can extract and make it generic over the input value, given that the input value's type is defined within the arktype scope?

[ssalbdivad]

The problem is that the morph can return the value undefined as a value if the input is null.

There is a difference in JS between a key being present with the value undefined and not present at all.

The tsconfig setting exactOptionalPropertyTypes enforces this difference, and you seem to have it enabled. I prefer using it, but if you're not invested and you know undefined is safe as an explicit value, you could remove that setting and the error will go away.

The more precise option is unfortunately that you need to morph the top-level object top check for null and prune the key accordingly so it will never explicitly have the value undefined. The morph at that point isn't on the value itself- it's the key holding it.

It may be possible to create a convenience syntax for this where returning some builtin symbol like prune would indicate to remove the key currently being morphed. If you feel like that would be very helpful, please open an issue! It should be relatively approachable, with the inference and potential type perf overhead being my main concerns.