avrots's Introduction

avrots

A DSL for simultaneously constructing an avro schema and the corresponding typescript type. Inspired by pelotom/runtypes and joewood/avro-typescript.

Usage

Construct an avro schema using the DSL.

import {Record, Field, Array, String, Named, AsTypescript} from 'avrots'

const Toy = Record('toy', {
  name: Field(String())
})

const ToyArray = Array(Toy)

const Person = Record('person', {
  name: Field({default: null, type: String()}),
  ownToys: Field<typeof ToyArray>(ToyArray), // occasional disambiguation is still needed, but should be obvious
  covetedToys: Field<typeof ToyArray>(Array(Named(Toy))) // reference named types from earlier in the schema, since avro doesn't like redundant names
})

The generated object is already a valid avro schema, so we can use it directly in that way, but we can also use it to get the typescript type of an object that meets the schema.

type Person = AsTypescript<typeof Person>

const timmy: Person = {
 ownToys: [],
 covetedToys: ['guitar'] //type error! string is not a Toy.
}

This allows us to register a schema with some service and use that schema to get compile time validation that our code will produce records that are valid to that service.

avrots's People

avrots's Issues

Make optional properties optional, not just nullable

Adding a nullable or defaulted field to a record creates a sane avro schema, but still requires the field to be provided (though it can be null or undefined).

const Person = Record('person', {name: Field({type: String(), default: 'odysseus'})

const nobody: AsTypescript<typeof Person> = {} // type error! {} has no property 'name'

Improve inference on parametrized record fields

When a Field is constructed from a parametrized type, it can't correctly infer the underlying type without an explicit annotation. This is trivial to add, but irritating boilerplate.

const person = Record("person", {
    name: Field(String()),
    age: Field(Long()),
  });
const field = Field(person) // infers RequiredField<unknown>
const betterField = Field<typeof person>(person) //infers RequiredField<{name: string, age: number}>

Ideally fields would automatically do this inference, rather than needing to be "prompted" in this way. This feels like a higher kinded types problem though, so I'm not sure if there is a solution.

The issue exists for any field constructed with an underlying type which has a parameter.

Recommend Projects

schicks / avrots Goto Github PK

avrots's Introduction

avrots

Usage

avrots's People

avrots's Issues

Make optional properties optional, not just nullable

Improve inference on parametrized record fields

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent