Currently the union type tries all branches and succeeds when one branch passes. Instead, it should use a structural check and do the full validation on a single branch.

From #1, it'd be useful for serialising and deserialising to be able to visit types without implementing too much logic.

Version 19.0.5 of ts-jest just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As ts-jest is “only” a devDependency of this project it might not break production or downstream projects, but “only” your build or test tools – preventing new deploys or publishes.

I recommend you give this issue a high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

• Any
  • @id - for referencing across schema and to other schemas
  • description - user description of type
• String
  • minLength - string validation
  • maxLength - string validation
  • pattern - string validation
• String, Number, Date, DateTime, Property
  • min - minimum valid value (e.g. 1900-01-01, aaa, 1)
  • max - maximum valid value (e.g. 2010-01-01, bbb, 9)
• Intersection, Union
  • types - list of valid types
• List
  • minItems - minimum number of items
  • maxItems - maximum number of items
• Object
  • properties - list of valid properties
  • additionalProperties - validate additional properties not matched (e.g. "force invalid here")
• Property, Object
  • minProperties - minimum matching properties when using key schema
  • maxProperties - maximum matching properties when using key schema
• Property
  • key - allow key to be a schema or primitive value
  • required - equal to minProperties == 1
• Tuple
  • tuple - list of valid properties for ordered tuple

Need to be able to specify dependencies within the system - most likely as a rule and using the refs feature.

new Types.Object({
  properties: {
    lat: new Types.Number({ 
      required: false ,
      uses: [
        new Types.Depends({
          on: [Utils.ref(['lng'], 1)]
        })
      ]
    }),
    lng: new Types.Number({ 
      required: false 
    })
  }
})

Version 5.0.2 of tslint-config-standard just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As tslint-config-standard is “only” a devDependency of this project it might not break production or downstream projects, but “only” your build or test tools – preventing new deploys or publishes.

I recommend you give this issue a high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

Version 6.3.0 of validator just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As validator is a direct dependency of this project this is very likely breaking your project right now. If other packages depend on you it’s very likely also breaking them.
I recommend you give this issue a very high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

The ability to link to another defined type using URIs would be very useful in public API spaces. This would largely be related to #26 which would enable the ability to actually read these types at a given URI.

Three types of methods:

• formatter (for serialising data)
• parser (for deserialising data)
• validate (for validating native representations)

Serialising and deserialising can be completely synchronous, they would be based on structural type checking (none of the validation logic needs to occur). The tricky part here is picking which branch to use during serialisation/deserialisation (E.g. for union types). Maybe the structural checks can throw errors and pick the first branch that doesn't error? Also, sort union types by assignability (E.g. "a is a subset of b, but b is not a subset of a").

It'd be nice to remove the classes, but I think they'll just get more prominent as I add complexity (E.g. sort union types, proper intersection types). Could make it so the classes don't hold anything and move logic outside. E.g.

import { types, compile } from 'jaywalk'

const schema = {
  type: 'string',
  properties: {
    username: {
      type: 'string'
    }
  }
}

const validate = compile(types, schema)

Vs

import { Types, compile } from 'jaywalk'

const schema = new Types.Object({
  properties: {
    username: new Types.String()
  }
})

const validate = compile(schema)

I just found a useful case where I want to store valid sub-schemas, but only when the result is successful. For example, I need [x, y, z] to be set, but if one fails validation don't fail entirely - just use undefined.

Looks like this doesn't work:

now: new Types.DateTime({
    default: new Date()
})

Leads to:

TypeError: Value argument must be a reference or primitive value

Guessing it's related to default being on the Any time, but DateTime being more specific.

Need to be able to compose types into each other to optimise the executed code path.

For example, it's currently:

new Types.Object({
  patterns: {
    '^...$': ...
  }
})

Could re-use types and patterns instead:

new Types.Object({
  propertyTypes: [
    [
      new Types.Uuid(),
      new Types.Object()
    ]
  ]
})

Both implementations need to consider how intersections work.

Version 4.5.0 of tslint just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As tslint is “only” a devDependency of this project it might not break production or downstream projects, but “only” your build or test tools – preventing new deploys or publishes.

I recommend you give this issue a high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

I'm terrible at naming, but maybe someone can help me come up with something better?

• schematica
• skeema
• Yours here?

When running validations and branching occurs (e.g. Types.Union) it needs to clear the errors from previous unsuccessful branches.

• JSON (object mode, from JSON.parse)
• String hash (E.g. from querystring.parse)
• URL encoding

One thing that's kind of tricky to implement, but nice to have is partial validation.

Example usecase: if I'm entering values in a form and I want to type check onBlur for each field, but I also want to make sure that the final result shape is validate.

I could see do something like validate.only(...):

const validate = compile(new Types.Object({
  properties: {
    job: new Types.String({
      pattern: '^[\\w:]+$'
    }),
    cron: new Types.String({
      //pattern: '^\\d{1,2}:\\d{2}$'
    }),
    timezone: new Types.String(),
    now: new Types.DateTime({
      required: false
    })
  }
}))

const valid = await validate.only('timezone')('some string')

Could also be done with composition though

Enable conditional trees using If rules. E.g. If(CheckUnique).

interface IfOptions {
  left: any | Ref,
  comparator: '==' | '!=' | '>=' | '<='
  right: any | Ref
  uses: Rule[]
}

new Types.Object({
  properties: {
    password: new Types.String({ minLength: 5, maxLength: 10 }),
    confirmPassword: new Types.String({ 
      uses: [new Types.If({ left: ref(), compator: '==', right: ref(['password'], 1) })] 
    })
  }
})

Something more user-friendly - like type.string().required(false).minLength(100). At the end, it should probably expose a single function to collect the types and get the schema for compilation.

It'd be awesome to add a Mutate/Transform rule that only transforms for the duration of the rules nested inside it. This would enable things like ToLower(Blacklist) where the original casing is preserved when returning back upstream.

Edit: Oh, clever thing is now required can skip the following checks immediately - exiting the middleware chain.

Defines the minimum and maximum number of keys allows on the object.

Inverses the containing rules. E.g. a pass fails, while a failure passes. This would allow things like Not(Uuid).

interface NotOptions {
  check: Rule
  uses: Rule[]
}

Using a required: boolean flag on properties doesn't make a lot of sense overall. It's useful, but it's kind of tricky. Instead, consider whether the Object type should instead have an optionalProperties array and we should introduce a Null type for "null-able".

Providing an optional name for the schema could be handy when you have larger applications. Right now the validation error I get back doesn't help me pinpoint which schema has the error:

{ MultiError: Validation failed for "String#pattern" at "time"
    at /Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/index.js:27:51
    at process._tickDomainCallback (internal/process/next_tick.js:129:7)
    at Function.Module.runMain (module.js:577:11)
    at Object.<anonymous> (/usr/local/lib/node_modules/async-to-gen/async-node:98:10)
    at Module._compile (module.js:541:32)
    at Object.Module._extensions..js (module.js:550:10)
    at Module.load (module.js:458:32)
    at tryModuleLoad (module.js:417:12)
    at Function.Module._load (module.js:409:3)
    at Module.runMain (module.js:575:10)
  cause: undefined,
  errors:
   [ { ValidationError: Validation failed for "String#pattern" at "time"
         at Object.error (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/index.js:18:23)
         at /Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/types/string.js:83:27
         at /Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:75:32
         at dispatch (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:74:20)
         at next (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:76:28)
         at isString (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/types/string.js:47:12)
         at /Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:75:32
         at dispatch (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:74:20)
         at next (/Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/utils.js:76:28)
         at /Users/matt/Projects/standupjack.com/node_modules/jaywalk/dist/types/any.js:73:16
       cause: undefined,
       path: [Object],
       type: 'String',
       keyword: 'pattern',
       assertion: '^\\d{1,2}:\\d{1,2}$',
       value: '1030' } ] }

Would be useful for validation errors to contain the schema path - not just the assertion itself.

For example:

const createdSchema = compose([
  new Types.Properties({
    dateCreated: compose([new Types.Date()])
  })
])

const userSchema = compose([
  new Types.Properties({
    username: compose([new Types.String(), new Types.Pattern('^[a-zA-Z0-9_-]+$')]),
    password: compose([new Types.String(), new Types.MinLength(5), new Types.MaxLength(100)])
  }),
  createdSchema
])

• How do this interact with serialising and deserialising? E.g. when does one serialise/deserialise a type in the chain above?
• This feels more powerful, but the serialised representation is terrible (hard to read)
• Rules become dependent on order, may be confusing? E.g. when does one serialise the type in the chain, especially recursively? Imagine Falcor paths that needs to ignore object outputs.

Related to #13, but enable the ability to extend using raw objects. E.g. stringType._extend({ required: false }).

Currently there's a rough coupling going on. Instead, structural classes should be completely separated from rules. Every property on a structural class must be used from structural type checking, otherwise it should be a rule. Rules can be simplified, since they don't need things like description, meta, etc.

new Types.String({
  uses: [
    new Rules.MinLength(1),
    new Rules.MaxLength(50),
    new Rules.Matches('^a-zA-Z0-9_$')
  ]
})

Version 2.2.1 of typescript just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As typescript is “only” a devDependency of this project it might not break production or downstream projects, but “only” your build or test tools – preventing new deploys or publishes.

I recommend you give this issue a high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

Traverse the type model and generate a JavaScript validation function.

Old version: https://github.com/standardschema/javascript/blob/aae7c023a958e489b5a83454521ad71c6dfe281a/src/validation.ts

Mostly just for the error schema - want to be able to serialise the errors without each person writing a schema for it.

Need to be able to create Rule instances for usage in uses: [] without having to re-specify options like default: and required:.

This would enable the ability to "omit" a field, especially during intersection. For example:

new Types.Compose({
  items: [
    userSchema
    new Types.Object({
      properties: {
        password: new Types.Void()
      }
    }
  }
})

Need to implement a visual mode for the type system (E.g. JSON) that be stored in plain text and restored from plain text. The most obvious implementation requires exposing a "type container" of the built-in types that allows instantiating multiple type containers that also support "user types" for restoring.

Rules/types need a method to merge compatible sub-types into others. This would enable optimised intersections and also enable composed types.

Trying out this library :-) It's a bit weird that pattern needs to be a string since it forces you to escape your regexp. Example:

const validate = compile(new Types.Object({
  properties: {
    job: new Types.String({ pattern: '^[\\w:]+$' }),
    time: new Types.String({ pattern: '^\\d{1,2}:\\d{1,2}$' }),
    timezone: new Types.String()
  }
}))

Might be nice to make it support regexp too

Enable a type to be composed from property rules and make fromJSON and toJSON simpler (remove duplication and sub-classing logic). Removes independent type classes and instead makes them a composition of their properties (with @type coming first).

• Structural type checking
• Validation functions
• Rules
• Types
• Rules vs Types
• use[]

From #6 (comment), was thinking about it a bit before. Basically, need a new special type (it's kind of on the same level as Intersection, in that it's a special construct) that anywhere in the validation process can retrieve the runtime value or use a raw value. E.g. a number or a reference to a number.