deckchair-technicians/vicets

Validation and coercion library for Typescript

vicets's Issues

strict compiler checking

Think about optional keys on data classes

@data
export class Foo {
  readonly bar?: string | undefined = __(isstring());
}

Currently this will fail validation if key bar is missinh

Generate test data

typeDescription(x) blows up if x is null or undefined

.. so the error message is confusing

null, undefined

JSON schema datatypes

https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#dataTypes

Whole-object schemas on @data classes

e.g. field index must be less than the length of someStringField

build() a Partial<DataClass>

Schemas for all functions in validations library

Generate OpenAPI/json schema

Babel me

Strongly-type schema inputs

not()

Depends on #23

Schemas have description

Remember to test that recursion does not create an infinite loop.

Make everything everywhere immutable

Schema with runtime dependencies (e.g. repositories)

Figure out how to cleanly pass dependencies to schema at runtime for dynamic validation (repositories and so on). Ideally do this without magic global state.

Option to forbid unknown values on object being passed in

e.g. {a: 1, b: 1} should not validate against {a: __(isnumber())}

Array schemas

Think about versioning of schemas

Array length restriction

Property dependencies

https://json-schema.org/understanding-json-schema/reference/object.html

Object, array and map schemas add context to subschema exceptions

Easy override of failure messages

Test passing incorrect type to schemas

Maybe create a standard test harness for all schema

select and lens might be the same?

Can't remember what I was thinking. Double check this.

Think about JsonSchema for TagSchemaAsOptional

undefined isn't a concept in json, so we can't express it in json schema. The tag is really just for the ObjectSchema that eventually wraps TagSchemaAsOptional.

DataSchema ctor should fail if no schema attached to constructor

Serialisation? i.e. unform()

May be out of scope. Don't forget to test circular dependencies, which should either be impossible, or blow up. Our classes are supposed to be pure value objects.

Include password schema, which unforms to "*****" or similar.

HasItemBehaviour does not return "this"

Recursive schemas

Create typesafe validator separate from class definition

Conditional schemas ("switch")

Coercions (UUID, Date, etc.)

Think about async/await

Alternative support for schema in decorators

Add namespaces and reference paths

i.e. hide impl from the outside world

Tuple

Schema for 'is instance of enum'

My best guess on this now is:

@data
export class Bar {
  foo: MyEnum = __(isin(...Object.keys(MyEnum)));
}

Is there a better way?

Map schemas

Extend data classes (intersection types)

@data
class A {
  a:string=isstring().__();
}

@data
class B {
  b:string=isstring().__();
}

const C : A & B = extendData(A,B);

let -> const wherever possible

Seal and freeze data?

set()

@data classes with fields that use this class

Tuple

objectInPlace

Iterate Object.getOwnProperties() when cloning inside object?

like(e, pattern) doesn't work as expected when e instanceof Error

schemas.ts/conform()?

Do we need a conform(schema, value) function that catches exceptions from the schema and adds them to problems?

any()

valuesToSchemas and schematizeEntries do not both need to exist