Is converting values in the scope of this library ? about runtypes HOT 14 OPEN

const Apple = Record({
	color: Union(Literal('red'), Literal('green'), Literal('yellow'), // 'red' | 'green' | 'yellow'
	seeds: String.withConverter(x => Number.parseFloat(x)), // number
})

/**
 * Explore the Runtypes reflection to find a type brand.
 * @param reflect type info to search for brand string in.
 * @returns brand string if found, otherwise, null.
 */
export function findTypeBrands(reflect: rt.Reflect): string[] | undefined {
  switch (reflect.tag) {
    case 'brand':
      return [reflect.brand];

    case 'optional':
      return findTypeBrands(reflect.underlying);

    case 'union': {
      const brands = reflect.alternatives
        .map((alt) => findTypeBrands(alt.reflect))
        .flat()
        .filter((val) => !!val) as string[];
      return brands.length > 0 ? brands : undefined;
    }

    case 'intersect': {
      const brands = reflect.intersectees
        .map((entry) => findTypeBrands(entry.reflect))
        .flat()
        .filter((val) => !!val) as string[];
      return brands.length > 0 ? brands : undefined;
    }

    case 'constraint':
      return findTypeBrands(reflect.underlying);

    default:
      return undefined;
  }
}

/**
 * Gets the array's element type from reflection, or undefined if not an array.
 * @param reflect array type to confirm that the type is an array.
 * @returns Array's element type or undefined if not an array.
 */
export function getArrayElementType(reflect: rt.Reflect): rt.Reflect | undefined {
  switch (reflect.tag) {
    case 'brand':
      return getArrayElementType(reflect.entity);

    case 'optional':
      return getArrayElementType(reflect.underlying);

    case 'union':
      // Only dig deeper if this is a nullable union.
      if (reflect.alternatives.length === 2 && reflect.alternatives[1] === rt.Null) {
        return getArrayElementType(reflect.alternatives[0].reflect);
      }
      return undefined;

    case 'constraint':
      return getArrayElementType(reflect.underlying);

    case 'array':
      return reflect.element;
  }
  return undefined;
}

/**
 * Gets the tuple's component types from reflection, or undefined if not a tuple.
 * @param reflect tuple type to confirm that the type is a tuple.
 * @returns Tuple's component types or undefined if not a tuple.
 */
export function getTupleComponentTypes(reflect: rt.Reflect): rt.Reflect[] | undefined {
  switch (reflect.tag) {
    case 'brand':
      return getTupleComponentTypes(reflect.entity);

    case 'optional':
      return getTupleComponentTypes(reflect.underlying);

    case 'union':
      // Only dig deeper if this in a nullable union.
      if (reflect.alternatives.length === 2 && reflect.alternatives[1] === rt.Null) {
        return getTupleComponentTypes(reflect.alternatives[0].reflect);
      }
      return undefined;

    case 'constraint':
      return getTupleComponentTypes(reflect.underlying);

    case 'tuple':
      return reflect.components;
  }
  return undefined;
}

/**
 * Gets the record's type from reflection, or undefined if not a record.
 * @param reflect record type to confirm that the type is a record.
 * @returns record type or undefined if not a record.
 */
export function getRecordType(reflect: rt.Reflect): (rt.Reflect & { tag: 'record' }) | undefined {
  switch (reflect.tag) {
    case 'brand':
      return getRecordType(reflect.entity);

    case 'optional':
      return getRecordType(reflect.underlying);

    case 'union':
      // Only dig deeper if this in a nullable union.
      if (reflect.alternatives.length === 2 && reflect.alternatives[1] === rt.Null) {
        return getRecordType(reflect.alternatives[0].reflect);
      }
      return undefined;

    case 'constraint':
      return getRecordType(reflect.underlying);

    case 'record':
      return reflect;
  }
  return undefined;
}

/**
 * Gets the insersectee types from reflection, or undefined if not an intersection.
 * @param reflect intersection type to confirm that the type is an intersection.
 * @returns intersectee types or undefined if not an intersection.
 */
export function getIntersecteeTypes(reflect: rt.Reflect): rt.Reflect[] | undefined {
  switch (reflect.tag) {
    case 'brand':
      return getIntersecteeTypes(reflect.entity);

    case 'optional':
      return getIntersecteeTypes(reflect.underlying);

    case 'union':
      // Only dig deeper if this in a nullable union.
      if (reflect.alternatives.length === 2 && reflect.alternatives[1] === rt.Null) {
        return getIntersecteeTypes(reflect.alternatives[0].reflect);
      }
      return undefined;

    case 'constraint':
      return getIntersecteeTypes(reflect.underlying);

    case 'intersect':
      return reflect.intersectees;
  }
  return undefined;
}

/**
 * Runtype type converter storage.
 */
const typeConverters: Record<
  string,
  {
    type: RuntypeBase<unknown>;
    convert: (data: unknown) => unknown;
  }
> = {};

/**
 * Register a runtype with a conversion function. (Must have a brand associated)
 * @param type Type to register for conversion.
 * @param converter Conversion function from untyped to typed.
 */
export function registerTypeConverter(type: RuntypeBase<unknown>, converter: (data: unknown) => unknown) {
  const brands = findTypeBrands(type.reflect);
  if (!brands) {
    throw new Error('Type must have a brand to be registered as a type converter');
  }

  const foundBrand = Object.keys(typeConverters).find((brand) => brands.includes(brand));
  if (foundBrand) {
    throw new Error(`A Type converter was already registered for this type: ${foundBrand}`);
  }

  for (const brand of brands) {
    typeConverters[brand] = {
      type,
      convert: converter,
    };
  }
}

/**
 * Parses a runtype, allowing for type conversions.
 * @param type RunType to parse.
 * @param data Data to parse to RunType
 * @param options Conversion options: {
 *  stripUnknown: "Removes fields that aren't on the type.",
 *  check: "Apply runtype check? Turn to false if you need a higher check, e.g. parsing deep records."
 * }
 * @returns Parsed RunType
 */
export function parseType<T extends RuntypeBase<unknown>>(
  type: T,
  data: unknown,
  { stripUnknown = true, check = true }: { stripUnknown?: boolean; check?: boolean } = {},
): rt.Static<RuntypeBase<T extends RuntypeBase<infer R> ? R : never>> {
  let value = data;

  // Ignore type warnings, used for chaining. Return value if type information couldn't be found.
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  if (!type) return value as any;

  const brands = findTypeBrands(type.reflect);
  if (brands) {
    for (const brand of brands) {
      const typeConvertInfo = typeConverters[brand];
      if (typeConvertInfo) {
        value = typeConvertInfo.convert(value);
      }
    }
  } else if (Array.isArray(value)) {
    const arrayElementType = getArrayElementType(type.reflect);
    const tupleTypes = getTupleComponentTypes(type.reflect);

    if (arrayElementType) {
      value = value.map((element) => parseType(arrayElementType, element, { check: false, stripUnknown }));
    } else if (tupleTypes) {
      value = value.map((element, index) => parseType(tupleTypes[index], element, { check: false, stripUnknown }));
    }
  } else if (value !== null && value !== undefined && typeof value === 'object') {
    const recordType = getRecordType(type.reflect);
    const intersecteeTypes = getIntersecteeTypes(type.reflect);

    // Handle intersections of types.
    if (intersecteeTypes) {
      const intersectResults: Record<string, unknown>[] = [];
      for (const intersecteeType of intersecteeTypes) {
        intersectResults.push(
          parseType(intersecteeType, value, { check: false, stripUnknown }) as Record<string, unknown>,
        );
      }
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      value = (_.merge as any)(...intersectResults);
    } else if (recordType) {
      const data = value as Record<string, unknown>;
      const dataKeys = Object.keys(data);
      const record: Record<string, unknown> = stripUnknown ? {} : data;

      for (const [field, fieldType] of Object.entries(recordType.fields)) {
        if (stripUnknown && !dataKeys.includes(field)) continue;
        record[field] = parseType(fieldType as RuntypeBase<unknown>, data[field], { check: false, stripUnknown });
      }

      value = record;
    }
  }

  // We essentially have done everything, if check is false,
  // then we essentially have "casted" the value.
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  return (check ? type.check(value) : value) as any;
}

export const DateString = rt.String.withBrand('DateString').withConstraint((str) => {
  const dateObj = DateTime.fromISO(str);
  return dateObj.isValid || dateObj.invalidExplanation || `The date was not a valid ISO string: ${str}`;
});
export type DateString = rt.Static<typeof DateString>;

export const DateType = rt.InstanceOf(Date).withBrand('Date');
export type DateType = rt.Static<typeof DateType>;

registerTypeConverter(DateType, (value) => {
  if (typeof value === 'string') {
    value = new Date(DateString.check(value));
  }
  return value;
});

const nullableDateType = DateType.nullable().optional();

describe('parseType()', () => {
  const testType = rt.Record({
    date: nullableDateType,
  });

  it('converts values in a record type', () => {
    const source = {
      date: '2022-01-18T23:03:16.328Z',
    };

    expect(parseType(testType, source)).toEqual({
      date: new Date(source.date),
    });
  });
});

const TrimmedString = String.withTransform(value => value.trim(), { name: 'TrimmedString' });
TrimmedString.check(' foo bar ');
// => 'foo bar'

const AlreadyTrimmedString = String.withConstraint(
  value =>
    value.trim() === value || `Expected the string to be trimmed, but this one has whitespace`,
);

const TrimmedString = String.withConstraint(x => x.trim() === value)
TrimmedString.parse(' foo bar ') // throws error
TrimmedString.safeParse(' foo bar ') // returns error (IIRC, I never use this one so I forget how it surfaces errors exactly)

const TrimmedString = String.withConstraint(x => x.trim() === value)
TrimmedString.check(' foo bar ') // throws error
TrimmedString.validate(' foo bar ') // returns error

AlreadyTrimmedString.check(' foo bar ') // throws error
AlreadyTrimmedString.validate(' foo bar ') // returns error