export function serializationType()

in packages/@jsii/kernel/src/serialization.ts [890:956]
59 lines of code
17 McCabe index (conditional complexity)

export function serializationType(
  typeRef: OptionalValueOrVoid,
  lookup: LookupType,
): TypeSerialization[] {
  assert(
    typeRef != null,
    `Kernel error: expected type information, got ${inspect(typeRef)}`,
  );

  if (typeRef === 'void') {
    return [{ serializationClass: SerializationClass.Void, typeRef }];
  }
  if (spec.isPrimitiveTypeReference(typeRef.type)) {
    switch (typeRef.type.primitive) {
      case spec.PrimitiveType.Any:
        return [{ serializationClass: SerializationClass.Any, typeRef }];
      case spec.PrimitiveType.Date:
        return [{ serializationClass: SerializationClass.Date, typeRef }];
      case spec.PrimitiveType.Json:
        return [{ serializationClass: SerializationClass.Json, typeRef }];
      case spec.PrimitiveType.Boolean:
      case spec.PrimitiveType.Number:
      case spec.PrimitiveType.String:
        return [{ serializationClass: SerializationClass.Scalar, typeRef }];
    }

    assert(false, `Unknown primitive type: ${inspect(typeRef.type)}`);
  }
  if (spec.isCollectionTypeReference(typeRef.type)) {
    return [
      {
        serializationClass:
          typeRef.type.collection.kind === spec.CollectionKind.Array
            ? SerializationClass.Array
            : SerializationClass.Map,
        typeRef,
      },
    ];
  }
  if (spec.isUnionTypeReference(typeRef.type)) {
    const compoundTypes = flatMap(typeRef.type.union.types, (t) =>
      serializationType({ type: t }, lookup),
    );
    // Propagate the top-level 'optional' field to each individual subtype
    for (const t of compoundTypes) {
      if (t.typeRef !== 'void') {
        t.typeRef.optional = typeRef.optional;
      }
    }
    return compoundTypes.sort((l, r) =>
      compareSerializationClasses(l.serializationClass, r.serializationClass),
    );
  }

  // The next part of the conversion is lookup-dependent
  const type = lookup(typeRef.type.fqn);

  if (spec.isEnumType(type)) {
    return [{ serializationClass: SerializationClass.Enum, typeRef }];
  }

  if (spec.isInterfaceType(type) && type.datatype) {
    return [{ serializationClass: SerializationClass.Struct, typeRef }];
  }

  return [{ serializationClass: SerializationClass.ReferenceType, typeRef }];
}