KeysOf & OAS emitter

[p-bakker]

Am trying to use Rest.Resource.KeysOf to get all property keys of a model and then use those to validate the provided values in my fields query parameter, but cannot get it to work

Pseudo code:

model Order {
  // whole bunch of properties here
}

model OrderQueryParams {
    @doc("List of fields to include in the response")
    @query()
    fields?: Resource.KeysOf<Order>[];;
}

 op getOrders(
        ...OrderQueryParams,
    ): {
        @statusCode statusCode: 200;
        @body orders: Order[];
    };

This results in the following (trimmed down) OAS content:

...
  /orders:
    get:
      parameters:
        - $ref: '#/components/parameters/OrderQueryParams.fields'
...
components:
  parameters:
    OrderQueryParams.fields:
      name: fields
      in: query
      required: false
      description: List of fields to include in the response
      schema:
        type: array
        items:
          $ref: '#/components/schemas/OrderKeyItem'
      explode: false
  ...
  schema:
    OrderKeyItem:
      type: object
      additionalProperties:
        not: {}
      description: Dynamically gathers keys of the model type Resource.
   ...

Am I doing something wrong? Is this just not supported or a known issue?

Any help appreciated!

[p-bakker]

Note that what I expected components > schema > OrderKeyItem to be is:

    OrderKeyItem:
      type: string
      enum:
        - prop1
        - prop2
        - ...
        - propN

[timotheeguerin]

Were you expecting this KeysOf to give you all the keys (like typescript keyof)? In this case this is not what this type does in the rest library. It only retrieve the properties annonated with @key including parent resources.

See playground

I think we don't have a direct equivalent to typescript keyof, feel free to file an isuse if that's what you were looking for.

[p-bakker]

Were you expecting this KeysOf to give you all the keys (like typescript keyof)?

Yes, that was what I was hoping/expecting if would give me. Maybe I missed something, but I couldn't find any documentation suggesting it would only return properties tagged with @key

So any other suggestions on/pointers to how to validate query params that are tied to the available properties on the type returned of an operation? My 'fields' example is just a simple, straight-forward one I started with, but I also have a filters query param that is also tied to the available properties (and their types) on the operation return type

Or am I just trying to do the impossible here?

[timotheeguerin]

with the current types it is not possible, you could make your own type+decorator if you want.

@applyKeyOf(T)
union KeyOf<T> {
}

and define the applyKeyOf decorator to add each variant to the union from the keys

[p-bakker]

I'll have a look if I can figure it out with a custom decorator!

feel free to file an isuse if that's what you were looking for

As for that feature request: would that have any chance getting added, or would such a request be pretty much DOA?

[p-bakker]

This is what I came up with for the decorator:

export function $propertiesEnumOf(context: DecoratorContext, target: Enum, model: Model) {
  for (const key of model.properties.keys()) {
    target.members.set(key, {
      kind: 'EnumMember',
      name: key,
      enum: target,
      entityKind: 'Type',
      isFinished: true,
      decorators: [],
    })
  }

  return target;
}

which I then use like:

  @propertiesEnumOf(MyResource)
  enum MyResourceProperties {}

So I can use if on a model property like this:

  fields?: MyResourceProperties[]

Which means that the generated OAS defines that the fields property must be an Array of (string) values, where each value is one of the root property names of the MyResource model

I tried with a Union as you suggested, but couldn't get that going.

Also, wrt the way I implemented the $propertiesEnumOf decorator: is that considered a good approach? I was expecting there be be some api's to manipulate the enum, instead of directly manipulating the Enum.members map and creating EnumMember objects myself, but at least this works...

[artsiommiksiuk]

I'd +1 this. IMHO, keyof is a must in the core of the language.