d1c4a61...master · schematic

git.iko.soy/schematic

on master help sign in

.travis.yml+2−2

since splitsnapshots

unifiedsplit

@@ -1,4 +1,4 @@

1−sudo: false

1+sudo: required

3language: c

@@ -22,4 +22,4 @@ script:

23cache:

24 directories:

25− - $HOME/.stack

25+ - $HOME/.stack

ChangeLog.md+45

@@ -1,5 +1,50 @@

1# Revision history for schematic

3+## 0.5.0.0 -- 2019-02-20

5+GHC 8.6, json generation by schema definition, validation bug fixes, better

6+parsing error messages.

8+## 0.4.3.0 -- 2018-07-12

10+GHC 8.4 support, dropping support for older GHC versions

11+

12+## 0.4.2.0

13+

14+Support ghc-8.4 and drop support for older versions

15+

16+## 0.4.1.0 -- 2017-11-05

17+

18+Convenience isomorphisms: txt, num, opt, bln etc

19+

20+## 0.4.1.0 -- 2017-11-01

21+

22+flens and fget now use type application syntax

23+

24+## 0.4.0.0 -- 2017-10-17

25+

26+Object building DSL, more convenience helpers, MCons simplified with Tagged

27+

28+## 0.3.2.0 -- 2017-10-02

29+

30+Fixed FIndex bug, added bunch of convenience isomorphism, re-exports.

31+

32+## 0.3.1.0 -- 2017-09-28

33+

34+Add UUID and ISO8601 helpers, json schema constraint export, fsubset lens

35+combinator.

36+

37+## 0.3.0.0 -- 2017-09-28

38+

39+Updated to GHC 8.2.1 and singletons 2.3.1

40+

41+## 0.2.1.0 -- 2017-09-26

42+

43+Add decodeAndValidateVersionedWithPureMList, fix tests

44+

45+## 0.2.0.0 -- 2017-09-26

46+

47+Migratable is deprecated, migrations are now possible in an arbitrary monad.

4## 0.1.5.0 -- 2017-08-22

49## 0.1.5.0 -- 2017-08-22

README.md+150−29

@@ -1,6 +1,6 @@

1# schematic

3−[![Build Status](https://travis-ci.org/dredozubov/schematic.svg?branch=master)](https://travis-ci.org/dredozubov/schematic)

3+[![Build Status](https://travis-ci.org/typeable/schematic.svg?branch=master)](https://travis-ci.org/typeable/schematic)

5## Goal

@@ -10,13 +10,7 @@ The goal of the library is to provide a type-safe transport layer for serializin

10* Serializers are generic, so they follow from the type-level schema and the're supposed to have a roundtrip property by an implementation.

11* Runtime value validators are generated from the schema. Validation errors are reported as a pairs of a json-path to the element and an error message.

12* There are migrations. It's possible to describe a series of migrations to the schema and have all the necessary machinery to deserialize a user specified version of the schema if there are multiple versions available.

13−

13+* Schematic schemas can be exported to [json-schema](http://json-schema.org)

14−## TODO

15−

16−* Schema pretty-printing

17−* More validators

18−* Overall user friendliness

19−* Versioned http endpoints

21Be aware that library is experimental and subject to change a lot. The current state can be viewed as a prototype.

15Be aware that library is experimental and subject to change a lot. The current state can be viewed as a prototype.

@@ -28,9 +22,35 @@ Be aware that library is experimental and subject to change a lot. The current s

28$ stack install schematic

22$ stack install schematic

29```

23```

31−## Basic Examples

25+## GHC Extensions

26+

27+To use this library without any hassle you should add a few GHC extension

28+either to a module or a cabal file:

33```

30```

31+DataKinds

32+OverloadedLists

33+OverloadedStrings

34+TypeApplications

35+```

36+

37+`Overloaded`-extensions are being used only by `field` combinator,

38+so if you don't use it - feel free to disable it.

39+

40+## GHC Options

41+

42+I recommend using `{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}`

43+pragma in modules which declare schemas and schema migrations, because `schematic`

44+heavily uses promoted types which should be prefixed with "`" signs and they can

45+be dropped with this option, making it less noisy visually.

46+It's entirely optional and totally opinionated, so feel free to ignore this.

47+Through the documentation, the code is written without any explicit ticks for

48+the same reason.

49+Notice that they're still needed for type-level lists and tuples in schematic code.

50+

51+## Basic Examples

52+

53+```haskell

34type SchemaExample

54type SchemaExample

35 = SchemaObject

55 = SchemaObject

36 '[ '("foo", SchemaArray '[AEq 1] (SchemaNumber '[NGt 10]))

56 '[ '("foo", SchemaArray '[AEq 1] (SchemaNumber '[NGt 10]))

@@ -48,21 +68,21 @@ type SchemaExample

49This one is valid for example

69This one is valid for example

51−```

71+```haskell

52schemaJson :: ByteString

72schemaJson :: ByteString

53schemaJson = "{\"foo\": [13], \"bar\": null}"

73schemaJson = "{\"foo\": [13], \"bar\": null}"

54```

74```

56Also valid

76Also valid

58−```

78+```haskell

59schemaJson :: ByteString

79schemaJson :: ByteString

60schemaJson = "{\"foo\": [13], \"bar\": \"bar\"}"

80schemaJson = "{\"foo\": [13], \"bar\": \"bar\"}"

61```

81```

63it can be parsed and validated like this:

83it can be parsed and validated like this:

65−```

85+```haskell

66decodeAndValidateJson schemaJson :: ParseResult (JsonRepr SchemaExample)

86decodeAndValidateJson schemaJson :: ParseResult (JsonRepr SchemaExample)

67```

87```

@@ -72,24 +92,64 @@ decodeAndValidateJson schemaJson :: ParseResult (JsonRepr SchemaExample)

72* some of the runtime validations have failed, but it's structurally correct

92* some of the runtime validations have failed, but it's structurally correct

73 overall

93 overall

75−It implies a transport layer representation of that data that can be traversed and transformed to whatever internal types user has. It's called `JsonRepr`. Type parameter is the schema itself.

95+It implies a transport layer representation of that data that can be traversed

96+and transformed to whatever internal types user has.

97+It's called `JsonRepr`. Type parameter is the schema itself.

99+```haskell

100+jsonExample :: JsonRepr SchemaExample

101+jsonExample = withRepr @SchemaExample

102+ $ field @"foo" [12]

103+ :& field @"bar" (Just "bar")

104+ :& RNil

105+```

106+

107+The most basic and sugar-free way of constructing the same object will look like this:

108

78```

109```

79−jsonExample :: JsonRepr SchemaExample

110+jsonExample' :: JsonRepr SchemaExample

80−jsonExample = ReprObject $

111+jsonExample' = ReprObject $

81 FieldRepr (ReprArray [ReprNumber 12])

112 FieldRepr (ReprArray [ReprNumber 12])

82 :& FieldRepr (ReprOptional (Just (ReprText "bar")))

113 :& FieldRepr (ReprOptional (Just (ReprText "bar")))

83 :& RNil

114 :& RNil

84```

115```

116

117+## Lens-compatibility

118+

119+It's possible to use `flens` to construct a field lens for a typed object in schematic. Let's suppose you have a schema like this:

120+

121+```haskell

122+type ArraySchema = SchemaArray '[AEq 1] (SchemaNumber '[NGt 10])

123+

124+type ArrayField = '("foo", ArraySchema)

125+

126+type FieldsSchema =

127+ '[ ArrayField, '("bar", SchemaOptional (SchemaText '[TEnum '["foo", "bar"]]))]

128+

129+type SchemaExample = 'SchemaObject FieldsSchema

130+

131+```

132+

133+There are two ways of working with named fields in the objects:

134+

135+* Using the `fget` and `fset` functions: `fget @"foo" (fput newFooVal objectData) == newFooVal`

136+* Using the lens library: `set (flens @"foo") newFooVal objectData ^. flens @"foo" == newFooVal`

137+

86## Migrations

138## Migrations

139

140+Usually migrations are implicit and hard to deal with, `schematic` deals with it

141+by giving tools to deal with it to a programmer, being as explicit as possible,

142+notifying the developer of a missing transition with a compile-time error.

143+It allows to build versioned HTTP APIs or migrate data from the older versions

144+when reading from the JSON storages.

145+

146+It's possible to represent schema changes as a series of migrations,

88−It's possible to represent schema changes as a series of migrations, which describes a series of json-path/change pairs. Migrations can be applied in succession.

147+which describes a series of json-path/change pairs. Migrations can be applied in

148+succession.

149

90This piece of code will apply a migration to the schema, decode and validate the latest version.

150This piece of code will apply a migration to the schema, decode and validate the latest version.

151

92−```

152+```haskell

93type SchemaExample

153type SchemaExample

94 = SchemaObject

154 = SchemaObject

95 '[ '("foo", SchemaArray '[AEq 1] (SchemaNumber '[NGt 10]))

155 '[ '("foo", SchemaArray '[AEq 1] (SchemaNumber '[NGt 10]))

@@ -97,8 +157,8 @@ type SchemaExample

157

98type TestMigration =

158type TestMigration =

99 'Migration "test_revision"

159 'Migration "test_revision"

100− '[ 'Diff '[ 'PKey "bar" ] ('Update ('SchemaText '[]))

160+ '[ Diff '[ PKey "bar" ] (Update (SchemaText '[]))

101− , 'Diff '[ 'PKey "foo" ] ('Update ('SchemaNumber '[])) ]

161+ , Diff '[ PKey "foo" ] (Update (SchemaNumber '[])) ]

102

162

103type VS = 'Versioned SchemaExample '[ TestMigration ]

163type VS = 'Versioned SchemaExample '[ TestMigration ]

104

164

@@ -112,23 +172,84 @@ It's possible to decode the latest version like this:

112decodeAndValidateJson schemaJsonTopVersion :: ParseResult (JsonRepr (TopVersion (AllVersions VS)))

172decodeAndValidateJson schemaJsonTopVersion :: ParseResult (JsonRepr (TopVersion (AllVersions VS)))

113```

173```

114

174

115−## Lens-compatibility

175+It's important to differentiate between schema migrations and data migrations.

176+Schema migration is a change of a schema acceptable by a JSON consumer. It transforms one schema to another.

177+Data migrations on the other hand are functions on the data itself. They transform values

178+acceptable by one schema to values acceptable by another.

179+Let's look at the situation when we have to add a field to a JSON Object of a current schema:

116

180

117−It's possible to use `flens` to construct a field lens for a typed object in schematic. Let's suppose you have a schema like this:

181+```haskell

182+type SchemaExample = 'SchemaObject

183+ '[ '("foo", 'SchemaArray '[ 'AEq 1] ('SchemaNumber '[ 'NGt 10]))

184+ , '("bar", 'SchemaOptional ('SchemaText '[ 'TEnum '["foo", "bar"]]))]

185+

186+jsonExample :: JsonRepr SchemaExample

187+jsonExample = withRepr @SchemaExample

188+ $ field @"bar" (Just "bar")

189+ :& field @"foo" [12]

190+ :& RNil

191+

192+type AddQuuz =

193+ 'Migration "add_field_quuz"

194+ '[ 'Diff '[] ('AddKey "quuz" (SchemaNumber '[])) ]

195+

196+type DeleteQuuz =

197+ 'Migration "remove_field_quuz"

198+ '[ 'Diff '[] ( 'DeleteKey "quuz") ]

199+

200+type Migrations = '[ AddQuuz

201+ , DeleteQuuz ]

202+

203+type VersionedJson = 'Versioned SchemaExample Migrations

204+

205+migrationList :: MigrationList Identity VersionedJson

206+migrationList

207+ = (migrateObject (\r -> Identity $ field @"quuz" 42 :& r))

208+ :&& shrinkObject

209+ :&& MNil

118

210

119```

211```

120−type ArraySchema = 'SchemaArray '[AEq 1] ('SchemaNumber '[NGt 10])

121

212

122−type ArrayField = '("foo", ArraySchema)

213+In this instance `Migrations` is a list of schema migrations and

214+`MigrationList Identity VersionedJson` is a list of data migrations corresponding

215+to the list of schema migrations: `migrateObject (\r -> Identity $ field @"quuz" 42 :& r))`

216+will be used at runtime to transform `JsonRepr SchemaExample` to

217+`JsonRepr (SchemaByRevision "add_quuz" VersionedJson). `Identity` in the type of

218+`MigrationList` is a monad we choose to run our migrations in. If there's need to

219+do database queries or something like that, it can be changed to something more

220+appropriate by a user.

221+`migrateObject` takes a function transforming old fields into new ones, `shrinkObject`

222+allows to shrink the JSON object in case migration only removed fields.

123

223

124−type FieldsSchema =

224+## How do I construct a value of `JsonRepr schema`?

125− '[ ArrayField, '("bar", 'SchemaOptional ('SchemaText '[TEnum '["foo", "bar"]]))]

126

225

226+`JsonRepr schema` is a primary representation of a value serializable/deserializable

227+to JSON, but with a twist. It's guaranteed to correspond a type-level schema,

228+it's a type parameter of a same name.

229+It makes constructing it a little bit more involved, but luckily `schematic`

230+provides a DSL for doing so in a more straightforward fashion. An example would

231+look like this:

232+

233+```haskell

127−type SchemaExample = 'SchemaObject FieldsSchema

234+type SchemaExample = 'SchemaObject

235+ '[ '("foo", SchemaArray '[ AEq 1] (SchemaNumber '[NGt 10]))

236+ , '("bar", SchemaOptional (SchemaText '[TEnum '["foo", "bar"]]))]

128

237

238+jsonExample = withRepr @SchemaExample

239+ $ field @"bar" (Just "bar")

240+ :& field @"foo" [12]

241+ :& RNil

129```

242```

130

243

131−There are two ways of working with named fields in the objects:

244+`@foo` syntax is an explicit type application, which is a feature of GHC 8+, it

245+makes type inference possible without relying on a bunch of `Proxy`s, which

246+makes it syntactically more terse.

247+

248+[GHC Type Applications](https://ghc.haskell.org/trac/ghc/wiki/TypeApplication)

249+

250+`schematic` provides instances for `OverloadedLists` and `OverloadedStrings`

251+GHC extensions to make use of string and list literals for values in a previous

252+example.

253+

132

254

133−* Using the `fget` and `fset` functions: `fget fooProxy (fput newFooVal objectData) == newFooVal`

255+## Export to json-schema (draft 4)

134−* Using the lens library: `set (flens (Proxy @"foo")) newFooVal objectData ^. flens (Proxy @"foo") == newFooVal`

releasenew file+43

@@ -0,0 +1,43 @@

1+#!/bin/bash

3+set -o xtrace

5+dist=`stack path --dist-dir --stack-yaml ./stack.yaml 2> /dev/null`

7+rootdir=`pwd`

9+cabalfile=`ls *.cabal`

10+packagename="${cabalfile%%.*}"

11+version=`grep '^version:' schematic.cabal | rev | cut -d" " -f1 | rev`

12+

13+echo -e "\033[1;36mTesting library...\033[0m"

14+stack test 2> /dev/null

15+

16+echo -e "\033[1;36mRunning sdist...\033[0m"

17+cabal sdist

18+

19+echo -e "\033[1;36mGenerating documentation...\033[0m"

20+stack haddock 2> /dev/null

21+

22+if [ "$?" -eq "0" ]; then

23+ echo -e "\033[1;32mUploading package to Hackage...\033[0m"

24+ read -p "Hackage username: " username

25+ read -p "Hackage password: " -s password

26+ echo ""

27+ cabal upload -u $username -p $password dist/$packagename-$version.tar.gz

28+

29+ docdir=`find .stack-work -name "$packagename-$version-docs"`

30+

31+ echo -e "Compressing documentation from \033[1;34m$docdir\033[0m for \033[1;35m$packagename\033[0m-\033[1;33m$version\033[1;30m"

32+ tar -c -v -z --format=ustar -f $docdir.tar.gz $docdir

33+ echo -e "\033[1;32mUploading documentation to Hackage...\033[0m"

34+ cd $docdir

35+ cd ..

36+ curl -X PUT -H 'Content-Type: application/x-tar' -H 'Content-Encoding: gzip' --data-binary "$packagename-$version-docs.tar.gz" "https://$username:$password@hackage.haskell.org/package/$packagename-$version/candidate/docs"

37+ open "https://hackage.haskell.org/package/$packagename-$version/candidate/"

38+ cd $rootdir

39+ echo "To publish the candidate, use 'cabal upload --publish'."

40+ exit $?

41+else

42+ echo -e "\033[1;31mNot in a stack-powered project\033[0m"

43+fi

release.nixnew file+32

@@ -0,0 +1,32 @@

1+{ schematicSrc ? { outPath = ./.; revCount = 0; gitTag = "dirty"; }

2+, supportedSystems ? [ "x86_64-linux" ]

3+}:

5+let

6+ _nixpkgs = import <nixpkgs> {};

7+ inherit (_nixpkgs) pkgs lib;

9+ stackageOverlayPath = pkgs.fetchFromGitHub {

10+ owner = "typeable";

11+ repo = "nixpkgs-stackage";

12+ rev = "abe0a03ba2bde609b0707ce45301ec836cb3ed29";

13+ sha256 = "0ksdk83zbsgvs30izwsfyjh4xxwz8dsn9a5igrs3pjap4whpzqfv";

14+ };

15+

16+ nixpkgsArgs = {

17+ overlays = [ (import stackageOverlayPath) ];

18+ };

19+

20+ release = import <nixpkgs/pkgs/top-level/release-lib.nix> { inherit nixpkgsArgs supportedSystems; };

21+

22+ mkStackage = system:

23+ let

24+ nixpkgs = release.pkgsFor system;

25+ stackage = nixpkgs.haskell.packages.stackage.lib.callStackage2nix "schematic" schematicSrc { inherit nixpkgs; };

26+ in

27+ stackage;

28+

29+in

30+ lib.genAttrs supportedSystems (system: {

31+ inherit (mkStackage system) schematic;

32+ })

schematic.cabal+32−44

@@ -1,15 +1,13 @@

1−-- Initial schematic.cabal generated by cabal init. For further

2−-- documentation, see http://haskell.org/cabal/users-guide/

3−

4name: schematic

1name: schematic

5−version: 0.1.6.0

2+version: 0.5.0.0

6synopsis: JSON-biased spec and validation tool

3synopsis: JSON-biased spec and validation tool

7−-- description:

4+description: JSON-biased spec and validation tool. Makes possible to have a schema as a haskell type and derive json instances, validation actions, JSON generation for property-test generically. Built-in lens support.

8license: BSD3

5license: BSD3

9license-file: LICENSE

6license-file: LICENSE

10author: Denis Redozubov

7author: Denis Redozubov

11maintainer: denis.redozubov@gmail.com

8maintainer: denis.redozubov@gmail.com

12−-- copyright:

9+homepage: http://github.com/typeable/schematic

10+Bug-reports: http://github.com/typeable/schematic/issues/

13category: Data

11category: Data

14build-type: Simple

12build-type: Simple

15extra-source-files: ChangeLog.md

13extra-source-files: ChangeLog.md

@@ -17,21 +15,29 @@ cabal-version: >=1.10

18library

16library

19 exposed-modules: Data.Schematic

17 exposed-modules: Data.Schematic

18+ , Data.Schematic.DSL

19+ , Data.Schematic.Generator

20+ , Data.Schematic.Generator.Regex

20 , Data.Schematic.Instances

21 , Data.Schematic.Instances

21 , Data.Schematic.JsonSchema

22 , Data.Schematic.JsonSchema

23+ , Data.Schematic.Helpers

22 , Data.Schematic.Lens

24 , Data.Schematic.Lens

23 , Data.Schematic.Migration

25 , Data.Schematic.Migration

24 , Data.Schematic.Path

26 , Data.Schematic.Path

25 , Data.Schematic.Schema

27 , Data.Schematic.Schema

26 , Data.Schematic.Validation

28 , Data.Schematic.Validation

27− , Data.Schematic.Utils

29+ , Data.Schematic.Verifier

30+ , Data.Schematic.Verifier.Array

31+ , Data.Schematic.Verifier.Common

32+ , Data.Schematic.Verifier.Number

33+ , Data.Schematic.Verifier.Text

28 ghc-options: -Wall

34 ghc-options: -Wall

29− -- other-modules:

30 default-extensions: ConstraintKinds

35 default-extensions: ConstraintKinds

31 , DataKinds

36 , DataKinds

32 , DefaultSignatures

37 , DefaultSignatures

33 , DeriveFunctor

38 , DeriveFunctor

34 , DeriveFoldable

39 , DeriveFoldable

40+ , DeriveTraversable

35 , DeriveGeneric

41 , DeriveGeneric

36 , DeriveDataTypeable

42 , DeriveDataTypeable

37 , FlexibleContexts

43 , FlexibleContexts

@@ -59,19 +65,24 @@ library

59 , TypeOperators

65 , TypeOperators

60 , TypeSynonymInstances

66 , TypeSynonymInstances

61 , UndecidableInstances

67 , UndecidableInstances

62− build-depends: base >=4.9 && <4.10

68+ build-depends: base >=4.11 && <4.13

63 , bytestring

69 , bytestring

64 , aeson >= 1

70 , aeson >= 1

65 , containers

71 , containers

72+ , hjsonschema

73+ , mtl

74+ , profunctors

66− , regex-compat

75+ , regex-tdfa

76+ , regex-tdfa-text

67 , scientific

77 , scientific

68− , singletons

78+ , singletons >= 2.4

69 , smallcheck

79 , smallcheck

70− , smallcheck-series

71 , tagged

80 , tagged

81+ , template-haskell

72 , text

82 , text

83+ , union

73 , unordered-containers

84 , unordered-containers

74− , validationt >= 0.1.0.1

85+ , validationt >= 0.2.1.0

75 , vector

86 , vector

76 , vinyl

87 , vinyl

77 hs-source-dirs: src

88 hs-source-dirs: src

@@ -82,51 +93,28 @@ test-suite spec

82 hs-source-dirs: test

93 hs-source-dirs: test

83 main-is: Spec.hs

94 main-is: Spec.hs

84 default-language: Haskell2010

95 default-language: Haskell2010

85− default-extensions: ConstraintKinds

86− , DataKinds

87− , DeriveFunctor

88− , DeriveFoldable

89− , DeriveGeneric

90− , DeriveDataTypeable

91− , FlexibleContexts

92− , FlexibleInstances

93− , FunctionalDependencies

94− , GADTs

95− , KindSignatures

96− , InstanceSigs

97− , MultiParamTypeClasses

98− , OverloadedLists

99− , OverloadedStrings

100− , PolyKinds

101− , QuasiQuotes

102− , PartialTypeSignatures

103− , RecordWildCards

104− , ScopedTypeVariables

105− , TemplateHaskell

106− , TypeApplications

107− , TypeFamilies

108− , TypeInType

109− , TypeOperators

110− , TypeSynonymInstances

111 build-depends: HUnit

96 build-depends: HUnit

112 , aeson >= 1

97 , aeson >= 1

113− , base >=4.9 && <4.10

98+ , base >=4.11 && <4.13

114 , bytestring

99 , bytestring

115 , containers

100 , containers

101+ , hjsonschema

116 , hspec >= 2.2.0

102 , hspec >= 2.2.0

117 , hspec-core

103 , hspec-core

118 , hspec-discover

104 , hspec-discover

119 , hspec-smallcheck

105 , hspec-smallcheck

120 , lens

106 , lens

121− , regex-compat

107+ , regex-tdfa

108+ , regex-tdfa-text

122 , schematic

109 , schematic

123 , smallcheck

110 , smallcheck

124− , smallcheck-series

125 , singletons

111 , singletons

126 , tagged

112 , tagged

127 , text

113 , text

128 , unordered-containers

114 , unordered-containers

129− , validationt >= 0.1.0.1

115+ , validationt >= 0.2.1.0

130 , vinyl

116 , vinyl

131 other-modules: SchemaSpec

117 other-modules: SchemaSpec

118+ , HelpersSpec

132− , LensSpec

119+ , LensSpec

120+ , JsonSchemaSpec

src/Data/Schematic.hs+38−82

@@ -2,62 +2,43 @@

2{-# LANGUAGE AllowAmbiguousTypes #-}

4module Data.Schematic

5− ( module Data.Schematic.Schema

5+ ( module Data.Schematic.JsonSchema

6+ , module Data.Schematic.Helpers

6 , module Data.Schematic.Lens

7 , module Data.Schematic.Lens

7 , module Data.Schematic.Migration

8 , module Data.Schematic.Migration

8− , module Data.Schematic.Utils

9+ , module Data.Schematic.Schema

9 , decodeAndValidateJson

10 , decodeAndValidateJson

10 , parseAndValidateJson

11 , parseAndValidateJson

11 , parseAndValidateJsonBy

12 , parseAndValidateJsonBy

12− , parseAndValidateVersionedJson

13 , parseAndValidateTopVersionJson

14− , decodeAndValidateVersionedJson

15 , parseAndValidateWithMList

14 , parseAndValidateWithMList

16 , decodeAndValidateVersionedWithMList

15 , decodeAndValidateVersionedWithMList

16+ , decodeAndValidateVersionedWithPureMList

17 , isValid

18 , isDecodingError

19 , isValidationError

20 , ParseResult(..)

21− , Migratable

21+ , withRepr

22+ , field

22 ) where

23 ) where

24import Control.Monad.Validation

25import Control.Monad.Validation

25import Data.Aeson as J

26import Data.Aeson as J

26import Data.Aeson.Types as J

27import Data.Aeson.Types as J

27import Data.ByteString.Lazy as BL

28import Data.ByteString.Lazy as BL

28−import Data.Functor.Identity

29+import Data.Functor.Identity as F

30+import Data.Schematic.DSL

31+import Data.Schematic.Helpers

32+import Data.Schematic.JsonSchema

29import Data.Schematic.Lens

33import Data.Schematic.Lens

30import Data.Schematic.Migration

34import Data.Schematic.Migration

31import Data.Schematic.Schema

35import Data.Schematic.Schema

32−import Data.Schematic.Utils

33import Data.Schematic.Validation

36import Data.Schematic.Validation

34−import Data.Singletons.Prelude

37+import Data.Singletons.Prelude hiding ((:.))

38+import Data.Tagged

35import Data.Text as T

39import Data.Text as T

38−parseAndValidateJson

39− :: forall schema

40− . (J.FromJSON (JsonRepr schema), TopLevel schema, SingI schema)

41− => J.Value

42− -> ParseResult (JsonRepr schema)

43−parseAndValidateJson v =

44− case parseEither parseJSON v of

45− Left s -> DecodingError $ T.pack s

46− Right jsonRepr ->

47− let

48− validate = validateJsonRepr (sing :: Sing schema) [] jsonRepr

49− res = runIdentity . runValidationTEither $ validate

50− in case res of

51− Left em -> ValidationError em

52− Right () -> Valid jsonRepr

53−

54−parseAndValidateJsonBy

55− :: (J.FromJSON (JsonRepr schema), TopLevel schema, SingI schema)

56− => proxy schema

57− -> J.Value

58− -> ParseResult (JsonRepr schema)

59−parseAndValidateJsonBy _ = parseAndValidateJson

60−

61parseAndValidateTopVersionJson

42parseAndValidateTopVersionJson

62 :: forall proxy (v :: Versioned)

43 :: forall proxy (v :: Versioned)

63 . (SingI (TopVersion (AllVersions v)))

44 . (SingI (TopVersion (AllVersions v)))

@@ -76,44 +57,23 @@ parseAndValidateTopVersionJson _ v =

76 Left em -> ValidationError em

57 Left em -> ValidationError em

77 Right () -> Valid jsonRepr

58 Right () -> Valid jsonRepr

79−class Migratable (revisions :: [(Revision, Schema)]) where

80− mparse

81− :: Sing revisions

82− -> J.Value

83− -> ParseResult (JsonRepr (Snd (Head revisions)))

84−

85−instance

86− {-# OVERLAPPING #-}

87− ( TopLevel (Snd rev), SingI (Snd rev) )

88− => Migratable '[rev] where

89− mparse _ = parseAndValidateJson

90−

91−instance {-# OVERLAPPABLE #-}

92− ( Migratable (Tail revisions)

93− , MigrateSchema (Snd (Head (Tail revisions))) (Snd (Head revisions))

94− , SingI (Snd (Head revisions)))

95− => Migratable revisions where

96− mparse s v = case parseEither parseJSON v of

97− Left _ ->

98− migrate <$> (mparse (sTail s) v :: ParseResult (JsonRepr (Snd (Head (Tail revisions)))))

99− Right x -> Valid x

100−

101−parseAndValidateVersionedJson

102− :: forall proxy v. (SingI (AllVersions v), Migratable (AllVersions v))

103− => proxy v

104− -> J.Value

105− -> ParseResult (JsonRepr (Snd (Head (AllVersions v))))

106−parseAndValidateVersionedJson _ v = mparse (sing :: Sing (AllVersions v)) v

107−

108parseAndValidateWithMList

60parseAndValidateWithMList

61+ :: Monad m

109− :: MList revisions

62+ => MList m revisions

110 -> J.Value

63 -> J.Value

111− -> ParseResult (JsonRepr (Head revisions))

64+ -> m (ParseResult (JsonRepr (Head revisions)))

112−parseAndValidateWithMList MNil v = parseAndValidateJson v

65+parseAndValidateWithMList MNil v = pure $ parseAndValidateJson v

66+parseAndValidateWithMList (Tagged f :&& tl) v =

113−parseAndValidateWithMList ((:&&) p f tl) v = case parseAndValidateJsonBy p v of

67+ case parseAndValidateJsonBy Proxy v of

114− Valid a -> Valid a

68+ Valid a -> pure $ Valid a

69+ DecodingError _ -> do

115− DecodingError _ -> f <$> parseAndValidateWithMList tl v

70+ pr <- parseAndValidateWithMList tl v

71+ let pr' = f <$> pr

72+ sequence pr'

73+ ValidationError _ -> do

116− ValidationError _ -> f <$> parseAndValidateWithMList tl v

74+ pr <- parseAndValidateWithMList tl v

75+ let pr' = f <$> pr

76+ sequence pr'

117

118decodeAndValidateJson

78decodeAndValidateJson

119 :: forall schema

79 :: forall schema

@@ -124,24 +84,20 @@ decodeAndValidateJson bs = case decode bs of

124 Nothing -> DecodingError "malformed json"

84 Nothing -> DecodingError "malformed json"

125 Just x -> parseAndValidateJson x

85 Just x -> parseAndValidateJson x

126

127−decodeAndValidateVersionedJson

87+decodeAndValidateVersionedWithMList

128− :: (Migratable (AllVersions versioned), SingI (AllVersions versioned))

88+ :: Monad m

129 => proxy versioned

89 => proxy versioned

90+ -> MList m (MapSnd (AllVersions versioned))

130 -> BL.ByteString

91 -> BL.ByteString

131− -> ParseResult (JsonRepr (Snd (Head (AllVersions versioned))))

92+ -> m (ParseResult (JsonRepr (Head (MapSnd (AllVersions versioned)))))

132−decodeAndValidateVersionedJson vp bs = case decode bs of

93+decodeAndValidateVersionedWithMList _ mlist bs = case decode bs of

133− Nothing -> DecodingError "malformed json"

94+ Nothing -> pure $ DecodingError "malformed json"

134− Just x -> parseAndValidateVersionedJson vp x

95+ Just x -> parseAndValidateWithMList mlist x

135−

136−type family MapSnd (l :: [(a,k)]) = (r :: [k]) where

137− MapSnd '[] = '[]

138− MapSnd ( '(a, b) ': tl) = b ': MapSnd tl

139

140−decodeAndValidateVersionedWithMList

97+decodeAndValidateVersionedWithPureMList

141 :: proxy versioned

98 :: proxy versioned

142− -> MList (MapSnd (AllVersions versioned))

99+ -> MList F.Identity (MapSnd (AllVersions versioned))

143 -> BL.ByteString

100 -> BL.ByteString

144 -> ParseResult (JsonRepr (Head (MapSnd (AllVersions versioned))))

101 -> ParseResult (JsonRepr (Head (MapSnd (AllVersions versioned))))

145−decodeAndValidateVersionedWithMList _ mlist bs = case decode bs of

102+decodeAndValidateVersionedWithPureMList a b c =

146− Nothing -> DecodingError "malformed json"

103+ runIdentity $ decodeAndValidateVersionedWithMList a b c

147− Just x -> parseAndValidateWithMList mlist x

src/Data/Schematic/DSL.hsnew file+92

@@ -0,0 +1,92 @@

1+{-# LANGUAGE AllowAmbiguousTypes #-}

2+{-# LANGUAGE CPP #-}

4+module Data.Schematic.DSL where

6+import Data.Kind

7+import Data.Schematic.Lens

8+import Data.Schematic.Schema

9+import Data.Scientific

10+import Data.Singletons

11+import Data.Singletons.Prelude hiding ((:.))

12+import Data.Singletons.TypeLits

13+import Data.Tagged

14+import Data.Text as T

15+import Data.Union

16+import qualified Data.Vector as V

17+import Data.Vinyl

18+import Data.Vinyl.Functor

19+

20+

21+#if MIN_VERSION_base(4,12,0)

22+type Constructor a

23+ = forall fields b

24+ . (fields ~ FieldsOf a, FSubset fields b (FImage fields b), RMap fields)

25+ => Rec (Tagged fields :. FieldRepr) b

26+ -> JsonRepr ('SchemaObject fields)

27+#else

28+type Constructor a

29+ = forall fields b

30+ . (fields ~ FieldsOf a, FSubset fields b (FImage fields b))

31+ => Rec (Tagged fields :. FieldRepr) b

32+ -> JsonRepr ('SchemaObject fields)

33+#endif

34+withRepr :: Constructor a

35+withRepr = ReprObject . rmap (unTagged . getCompose) . fcast

36+

37+class Representable s where

38+ constructField :: Sing fn -> Proxy s -> Repr s -> FieldRepr '(fn, s)

39+

40+instance SingI so => Representable ('SchemaObject so) where

41+ constructField sfn _ o = withKnownSymbol sfn $ FieldRepr $ ReprObject o

42+

43+instance (SingI cs, SingI sa) => Representable ('SchemaArray cs sa) where

44+ constructField sfn _ a = withKnownSymbol sfn $ FieldRepr $ ReprArray a

45+

46+instance SingI cs => Representable ('SchemaText cs) where

47+ constructField sfn _ t = withKnownSymbol sfn $ FieldRepr $ ReprText t

48+

49+instance SingI cs => Representable ('SchemaNumber cs) where

50+ constructField sfn _ n = withKnownSymbol sfn $ FieldRepr $ ReprNumber n

51+

52+instance Representable 'SchemaBoolean where

53+ constructField sfn _ b = withKnownSymbol sfn $ FieldRepr $ ReprBoolean b

54+

55+instance SingI so => Representable ('SchemaOptional so) where

56+ constructField sfn _ o = withKnownSymbol sfn $ FieldRepr $ ReprOptional o

57+

58+instance SingI (h ': tl) => Representable ('SchemaUnion (h ': tl)) where

59+ constructField sfn _ u = withKnownSymbol sfn $ FieldRepr $ ReprUnion u

60+

61+construct :: Sing s -> Repr s -> JsonRepr s

62+construct s r = case s of

63+ SSchemaObject _ -> ReprObject r

64+ SSchemaArray _ _ -> ReprArray r

65+ SSchemaText _ -> ReprText r

66+ SSchemaNumber _ -> ReprNumber r

67+ SSchemaBoolean -> ReprBoolean r

68+ SSchemaOptional _ -> ReprOptional r

69+ SSchemaNull -> ReprNull

70+ SSchemaUnion ss -> case ss of

71+ SNil -> error "unconstructable union"

72+ SCons _ _ -> ReprUnion r

73+

74+type family FieldsOf (s :: Schema) :: [(Symbol, Schema)] where

75+ FieldsOf ('SchemaObject fs) = fs

76+

77+type FieldConstructor fn =

78+ forall byField fs. (byField ~ ByField fn fs (FIndex fn fs), Representable byField)

79+ => Repr byField

80+ -> (Tagged fs :. FieldRepr) '(fn, byField)

81+

82+field :: forall fn. KnownSymbol fn => FieldConstructor fn

83+field = Compose . Tagged . constructField (sing :: Sing fn) Proxy

84+

85+type family Repr (s :: Schema) = (ty :: Type) where

86+ Repr ('SchemaObject so) = Rec FieldRepr so

87+ Repr ('SchemaArray cs sa) = V.Vector (JsonRepr sa)

88+ Repr ('SchemaText cs) = Text

89+ Repr ('SchemaNumber cs) = Scientific

90+ Repr 'SchemaBoolean = Bool

91+ Repr ('SchemaOptional so) = Maybe (JsonRepr so)

92+ Repr ('SchemaUnion (h ': tl)) = Union JsonRepr (h ': tl)

src/Data/Schematic/Generator.hsnew file+91

@@ -0,0 +1,91 @@

1+module Data.Schematic.Generator where

3+import Data.Maybe

4+import Data.Schematic.Generator.Regex

5+import {-# SOURCE #-} Data.Schematic.Schema

6+import Data.Schematic.Verifier

7+import Data.Scientific

8+import Data.Text (Text, pack)

9+import qualified Data.Vector as V

10+import Test.SmallCheck.Series

11+

12+maxHigh :: Int

13+maxHigh = 30

14+

15+minLow :: Int

16+minLow = 2

17+

18+textLengthSeries :: Monad m => [VerifiedTextConstraint] -> Series m Text

19+textLengthSeries =

20+ \case

21+ [VTEq eq] -> pure $ pack $ take (fromIntegral eq) $ cycle "sample"

22+ [VTBounds ml mh] -> do

23+ let

24+ l = fromMaybe minLow (fromIntegral <$> ml) + 1

25+ h = fromMaybe maxHigh (fromIntegral <$> mh) - 1

26+ n <- generate $ \depth -> take depth [l .. h]

27+ pure $ pack $ take (fromIntegral n) $ cycle "sample"

28+ _ -> pure "error"

29+

30+textEnumSeries :: Monad m => [Text] -> Series m Text

31+textEnumSeries enum = generate $ \depth -> take depth enum

32+

33+textSeries :: Monad m => [DemotedTextConstraint] -> Series m Text

34+textSeries cs = do

35+ let mvcs = verifyTextConstraints cs

36+ case mvcs of

37+ Just vcs -> do

38+ n <- textSeries' vcs

39+ pure n

40+ Nothing -> pure "error"

41+

42+textSeries' :: Monad m => [VerifiedTextConstraint] -> Series m Text

43+textSeries' [] = pure "sample"

44+textSeries' vcs = do

45+ let enums = listToMaybe [x | VTEnum x <- vcs]

46+ case enums of

47+ Just e -> textEnumSeries e

48+ Nothing -> do

49+ let regexps = listToMaybe [x | VTRegex x _ _ <- vcs]

50+ case regexps of

51+ Just e -> regexSeries e

52+ Nothing -> textLengthSeries vcs

53+

54+numberSeries :: Monad m => [DemotedNumberConstraint] -> Series m Scientific

55+numberSeries cs = do

56+ let mvcs = verifyNumberConstraints cs

57+ case mvcs of

58+ Just vcs -> do

59+ n <- numberSeries' vcs

60+ pure $ n

61+ Nothing -> pure 0

62+

63+numberSeries' :: Monad m => VerifiedNumberConstraint -> Series m Scientific

64+numberSeries' =

65+ \case

66+ VNEq eq -> pure $ fromIntegral eq

67+ VNBounds ml mh -> do

68+ let l = fromMaybe minLow (fromIntegral <$> ml) + 1

69+ h = fromMaybe maxHigh (fromIntegral <$> mh) - 1

70+ n <- generate $ \depth -> take depth [l .. h]

71+ pure $ fromIntegral n

72+

73+arraySeries

74+ :: (Monad m, Serial m (JsonRepr s))

75+ => [DemotedArrayConstraint]

76+ -> Series m (V.Vector (JsonRepr s))

77+arraySeries cs = do

78+ let mvcs = verifyArrayConstraint cs

79+ case mvcs of

80+ Just vcs -> arraySeries' vcs

81+ Nothing -> pure V.empty

82+

83+arraySeries'

84+ :: forall m s. (Monad m, Serial m (JsonRepr s))

85+ => Maybe VerifiedArrayConstraint

86+ -> Series m (V.Vector (JsonRepr s))

87+arraySeries' ml = do

88+ objs <- V.replicateM (maybe minRepeat f ml) (series :: Series m (JsonRepr s))

89+ pure $ objs

90+ where

91+ f (VAEq l) = fromIntegral l

src/Data/Schematic/Generator/Regex.hsnew file+76

@@ -0,0 +1,76 @@

1+module Data.Schematic.Generator.Regex where

3+import Control.Monad

4+import Data.List

5+import Data.Maybe

6+import qualified Data.Set as S

7+import Data.Text (Text, unpack)

8+import Data.Text.Lazy (toStrict)

9+import Data.Text.Lazy.Builder (Builder, singleton, toLazyText)

10+import Test.SmallCheck.Series

11+import Text.Regex.TDFA.Pattern

12+import Text.Regex.TDFA.ReadRegex (parseRegex)

13+

14+

15+minRepeat :: Int

16+minRepeat = 2

17+

18+maxRepeat :: Int

19+maxRepeat = 10

20+

21+regexSeries :: (Monad m) => Text -> Series m Text

22+regexSeries regexp =

23+ case parseRegex . unpack $ regexp of

24+ Right (p, _) -> toStrict . toLazyText <$> regexSeries' p

25+ Left _ -> pure ""

26+

27+regexSeries' :: (Monad m) => Pattern -> Series m Builder

28+regexSeries' pt =

29+ case pt of

30+ PEmpty -> pure mempty

31+ PChar {..} -> pure $ singleton getPatternChar

32+ PAny {getPatternSet = PatternSet (Just cset) _ _ _} -> do

33+ x <- generate $ \depth -> take depth $ S.toList cset

34+ pure $ singleton x

35+ PAnyNot {getPatternSet = PatternSet (Just cset) _ _ _} -> do

36+ x <-

37+ generate $ \depth ->

38+ take depth $ notChars $ concatMap expandEscape $ S.toList cset

39+ pure $ singleton x

40+ PQuest p -> regexSeries' p \/ pure mempty

41+ PPlus p -> regexSeries' $ PBound 1 Nothing p

42+ PStar _ p -> regexSeries' $ PBound 0 Nothing p

43+ PBound low mhigh p -> do

44+ let high = fromMaybe (low + maxRepeat) mhigh

45+ n <- generate $ \depth -> take depth [low .. high]

46+ decDepth $ do

47+ ps <- replicateM n $ regexSeries' p

48+ pure $ mconcat ps

49+ PConcat ps -> mconcat <$> mapM regexSeries' ps

50+ POr xs -> regexSeries' =<< (generate $ \depth -> take depth xs)

51+ PDot _ -> do

52+ x <- generate $ \depth -> take depth $ notChars []

53+ pure $ singleton x

54+ PEscape {..} -> do

55+ x <- generate $ \depth -> take depth $ expandEscape getPatternChar

56+ pure $ singleton x

57+ PCarat _ -> pure mempty

58+ PDollar _ -> pure mempty

59+ _ -> pure mempty

60+ where

61+ notChars = ([' ' .. '~'] \\)

62+ expandEscape ch =

63+ case ch of

64+ 'n' -> "\n"

65+ 't' -> "\t"

66+ 'r' -> "\r"

67+ 'f' -> "\f"

68+ 'a' -> "\a"

69+ 'e' -> "\ESC"

70+ 'd' -> ['0' .. '9']

71+ 'w' -> ['0' .. '9'] ++ '_' : ['a' .. 'z'] ++ ['A' .. 'Z']

72+ 's' -> "\9\32"

73+ 'D' -> notChars $ ['0' .. '9']

74+ 'W' -> notChars $ ['0' .. '9'] ++ '_' : ['a' .. 'z'] ++ ['A' .. 'Z']

75+ 'S' -> notChars "\9\32"

76+ ch' -> [ch']

src/Data/Schematic/Helpers.hsnew file+59

@@ -0,0 +1,59 @@

1+module Data.Schematic.Helpers where

3+import Data.Schematic.Schema

4+import GHC.TypeLits

7+type UUIDRegex =

8+ 'TRegex "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"

10+type IsUUID = '[UUIDRegex]

11+

12+-- [ "1985-04-12T23:20:50.52Z"

13+-- , "1996-12-19T16:39:57-08:00"

14+-- , "1990-12-31T23:59:60Z"

15+-- , "1990-12-31T15:59:60-08:00"

16+-- , "1937-01-01T12:00:27.87+00:20"

17+-- ]

18+

19+-- components

20+type ISO8601Date = "[1-9][0-9]{3}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])"

21+

22+type ISO8601Time = "([0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]"

23+

24+type ISO8601DateTime =

25+ AppendSymbol

26+ ISO8601Date

27+ (AppendSymbol "(T" (AppendSymbol ISO8601Time ")?"))

28+

29+type ISO8601UTC = "(Z|\\+00:00)"

30+

31+type ISO8601DateTimeUTC =

32+ AppendSymbol ISO8601Date (AppendSymbol "T" (AppendSymbol ISO8601Time ISO8601UTC))

33+

34+type ISO8601TZ = "\\+[0-1][0-9]:[0-6][0-9]"

35+

36+type ISO8601DateTimeZoned =

37+ AppendSymbol ISO8601Date (AppendSymbol "T" (AppendSymbol ISO8601Time ISO8601TZ))

38+

39+-- regexes

40+type ISO8601DateRegex = 'TRegex ISO8601Date

41+

42+type ISO8601TimeRegex = 'TRegex ISO8601Time

43+

44+type ISO8601DateTimeRegex = 'TRegex ISO8601DateTime

45+

46+type ISO8601DateTimeRegexUTC = 'TRegex ISO8601DateTimeUTC

47+

48+type ISO8601DateTimeRegexZoned = 'TRegex ISO8601DateTimeZoned

49+

50+-- constraints

51+type IsDate = '[ISO8601DateRegex]

52+

53+type IsTime = '[ISO8601TimeRegex]

54+

55+type IsDateTime = '[ISO8601DateTimeRegex]

56+

57+type IsZonedDateTime = '[ISO8601DateTimeRegexZoned]

58+

59+type IsUTCDateTime = '[ISO8601DateTimeRegexUTC]

src/Data/Schematic/Instances.hs+4

@@ -4,6 +4,7 @@

4module Data.Schematic.Instances where

6import Data.Scientific

7+import Data.Text (Text, pack)

7import Data.Vector as V

8import Data.Vector as V

8import Data.Vinyl

9import Data.Vinyl

9import Test.SmallCheck.Series

10import Test.SmallCheck.Series

@@ -21,3 +22,6 @@ instance Serial m a => Serial m (V.Vector a) where

22instance Monad m => Serial m Scientific where

23instance Monad m => Serial m Scientific where

23 series = scientific <$> series <*> series

24 series = scientific <$> series <*> series

25+

26+instance Monad m => Serial m Text where

27+ series = pack <$> series

src/Data/Schematic/JsonSchema.hs+113−67

@@ -1,78 +1,124 @@

1+{-# LANGUAGE AllowAmbiguousTypes #-}

1{-# LANGUAGE RecordWildCards #-}

2{-# LANGUAGE RecordWildCards #-}

2{-# LANGUAGE OverloadedLabels #-}

3{-# LANGUAGE OverloadedLabels #-}

4+{-# LANGUAGE TemplateHaskell #-}

4−module Data.Schematic.JsonSchema where

6+module Data.Schematic.JsonSchema

7+ ( toJsonSchema

8+ , toJsonSchema'

9+ ) where

11+import Control.Monad.State.Strict

6−import Data.Aeson

12+import Data.Aeson as J

7−import qualified Data.Map as M

13+import Data.Foldable as F

14+import Data.HashMap.Strict as H

15+import Data.List as L

16+import Data.List.NonEmpty as NE

8−import Data.Schematic.Schema

17+import Data.Schematic.Schema as S

18+import Data.Set as Set

19+import Data.Singletons

9−import Data.Text

20+import Data.Text

21+import Data.Traversable

22+import JSONSchema.Draft4.Schema as D4

23+import JSONSchema.Validator.Draft4 as D4

12−draft6 :: Text

26+draft4 :: Text

13−draft6 = "http://json-schema.org/draft-06/schema#"

27+draft4 = "http://json-schema.org/draft-04/schema#"

15−data JsonSchemaType

29+textConstraint :: DemotedTextConstraint -> State D4.Schema ()

16− = JObject

30+textConstraint (DTEq n) = modify $ \s -> s

17− | JArray

31+ { _schemaMinLength = pure $ fromIntegral n

18− | JNumber

32+ , _schemaMaxLength = pure $ fromIntegral n }

19− | JString

33+textConstraint (DTLe n) = modify $ \s -> s

20− | JNull

34+ { _schemaMaxLength = pure . fromIntegral $ n }

35+textConstraint (DTLt n) =

36+ let n' = if n == 0 then 0 else n - 1

37+ in modify $ \s -> s { _schemaMaxLength = pure . fromIntegral $ n' }

38+textConstraint (DTGt n) = modify $ \s -> s

39+ { _schemaMinLength = pure . fromIntegral $ n + 1 }

40+textConstraint (DTGe n) = modify $ \s -> s

41+ { _schemaMinLength = pure . fromIntegral $ n }

42+textConstraint (DTRegex r) = modify $ \s -> s { _schemaPattern = pure r }

43+textConstraint (DTEnum ss) =

44+ let ss' = if F.length ss == 0 then [] else NE.fromList $ J.String <$> ss

45+ in modify $ \s -> s { _schemaEnum = pure ss' }

22−instance ToJSON JsonSchemaType where

47+numberConstraint :: DemotedNumberConstraint -> State D4.Schema ()

23− toJSON JObject = "object"

48+numberConstraint (DNLe n) = modify $ \s -> s

24− toJSON JArray = "array"

49+ { _schemaMaximum = pure . fromIntegral $ n }

25− toJSON JNumber = "number"

50+numberConstraint (DNLt n) = modify $ \s -> s

26− toJSON JString = "string"

51+ { _schemaMaximum = pure . fromIntegral $ n

27− toJSON JNull = "null"

52+ , _schemaExclusiveMaximum = pure True }

53+numberConstraint (DNGt n) = modify $ \s -> s

54+ { _schemaMinimum = pure . fromIntegral $ n

55+ , _schemaExclusiveMinimum = pure True }

56+numberConstraint (DNGe n) = modify $ \s -> s

57+ { _schemaMinimum = pure . fromIntegral $ n }

58+numberConstraint (DNEq n) = modify $ \s -> s

59+ { _schemaMinimum = pure $ fromIntegral n

60+ , _schemaMaximum = pure $ fromIntegral n }

29−data JsonSchema

62+arrayConstraint :: DemotedArrayConstraint -> State D4.Schema ()

30− = RootSchema

63+arrayConstraint (DALe n) = modify $ \s -> s

31− { type_ :: JsonSchemaType

64+ { _schemaMaxItems = pure . fromIntegral $ n }

32− , title :: Text

65+arrayConstraint (DALt n) =

33− , items :: Maybe Text

66+ let n' = if n == 0 then 0 else n - 1

34− , schemaDraft :: Text }

67+ in modify $ \s -> s { _schemaMaxItems = pure . fromIntegral $ n' }

35− | JsonObject

68+arrayConstraint (DAGt n) = modify $ \s -> s

36− { type_ :: JsonSchemaType

69+ { _schemaMinItems = pure . fromIntegral $ n + 1 }

37− , properties :: M.Map Text JsonSchema

70+arrayConstraint (DAGe n) = modify $ \s -> s

38− , additionalProperties :: Bool

71+ { _schemaMinItems = pure . fromIntegral $ n }

39− , required :: [Text]

72+arrayConstraint (DAEq n) = modify $ \s -> s

40− , schemaDraft :: Text }

73+ { _schemaMinItems = pure $ fromIntegral n

41− | JsonOptional JsonSchema

74+ , _schemaMaxItems = pure $ fromIntegral n }

43−jsonObject :: M.Map Text JsonSchema -> JsonSchema

76+toJsonSchema

44−jsonObject m = JsonObject

77+ :: forall proxy schema

45− { type_ = JObject

78+ . SingI schema

46− , properties = m

79+ => proxy (schema :: S.Schema)

47− , additionalProperties = False

80+ -> Maybe D4.Schema

48− , required = M.keys $ M.filter

81+toJsonSchema _ = do

49− (\case; JsonOptional _ -> False; _ -> True) m

82+ js <- toJsonSchema' $ fromSing (sing :: Sing schema)

50− , schemaDraft = draft6 }

83+ pure $ js { _schemaVersion = pure draft4 }

52−instance ToJSON JsonSchema where

85+toJsonSchema'

53− toJSON RootSchema{..} = object [ "type" .= type_, "title" .= title ]

86+ :: DemotedSchema

54− toJSON JsonObject{..} =

87+ -> Maybe D4.Schema

55− object

88+toJsonSchema' = \case

56− [ "type" .= type_

89+ DSchemaText tcs ->

57− , "properties" .= properties

90+ pure $ execState (traverse_ textConstraint tcs) $ emptySchema

58− , "additionalProperties" .= additionalProperties

91+ { _schemaType = pure $ TypeValidatorString D4.SchemaString }

59− , "required" .= required

92+ DSchemaNumber ncs ->

60− , "schemaDraft" .= schemaDraft]

93+ pure $ execState (traverse_ numberConstraint ncs) $ emptySchema

61−

94+ { _schemaType = pure $ TypeValidatorString D4.SchemaNumber }

62−-- Root schema:

95+ DSchemaBoolean -> pure $ emptySchema

63−--

96+ { _schemaType = pure $ TypeValidatorString D4.SchemaBoolean }

64−-- {

97+ DSchemaObject objs -> do

65−-- "title": "root",

98+ res <- for objs $ \(n,s) -> do

66−-- "items": {

99+ s' <- toJsonSchema' s

67−-- "title": "array item"

100+ pure (n, s')

68−-- }

101+ let

69−-- }

102+ nonOpt = \case

70−

103+ (_, DSchemaOptional _) -> False

71−-- toSchema :: JsonRepr a -> JsonSchema

104+ _ -> True

72−-- toSchema = \case

105+ pure $ emptySchema

73−-- ReprText t ->

106+ { _schemaType = pure $ TypeValidatorString D4.SchemaObject

74−-- ReprNumber n ->

107+ , _schemaRequired = pure $ Set.fromList $ fst <$> L.filter nonOpt objs

75−-- ReprNull ->

108+ , _schemaProperties = pure $ H.fromList res }

76−-- ReprArray arr ->

109+ DSchemaArray acs sch -> do

77−-- ReprObject obj ->

110+ res <- toJsonSchema' sch

78−-- ReprOptional mv ->

111+ pure $ execState (traverse_ arrayConstraint acs) $ emptySchema

112+ { _schemaType = pure $ TypeValidatorString D4.SchemaArray

113+ , _schemaItems = pure $ ItemsObject res }

114+ DSchemaNull -> pure $ emptySchema

115+ { _schemaType = pure $ TypeValidatorString D4.SchemaNull }

116+ DSchemaOptional sch -> do

117+ snull <- toJsonSchema' DSchemaNull

118+ sres <- toJsonSchema' sch

119+ pure $ emptySchema { _schemaOneOf = pure (snull :| [sres]) }

120+ DSchemaUnion sch -> do

121+ schemaUnion <- traverse toJsonSchema' sch >>= \case

122+ [] -> Nothing

123+ x -> Just x

124+ pure $ emptySchema { _schemaAnyOf = pure $ NE.fromList schemaUnion }

src/Data/Schematic/Lens.hs+168−27

@@ -3,64 +3,205 @@

3{-# LANGUAGE AllowAmbiguousTypes #-}

4{-# LANGUAGE InstanceSigs #-}

6−module Data.Schematic.Lens where

6+module Data.Schematic.Lens

7+ ( FIndex

8+ , FElem(..)

9+ , FImage

10+ , FSubset(..)

11+ , obj

12+ , arr

13+ , uni

14+ , txt

15+ , num

16+ , opt

17+ , bln

18+ , textRepr

19+ , numberRepr

20+ , boolRepr

21+ , arrayRepr

22+ , objectRepr

23+ , optionalRepr

24+ ) where

8−import Data.Proxy

26+import Data.Profunctor

9import Data.Schematic.Schema

27import Data.Schematic.Schema

28+import Data.Scientific

29+import Data.Singletons

30+import Data.Text

31+import Data.Union

32+import Data.Vector as V

10import Data.Vinyl

33import Data.Vinyl

11import Data.Vinyl.Functor

34import Data.Vinyl.Functor

12import Data.Vinyl.TypeLevel (Nat(..))

35import Data.Vinyl.TypeLevel (Nat(..))

13−import GHC.TypeLits (Symbol)

36+import GHC.TypeLits (Symbol, KnownSymbol)

16-- | A partial relation that gives the index of a value in a list.

39-- | A partial relation that gives the index of a value in a list.

17type family FIndex (r :: Symbol) (rs :: [(Symbol, Schema)]) :: Nat where

40type family FIndex (r :: Symbol) (rs :: [(Symbol, Schema)]) :: Nat where

18− FIndex r ( '(fn, s) ': rs) = 'Z

41+ FIndex r ( '(r, s) ': rs) = 'Z

19− FIndex r ( s ': rs) = 'S (FIndex r rs)

42+ FIndex r ( s ': rs) = 'S (FIndex r rs)

43+

44+type Flens fn f g rs i

45+ = Functor g

46+ => (f '(fn, (ByField fn rs i)) -> g (f '(fn, (ByField fn rs i))))

47+ -> Rec f rs

48+ -> g (Rec f rs)

49+

50+type FGetter fn f rs i = Rec f rs -> f '(fn, (ByField fn rs i))

21class i ~ FIndex fn rs => FElem (fn :: Symbol) (rs :: [(Symbol, Schema)]) (i :: Nat) where

52class i ~ FIndex fn rs => FElem (fn :: Symbol) (rs :: [(Symbol, Schema)]) (i :: Nat) where

22− type ByRevision fn rs i :: Schema

53+ type ByField fn rs i :: Schema

23− flens

54+ flens :: Flens fn f g rs i

24− :: Functor g

25− => proxy fn

26− -> (FieldRepr '(fn, (ByRevision fn rs i)) -> g (FieldRepr '(fn, (ByRevision fn rs i))))

27− -> Rec FieldRepr rs

28− -> g (Rec FieldRepr rs)

30 -- | For Vinyl users who are not using the @lens@ package, we provide a getter.

56 -- | For Vinyl users who are not using the @lens@ package, we provide a getter.

31− fget

57+ fget :: FGetter fn f rs i

32− :: proxy fn

33− -> Rec FieldRepr rs

34− -> FieldRepr '(fn, (ByRevision fn rs i))

36 -- | For Vinyl users who are not using the @lens@ package, we also provide a

59 -- | For Vinyl users who are not using the @lens@ package, we also provide a

37 -- setter. In general, it will be unambiguous what field is being written to,

60 -- setter. In general, it will be unambiguous what field is being written to,

38 -- and so we do not take a proxy argument here.

61 -- and so we do not take a proxy argument here.

39 fput

62 fput

40− :: FieldRepr '(fn, ByRevision fn rs i)

63+ :: f '(fn, ByField fn rs i)

41− -> Rec FieldRepr rs

64+ -> Rec f rs

42− -> Rec FieldRepr rs

65+ -> Rec f rs

44instance FElem fn ('(fn, r) ': rs) 'Z where

67instance FElem fn ('(fn, r) ': rs) 'Z where

45− type ByRevision fn ('(fn, r) ': rs) 'Z = r

68+ type ByField fn ('(fn, r) ': rs) 'Z = r

47− flens _ f (x :& xs) = fmap (:& xs) (f x)

70+ flens f (x :& xs) = fmap (:& xs) (f x)

48 {-# INLINE flens #-}

71 {-# INLINE flens #-}

50− fget k = getConst . flens k Const

73+ fget = getConst . flens Const

51 {-# INLINE fget #-}

74 {-# INLINE fget #-}

53− fput y = getIdentity . flens Proxy (\_ -> Identity y)

76+ fput y = getIdentity . flens (\_ -> Identity y)

54 {-# INLINE fput #-}

77 {-# INLINE fput #-}

56instance (FIndex r (s ': rs) ~ 'S i, FElem r rs i) => FElem r (s ': rs) ('S i) where

79instance (FIndex r (s ': rs) ~ 'S i, FElem r rs i) => FElem r (s ': rs) ('S i) where

57− type ByRevision fn (s ': rs) ('S i) = ByRevision fn rs i

80+ type ByField r (s ': rs) ('S i) = ByField r rs i

59− flens p f (x :& xs) = fmap (x :&) (flens p f xs)

82+ flens f (x :& xs) = fmap (x :&) (flens f xs)

60 {-# INLINE flens #-}

83 {-# INLINE flens #-}

62− fget k = getConst . flens k Const

85+ fget = getConst . flens Const

63 {-# INLINE fget #-}

86 {-# INLINE fget #-}

65− fput y = getIdentity . flens Proxy (\_ -> Identity y)

88+ fput y = getIdentity . flens (\_ -> Identity y)

66 {-# INLINE fput #-}

89 {-# INLINE fput #-}

90+

91+-- This is an internal convenience helpers stolen from the @lens@ library.

92+lens

93+ :: Functor f

94+ => (t -> s)

95+ -> (t -> a -> b)

96+ -> (s -> f a)

97+ -> t

98+ -> f b

99+lens sa sbt afb s = fmap (sbt s) $ afb (sa s)

100+{-# INLINE lens #-}

101+

102+type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t)

103+

104+type Iso' s a = Iso s s a a

105+

106+iso

107+ :: (s -> a) -> (b -> t)

108+ -> Iso s t a b

109+iso sa bt = dimap sa (fmap bt)

110+{-# INLINE iso #-}

111+

112+-- | A partial relation that gives the indices of a sublist in a larger list.

113+type family FImage (rs :: [(Symbol, Schema)]) (ss :: [(Symbol, Schema)]) :: [Nat] where

114+ FImage '[] ss = '[]

115+ FImage ('(fn,s) ': rs) ss = FIndex fn ss ': FImage rs ss

116+

117+class is ~ FImage rs ss

118+ => FSubset (rs :: [(Symbol, Schema)]) (ss :: [(Symbol, Schema)]) is where

119+ -- | This is a lens into a slice of the larger record. Morally, we have:

120+ --

121+ -- > fsubset :: Lens' (Rec FieldRepr ss) (Rec FieldRepr rs)

122+ fsubset

123+ :: Functor g

124+ => (Rec f rs -> g (Rec f rs))

125+ -> Rec f ss

126+ -> g (Rec f ss)

127+

128+ -- | The getter of the 'fsubset' lens is 'fcast', which takes a larger record

129+ -- to a smaller one by forgetting fields.

130+ fcast

131+ :: Rec f ss

132+ -> Rec f rs

133+ fcast = getConst . fsubset Const

134+ {-# INLINE fcast #-}

135+

136+ -- | The setter of the 'fsubset' lens is 'freplace', which allows a slice of

137+ -- a record to be replaced with different values.

138+ freplace

139+ :: Rec f rs

140+ -> Rec f ss

141+ -> Rec f ss

142+ freplace rs = getIdentity . fsubset (\_ -> Identity rs)

143+ {-# INLINE freplace #-}

144+

145+instance FSubset '[] ss '[] where

146+ fsubset = lens (const RNil) const

147+

148+instance

149+ ( ByField fn ss i ~ s

150+ , FElem fn ss i

151+ , FSubset rs ss is) => FSubset ( '(fn,s) ': rs) ss (i ': is) where

152+ fsubset = lens (\ss -> fget @fn ss :& fcast ss) set

153+ where

154+ set :: Rec f ss -> Rec f ( '(fn,s) ': rs) -> Rec f ss

155+ set ss (r :& rs) = fput r $ freplace rs ss

156+

157+-- A bunch of @Iso@morphisms

158+textRepr

159+ :: (KnownSymbol fn, SingI cs)

160+ => Iso' (FieldRepr '(fn, ('SchemaText cs))) Text

161+textRepr = iso (\(FieldRepr (ReprText t)) -> t) (FieldRepr . ReprText)

162+

163+numberRepr

164+ :: (KnownSymbol fn, SingI cs)

165+ => Iso' (FieldRepr '(fn, ('SchemaNumber cs))) Scientific

166+numberRepr = iso (\(FieldRepr (ReprNumber n)) -> n) (FieldRepr . ReprNumber)

167+

168+boolRepr

169+ :: (KnownSymbol fn)

170+ => Iso' (FieldRepr '(fn, 'SchemaBoolean)) Bool

171+boolRepr = iso (\(FieldRepr (ReprBoolean b)) -> b) (FieldRepr . ReprBoolean)

172+

173+arrayRepr

174+ :: (KnownSymbol fn, SingI cs, SingI schema)

175+ => Iso' (FieldRepr '(fn, ('SchemaArray cs schema))) (V.Vector (JsonRepr schema))

176+arrayRepr = iso (\(FieldRepr (ReprArray a)) -> a) (FieldRepr . ReprArray)

177+

178+objectRepr

179+ :: (KnownSymbol fn, SingI fields)

180+ => Iso' (FieldRepr '(fn, ('SchemaObject fields))) (Rec FieldRepr fields)

181+objectRepr = iso (\(FieldRepr (ReprObject o)) -> o) (FieldRepr . ReprObject)

182+

183+optionalRepr

184+ :: (KnownSymbol fn, SingI schema)

185+ => Iso' (FieldRepr '(fn, ('SchemaOptional schema))) (Maybe (JsonRepr schema))

186+optionalRepr = iso (\(FieldRepr (ReprOptional r)) -> r) (FieldRepr . ReprOptional)

187+

188+obj :: Iso' (JsonRepr ('SchemaObject fields)) (Rec FieldRepr fields)

189+obj = iso (\(ReprObject r) -> r) ReprObject

190+

191+arr :: Iso' (JsonRepr ('SchemaArray cs schema)) (V.Vector (JsonRepr schema))

192+arr = iso (\(ReprArray r) -> r) ReprArray

193+

194+uni :: Iso' (JsonRepr ('SchemaUnion (h ': tl))) (Union JsonRepr (h ': tl))

195+uni = iso (\(ReprUnion u) -> u) ReprUnion

196+

197+txt :: Iso' (JsonRepr ('SchemaText cs)) Text

198+txt = iso (\(ReprText t) -> t) ReprText

199+

200+num :: Iso' (JsonRepr ('SchemaNumber cs)) Scientific

201+num = iso (\(ReprNumber t) -> t) ReprNumber

202+

203+bln :: Iso' (JsonRepr 'SchemaBoolean) Bool

204+bln = iso (\(ReprBoolean b) -> b) ReprBoolean

205+

206+opt :: Iso' (JsonRepr ('SchemaOptional schema)) (Maybe (JsonRepr schema))

207+opt = iso (\(ReprOptional o) -> o) ReprOptional

src/Data/Schematic/Migration.hs+48−14

@@ -1,13 +1,19 @@

1{-# LANGUAGE AllowAmbiguousTypes #-}

2+{-# LANGUAGE CPP #-}

2−{-# LANGUAGE TemplateHaskell #-}

3+{-# LANGUAGE TemplateHaskell #-}

4module Data.Schematic.Migration where

5module Data.Schematic.Migration where

6import Data.Kind

7import Data.Kind

8+import Data.Schematic.DSL

9+import Data.Schematic.Lens

7import Data.Schematic.Path

10import Data.Schematic.Path

8import Data.Schematic.Schema

11import Data.Schematic.Schema

9−import Data.Singletons.Prelude hiding (All)

12+import Data.Singletons.Prelude hiding ((:.), All)

10import Data.Singletons.TypeLits

13import Data.Singletons.TypeLits

14+import Data.Tagged

15+import Data.Vinyl

16+import Data.Vinyl.Functor

13data Path

19data Path

@@ -37,8 +43,8 @@ type family SchemaByKey (fs :: [(Symbol, Schema)]) (s :: Symbol) :: Schema where

37 SchemaByKey ( '(a, s) ': tl) fn = SchemaByKey tl fn

43 SchemaByKey ( '(a, s) ': tl) fn = SchemaByKey tl fn

39type family DeleteKey (acc :: [(Symbol, Schema)]) (fn :: Symbol) (fs :: [(Symbol, Schema)]) :: [(Symbol, Schema)] where

45type family DeleteKey (acc :: [(Symbol, Schema)]) (fn :: Symbol) (fs :: [(Symbol, Schema)]) :: [(Symbol, Schema)] where

40− DeleteKey acc fn ('(fn, a) ': tl) = acc :++ tl

46+ DeleteKey acc fn ('(fn, a) ': tl) = acc ++ tl

41− DeleteKey acc fn (fna ': tl) = acc :++ (fna ': tl)

47+ DeleteKey acc fn (fna ': tl) = acc ++ (fna ': tl)

43type family UpdateKey

49type family UpdateKey

44 (fn :: Symbol)

50 (fn :: Symbol)

@@ -91,7 +97,8 @@ type family ElemOf (e :: k) (l :: [(a,k)]) :: Constraint where

91type family AllVersions (vd :: Versioned) :: [(Revision, Schema)] where

97type family AllVersions (vd :: Versioned) :: [(Revision, Schema)] where

92 AllVersions ('Versioned s ms) = Reverse (AllVersions' '[ '("initial", s) ] ms)

98 AllVersions ('Versioned s ms) = Reverse (AllVersions' '[ '("initial", s) ] ms)

94−type family AllVersions' (acc :: [(Revision, Schema)]) (ms :: [Migration]) = (r :: [(Revision, Schema)]) where

100+type family AllVersions' (acc :: [(Revision, Schema)]) (ms :: [Migration])

101+ = (r :: [(Revision, Schema)]) where

95 AllVersions' acc '[] = acc

102 AllVersions' acc '[] = acc

96 AllVersions' ( '(rh, sh) ': tl ) (m ': ms) =

103 AllVersions' ( '(rh, sh) ': tl ) (m ': ms) =

97 AllVersions' ( '(rh, sh) ': ApplyMigration m sh ': tl ) ms

104 AllVersions' ( '(rh, sh) ': ApplyMigration m sh ': tl ) ms

@@ -99,9 +106,6 @@ type family AllVersions' (acc :: [(Revision, Schema)]) (ms :: [Migration]) = (r

99type family TopVersion (rs :: [(Revision, Schema)]) :: Schema where

106type family TopVersion (rs :: [(Revision, Schema)]) :: Schema where

100 TopVersion ( '(rh, sh) ': tl) = sh

107 TopVersion ( '(rh, sh) ': tl) = sh

101

108

102−class MigrateSchema (a :: Schema) (b :: Schema) where

103− migrate :: JsonRepr a -> JsonRepr b

104−

105data Action = AddKey Symbol Schema | Update Schema | DeleteKey Symbol

109data Action = AddKey Symbol Schema | Update Schema | DeleteKey Symbol

106

110

107data instance Sing (a :: Action) where

111data instance Sing (a :: Action) where

@@ -141,13 +145,43 @@ data instance Sing (v :: Versioned) where

141 -> Sing (ms :: [Migration]) -- a bunch of migrations

145 -> Sing (ms :: [Migration]) -- a bunch of migrations

142 -> Sing ('Versioned s ms)

146 -> Sing ('Versioned s ms)

143

147

148+type DataMigration s m h = Tagged s (JsonRepr h -> m (JsonRepr s))

149+

144−data MList :: [Schema] -> Type where

150+data MList :: (Type -> Type) -> [Schema] -> Type where

145− MNil :: (SingI s, TopLevel s) => MList '[s]

151+ MNil :: (Monad m, SingI s, TopLevel s) => MList m '[s]

146 (:&&)

152 (:&&)

147 :: (TopLevel s, SingI s)

153 :: (TopLevel s, SingI s)

148− => proxy s

154+ => DataMigration s m h

149− -> (JsonRepr h -> JsonRepr s)

150− -> MList (h ': tl)

155+ -> MList m (h ': tl)

151− -> MList (s ': h ': tl)

156+ -> MList m (s ': h ': tl)

152

157

153infixr 7 :&&

158infixr 7 :&&

159+

160+#if MIN_VERSION_base(4,12,0)

161+migrateObject

162+ :: forall m fs fh. (FSubset fs fs (FImage fs fs), Monad m, RMap fh, RMap fs)

163+ => (Rec (Tagged fs :. FieldRepr) fh -> m (Rec (Tagged fs :. FieldRepr) fs))

164+ -> Tagged ('SchemaObject fs) (JsonRepr ('SchemaObject fh) -> m (JsonRepr ('SchemaObject fs)))

165+#else

166+migrateObject

167+ :: forall m fs fh. (FSubset fs fs (FImage fs fs), Monad m)

168+ => (Rec (Tagged fs :. FieldRepr) fh -> m (Rec (Tagged fs :. FieldRepr) fs))

169+ -> Tagged ('SchemaObject fs) (JsonRepr ('SchemaObject fh) -> m (JsonRepr ('SchemaObject fs)))

170+#endif

171+migrateObject f = Tagged $ \(ReprObject r) -> do

172+ res <- f $ rmap (Compose . Tagged) r

173+ pure $ withRepr @('SchemaObject fs) res

174+

175+shrinkObject

176+ :: forall rs ss m

177+ . ( Monad m, FSubset rs ss (FImage rs ss) )

178+ => Tagged

179+ ('SchemaObject rs)

180+ (JsonRepr ('SchemaObject ss) -> m (JsonRepr ('SchemaObject rs)))

181+shrinkObject = Tagged $ \(ReprObject r) -> pure $ ReprObject $ fcast r

182+

183+type family MapSnd (l :: [(a,k)]) = (r :: [k]) where

184+ MapSnd '[] = '[]

185+ MapSnd ( '(a, b) ': tl) = b ': MapSnd tl

186+

187+type MigrationList m vs = MList m (MapSnd (AllVersions vs))

src/Data/Schematic/Path.hs+6−17

@@ -1,9 +1,6 @@

1module Data.Schematic.Path where

3import Data.Foldable as F

4−import Data.Monoid

5−import Data.Schematic.Utils

6−import Data.Singletons

7import Data.Singletons.Prelude

4import Data.Singletons.Prelude

8import Data.Singletons.TypeLits

5import Data.Singletons.TypeLits

9import Data.Text as T

6import Data.Text as T

@@ -12,16 +9,8 @@ import Data.Text as T

12data PathSegment = Key Symbol | Ix Nat

9data PathSegment = Key Symbol | Ix Nat

14data instance Sing (jp :: PathSegment) where

11data instance Sing (jp :: PathSegment) where

15− SKey :: (KnownSymbol k, Known (Sing k)) => Sing (k :: Symbol) -> Sing ('Key k)

12+ SKey :: (SingI k) => Sing (k :: Symbol) -> Sing ('Key k)

16− SIx :: (KnownNat n, Known (Sing n)) => Sing (n :: Nat) -> Sing ('Ix n)

13+ SIx :: (SingI n) => Sing (n :: Nat) -> Sing ('Ix n)

17−

18−instance (KnownSymbol k, Known (Sing k))

19− => Known (Sing ('Key k)) where

20− known = SKey known

21−

22−instance (KnownNat n, Known (Sing n))

23− => Known (Sing ('Ix n)) where

24− known = SIx known

26data DemotedPathSegment = DKey Text | DIx Integer

15data DemotedPathSegment = DKey Text | DIx Integer

27 deriving (Show)

16 deriving (Show)

@@ -35,10 +24,10 @@ demotePath = go []

35 where

24 where

36 go :: [DemotedPathSegment] -> Sing (ps :: [PathSegment]) -> [DemotedPathSegment]

25 go :: [DemotedPathSegment] -> Sing (ps :: [PathSegment]) -> [DemotedPathSegment]

37 go acc SNil = acc

26 go acc SNil = acc

38− go acc (SCons p ps) = go (acc ++ [demote p]) ps

27+ go acc (SCons p ps) = go (acc ++ [demotePathSeg p]) ps

39− demote :: Sing (ps :: PathSegment) -> DemotedPathSegment

28+ demotePathSeg :: Sing (ps :: PathSegment) -> DemotedPathSegment

40− demote (SKey s) = DKey $ T.pack $ symbolVal s

29+ demotePathSeg (SKey s) = DKey $ T.pack $ withKnownSymbol s $ symbolVal s

41− demote (SIx n) = DIx $ natVal n

30+ demotePathSeg (SIx n) = DIx $ withKnownNat n $ fromIntegral $ natVal n

43demotedPathToText :: [DemotedPathSegment] -> JSONPath

32demotedPathToText :: [DemotedPathSegment] -> JSONPath

44demotedPathToText = JSONPath . F.foldl' renderPathSegment ""

33demotedPathToText = JSONPath . F.foldl' renderPathSegment ""

src/Data/Schematic/Schema.hs+314−39

@@ -1,35 +1,37 @@

1{-# LANGUAGE AllowAmbiguousTypes #-}

2+{-# LANGUAGE CPP #-}

2−{-# LANGUAGE OverloadedLists #-}

3+{-# LANGUAGE OverloadedLists #-}

3−{-# LANGUAGE OverloadedStrings #-}

4+{-# LANGUAGE OverloadedStrings #-}

4{-# OPTIONS_GHC -fprint-explicit-kinds #-}

5{-# OPTIONS_GHC -fprint-explicit-kinds #-}

6module Data.Schematic.Schema where

7module Data.Schematic.Schema where

8−import Control.Applicative ()

9+import Control.Applicative ((<|>))

9import Control.Monad

10import Control.Monad

10import Data.Aeson as J

11import Data.Aeson as J

11import Data.Aeson.Types as J

12import Data.Aeson.Types as J

12import Data.HashMap.Strict as H

13import Data.HashMap.Strict as H

13import Data.Kind

14import Data.Kind

14import Data.Maybe

15import Data.Maybe

16+import Data.Schematic.Generator

15import Data.Schematic.Instances ()

17import Data.Schematic.Instances ()

16import Data.Scientific

18import Data.Scientific

17−import Data.Singletons.Prelude.List hiding (All)

19+import Data.Singletons.Prelude.List hiding (All, Union)

18import Data.Singletons.TH

20import Data.Singletons.TH

19import Data.Singletons.TypeLits

21import Data.Singletons.TypeLits

20import Data.Text as T

22import Data.Text as T

23+import Data.Union

21import Data.Vector as V

24import Data.Vector as V

22import Data.Vinyl hiding (Dict)

25import Data.Vinyl hiding (Dict)

23import qualified Data.Vinyl.TypeLevel as V

26import qualified Data.Vinyl.TypeLevel as V

27+import GHC.Exts

24import GHC.Generics (Generic)

28import GHC.Generics (Generic)

29+import GHC.TypeLits

30+ (SomeNat(..), SomeSymbol(..), someNatVal, someSymbolVal)

25import Prelude as P

31import Prelude as P

26import Test.SmallCheck.Series

32import Test.SmallCheck.Series

29−type family All (c :: k -> Constraint) (s :: [k]) :: Constraint where

30− All c '[] = ()

31− All c (a ': as) = (c a, All c as)

32−

33type family CRepr (s :: Schema) :: Type where

35type family CRepr (s :: Schema) :: Type where

34 CRepr ('SchemaText cs) = TextConstraint

36 CRepr ('SchemaText cs) = TextConstraint

35 CRepr ('SchemaNumber cs) = NumberConstraint

37 CRepr ('SchemaNumber cs) = NumberConstraint

@@ -46,6 +48,51 @@ data TextConstraint

46 | TEnum [Symbol]

48 | TEnum [Symbol]

47 deriving (Generic)

49 deriving (Generic)

51+instance SingKind TextConstraint where

52+ type Demote TextConstraint = DemotedTextConstraint

53+ fromSing = \case

54+ STEq n -> withKnownNat n (DTEq . fromIntegral $ natVal n)

55+ STLt n -> withKnownNat n (DTLt . fromIntegral $ natVal n)

56+ STLe n -> withKnownNat n (DTLe . fromIntegral $ natVal n)

57+ STGt n -> withKnownNat n (DTGt . fromIntegral $ natVal n)

58+ STGe n -> withKnownNat n (DTGe . fromIntegral $ natVal n)

59+ STRegex s -> withKnownSymbol s (DTRegex $ T.pack $ symbolVal s)

60+ STEnum s -> let

61+ d :: Sing (s :: [Symbol]) -> [Text]

62+ d SNil = []

63+ d (SCons ss@SSym fs) = T.pack (symbolVal ss) : d fs

64+ in DTEnum $ d s

65+ toSing = \case

66+ DTEq n -> case someNatVal n of

67+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (STEq (SNat :: Sing n))

68+ Nothing -> error "Negative singleton nat"

69+ DTLt n -> case someNatVal n of

70+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (STLt (SNat :: Sing n))

71+ Nothing -> error "Negative singleton nat"

72+ DTLe n -> case someNatVal n of

73+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (STLe (SNat :: Sing n))

74+ Nothing -> error "Negative singleton nat"

75+ DTGt n -> case someNatVal n of

76+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (STGt (SNat :: Sing n))

77+ Nothing -> error "Negative singleton nat"

78+ DTGe n -> case someNatVal n of

79+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (STGe (SNat :: Sing n))

80+ Nothing -> error "Negative singleton nat"

81+ DTRegex s -> case someSymbolVal (T.unpack s) of

82+ SomeSymbol (_ :: Proxy n) -> SomeSing (STRegex (SSym :: Sing n))

83+ DTEnum ss -> case toSing ss of

84+ SomeSing l -> SomeSing (STEnum l)

85+

86+data DemotedTextConstraint

87+ = DTEq Integer

88+ | DTLt Integer

89+ | DTLe Integer

90+ | DTGt Integer

91+ | DTGe Integer

92+ | DTRegex Text

93+ | DTEnum [Text]

94+ deriving (Generic, Eq, Show)

95+

49data instance Sing (tc :: TextConstraint) where

96data instance Sing (tc :: TextConstraint) where

50 STEq :: Sing n -> Sing ('TEq n)

97 STEq :: Sing n -> Sing ('TEq n)

51 STLt :: Sing n -> Sing ('TLt n)

98 STLt :: Sing n -> Sing ('TLt n)

@@ -53,7 +100,7 @@ data instance Sing (tc :: TextConstraint) where

53 STGt :: Sing n -> Sing ('TGt n)

100 STGt :: Sing n -> Sing ('TGt n)

54 STGe :: Sing n -> Sing ('TGe n)

101 STGe :: Sing n -> Sing ('TGe n)

55 STRegex :: Sing s -> Sing ('TRegex s)

102 STRegex :: Sing s -> Sing ('TRegex s)

56− STEnum :: All KnownSymbol ss => Sing ss -> Sing ('TEnum ss)

103+ STEnum :: Sing ss -> Sing ('TEnum ss)

104

58instance (KnownNat n) => SingI ('TEq n) where sing = STEq sing

105instance (KnownNat n) => SingI ('TEq n) where sing = STEq sing

59instance (KnownNat n) => SingI ('TGt n) where sing = STGt sing

106instance (KnownNat n) => SingI ('TGt n) where sing = STGt sing

@@ -61,7 +108,7 @@ instance (KnownNat n) => SingI ('TGe n) where sing = STGe sing

61instance (KnownNat n) => SingI ('TLt n) where sing = STLt sing

108instance (KnownNat n) => SingI ('TLt n) where sing = STLt sing

62instance (KnownNat n) => SingI ('TLe n) where sing = STLe sing

109instance (KnownNat n) => SingI ('TLe n) where sing = STLe sing

63instance (KnownSymbol s, SingI s) => SingI ('TRegex s) where sing = STRegex sing

110instance (KnownSymbol s, SingI s) => SingI ('TRegex s) where sing = STRegex sing

64−instance (All KnownSymbol ss, SingI ss) => SingI ('TEnum ss) where sing = STEnum sing

111+instance (SingI ss) => SingI ('TEnum ss) where sing = STEnum sing

112

66instance Eq (Sing ('TEq n)) where _ == _ = True

113instance Eq (Sing ('TEq n)) where _ == _ = True

67instance Eq (Sing ('TLt n)) where _ == _ = True

114instance Eq (Sing ('TLt n)) where _ == _ = True

@@ -79,6 +126,14 @@ data NumberConstraint

79 | NEq Nat

126 | NEq Nat

80 deriving (Generic)

127 deriving (Generic)

128

129+data DemotedNumberConstraint

130+ = DNLe Integer

131+ | DNLt Integer

132+ | DNGt Integer

133+ | DNGe Integer

134+ | DNEq Integer

135+ deriving (Generic, Eq, Show)

136+

82data instance Sing (nc :: NumberConstraint) where

137data instance Sing (nc :: NumberConstraint) where

83 SNEq :: Sing n -> Sing ('NEq n)

138 SNEq :: Sing n -> Sing ('NEq n)

84 SNGt :: Sing n -> Sing ('NGt n)

139 SNGt :: Sing n -> Sing ('NGt n)

@@ -98,33 +153,122 @@ instance Eq (Sing ('NLe n)) where _ == _ = True

98instance Eq (Sing ('NGt n)) where _ == _ = True

153instance Eq (Sing ('NGt n)) where _ == _ = True

99instance Eq (Sing ('NGe n)) where _ == _ = True

154instance Eq (Sing ('NGe n)) where _ == _ = True

100

155

156+instance SingKind NumberConstraint where

157+ type Demote NumberConstraint = DemotedNumberConstraint

158+ fromSing = \case

159+ SNEq n -> withKnownNat n (DNEq . fromIntegral $ natVal n)

160+ SNGt n -> withKnownNat n (DNGt . fromIntegral $ natVal n)

161+ SNGe n -> withKnownNat n (DNGe . fromIntegral $ natVal n)

162+ SNLt n -> withKnownNat n (DNLt . fromIntegral $ natVal n)

163+ SNLe n -> withKnownNat n (DNLe . fromIntegral $ natVal n)

164+ toSing = \case

165+ DNEq n -> case someNatVal n of

166+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNEq (SNat :: Sing n))

167+ Nothing -> error "Negative singleton nat"

168+ DNGt n -> case someNatVal n of

169+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNGt (SNat :: Sing n))

170+ Nothing -> error "Negative singleton nat"

171+ DNGe n -> case someNatVal n of

172+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNGe (SNat :: Sing n))

173+ Nothing -> error "Negative singleton nat"

174+ DNLt n -> case someNatVal n of

175+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNLt (SNat :: Sing n))

176+ Nothing -> error "Negative singleton nat"

177+ DNLe n -> case someNatVal n of

178+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNLe (SNat :: Sing n))

179+ Nothing -> error "Negative singleton nat"

180+

101data ArrayConstraint

181data ArrayConstraint

102 = AEq Nat

182 = AEq Nat

183+ | AGt Nat

184+ | AGe Nat

185+ | ALt Nat

186+ | ALe Nat

103 deriving (Generic)

187 deriving (Generic)

104

188

189+data DemotedArrayConstraint

190+ = DAEq Integer

191+ | DAGt Integer

192+ | DAGe Integer

193+ | DALt Integer

194+ | DALe Integer

195+ deriving (Generic, Eq, Show)

196+

105data instance Sing (ac :: ArrayConstraint) where

197data instance Sing (ac :: ArrayConstraint) where

106 SAEq :: Sing n -> Sing ('AEq n)

198 SAEq :: Sing n -> Sing ('AEq n)

199+ SAGt :: Sing n -> Sing ('AGt n)

200+ SAGe :: Sing n -> Sing ('AGe n)

201+ SALt :: Sing n -> Sing ('ALt n)

202+ SALe :: Sing n -> Sing ('ALe n)

107

203

108instance KnownNat n => SingI ('AEq n) where sing = SAEq sing

204instance KnownNat n => SingI ('AEq n) where sing = SAEq sing

205+instance KnownNat n => SingI ('AGt n) where sing = SAGt sing

206+instance KnownNat n => SingI ('AGe n) where sing = SAGe sing

207+instance KnownNat n => SingI ('ALt n) where sing = SALt sing

208+instance KnownNat n => SingI ('ALe n) where sing = SALe sing

109

209

110instance Eq (Sing ('AEq n)) where _ == _ = True

210instance Eq (Sing ('AEq n)) where _ == _ = True

211+instance Eq (Sing ('AGt n)) where _ == _ = True

212+instance Eq (Sing ('AGe n)) where _ == _ = True

213+instance Eq (Sing ('ALt n)) where _ == _ = True

214+instance Eq (Sing ('ALe n)) where _ == _ = True

215+

216+instance SingKind ArrayConstraint where

217+ type Demote ArrayConstraint = DemotedArrayConstraint

218+ fromSing = \case

219+ SAEq n -> withKnownNat n (DAEq . fromIntegral $ natVal n)

220+ SAGt n -> withKnownNat n (DAGt . fromIntegral $ natVal n)

221+ SAGe n -> withKnownNat n (DAGe . fromIntegral $ natVal n)

222+ SALt n -> withKnownNat n (DALt . fromIntegral $ natVal n)

223+ SALe n -> withKnownNat n (DALe . fromIntegral $ natVal n)

224+ toSing = \case

225+ DAEq n -> case someNatVal n of

226+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SAEq (SNat :: Sing n))

227+ Nothing -> error "Negative singleton nat"

228+ DAGt n -> case someNatVal n of

229+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SAGt (SNat :: Sing n))

230+ Nothing -> error "Negative singleton nat"

231+ DAGe n -> case someNatVal n of

232+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SAGe (SNat :: Sing n))

233+ Nothing -> error "Negative singleton nat"

234+ DALt n -> case someNatVal n of

235+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SALt (SNat :: Sing n))

236+ Nothing -> error "Negative singleton nat"

237+ DALe n -> case someNatVal n of

238+ Just (SomeNat (_ :: Proxy n)) -> SomeSing (SALe (SNat :: Sing n))

239+ Nothing -> error "Negative singleton nat"

111

240

112data Schema

241data Schema

113 = SchemaText [TextConstraint]

242 = SchemaText [TextConstraint]

243+ | SchemaBoolean

114 | SchemaNumber [NumberConstraint]

244 | SchemaNumber [NumberConstraint]

115 | SchemaObject [(Symbol, Schema)]

245 | SchemaObject [(Symbol, Schema)]

116 | SchemaArray [ArrayConstraint] Schema

246 | SchemaArray [ArrayConstraint] Schema

117 | SchemaNull

247 | SchemaNull

118 | SchemaOptional Schema

248 | SchemaOptional Schema

249+ | SchemaUnion [Schema]

119 deriving (Generic)

250 deriving (Generic)

120

251

252+data DemotedSchema

253+ = DSchemaText [DemotedTextConstraint]

254+ | DSchemaNumber [DemotedNumberConstraint]

255+ | DSchemaBoolean

256+ | DSchemaObject [(Text, DemotedSchema)]

257+ | DSchemaArray [DemotedArrayConstraint] DemotedSchema

258+ | DSchemaNull

259+ | DSchemaOptional DemotedSchema

260+ | DSchemaUnion [DemotedSchema]

261+ deriving (Generic, Eq, Show)

262+

121data instance Sing (schema :: Schema) where

263data instance Sing (schema :: Schema) where

122 SSchemaText :: Sing tcs -> Sing ('SchemaText tcs)

264 SSchemaText :: Sing tcs -> Sing ('SchemaText tcs)

123 SSchemaNumber :: Sing ncs -> Sing ('SchemaNumber ncs)

265 SSchemaNumber :: Sing ncs -> Sing ('SchemaNumber ncs)

266+ SSchemaBoolean :: Sing 'SchemaBoolean

124 SSchemaArray :: Sing acs -> Sing schema -> Sing ('SchemaArray acs schema)

267 SSchemaArray :: Sing acs -> Sing schema -> Sing ('SchemaArray acs schema)

125 SSchemaObject :: Sing fields -> Sing ('SchemaObject fields)

268 SSchemaObject :: Sing fields -> Sing ('SchemaObject fields)

126 SSchemaOptional :: Sing s -> Sing ('SchemaOptional s)

269 SSchemaOptional :: Sing s -> Sing ('SchemaOptional s)

127 SSchemaNull :: Sing 'SchemaNull

270 SSchemaNull :: Sing 'SchemaNull

271+ SSchemaUnion :: Sing ss -> Sing ('SchemaUnion ss)

128

272

129instance SingI sl => SingI ('SchemaText sl) where

273instance SingI sl => SingI ('SchemaText sl) where

130 sing = SSchemaText sing

274 sing = SSchemaText sing

@@ -132,19 +276,52 @@ instance SingI sl => SingI ('SchemaNumber sl) where

132 sing = SSchemaNumber sing

276 sing = SSchemaNumber sing

133instance SingI 'SchemaNull where

277instance SingI 'SchemaNull where

134 sing = SSchemaNull

278 sing = SSchemaNull

279+instance SingI 'SchemaBoolean where

280+ sing = SSchemaBoolean

135instance (SingI ac, SingI s) => SingI ('SchemaArray ac s) where

281instance (SingI ac, SingI s) => SingI ('SchemaArray ac s) where

136 sing = SSchemaArray sing sing

282 sing = SSchemaArray sing sing

137instance SingI stl => SingI ('SchemaObject stl) where

283instance SingI stl => SingI ('SchemaObject stl) where

138 sing = SSchemaObject sing

284 sing = SSchemaObject sing

139instance SingI s => SingI ('SchemaOptional s) where

285instance SingI s => SingI ('SchemaOptional s) where

140 sing = SSchemaOptional sing

286 sing = SSchemaOptional sing

287+instance SingI s => SingI ('SchemaUnion s) where

288+ sing = SSchemaUnion sing

141

289

142instance Eq (Sing ('SchemaText cs)) where _ == _ = True

290instance Eq (Sing ('SchemaText cs)) where _ == _ = True

143instance Eq (Sing ('SchemaNumber cs)) where _ == _ = True

291instance Eq (Sing ('SchemaNumber cs)) where _ == _ = True

144instance Eq (Sing 'SchemaNull) where _ == _ = True

292instance Eq (Sing 'SchemaNull) where _ == _ = True

293+instance Eq (Sing 'SchemaBoolean) where _ == _ = True

145instance Eq (Sing ('SchemaArray as s)) where _ == _ = True

294instance Eq (Sing ('SchemaArray as s)) where _ == _ = True

146instance Eq (Sing ('SchemaObject cs)) where _ == _ = True

295instance Eq (Sing ('SchemaObject cs)) where _ == _ = True

147instance Eq (Sing ('SchemaOptional s)) where _ == _ = True

296instance Eq (Sing ('SchemaOptional s)) where _ == _ = True

297+instance Eq (Sing ('SchemaUnion s)) where _ == _ = True

298+

299+instance SingKind Schema where

300+ type Demote Schema = DemotedSchema

301+ fromSing = \case

302+ SSchemaText cs -> DSchemaText $ fromSing cs

303+ SSchemaNumber cs -> DSchemaNumber $ fromSing cs

304+ SSchemaBoolean -> DSchemaBoolean

305+ SSchemaArray cs s -> DSchemaArray (fromSing cs) (fromSing s)

306+ SSchemaOptional s -> DSchemaOptional $ fromSing s

307+ SSchemaNull -> DSchemaNull

308+ SSchemaObject cs -> DSchemaObject $ fromSing cs

309+ SSchemaUnion ss -> DSchemaUnion $ fromSing ss

310+ toSing = \case

311+ DSchemaText cs -> case toSing cs of

312+ SomeSing scs -> SomeSing $ SSchemaText scs

313+ DSchemaNumber cs -> case toSing cs of

314+ SomeSing scs -> SomeSing $ SSchemaNumber scs

315+ DSchemaBoolean -> SomeSing $ SSchemaBoolean

316+ DSchemaArray cs sch -> case (toSing cs, toSing sch) of

317+ (SomeSing scs, SomeSing ssch) -> SomeSing $ SSchemaArray scs ssch

318+ DSchemaOptional sch -> case toSing sch of

319+ SomeSing ssch -> SomeSing $ SSchemaOptional ssch

320+ DSchemaNull -> SomeSing SSchemaNull

321+ DSchemaObject cs -> case toSing cs of

322+ SomeSing scs -> SomeSing $ SSchemaObject scs

323+ DSchemaUnion ss -> case toSing ss of

324+ SomeSing sss -> SomeSing $ SSchemaUnion sss

148

325

149data FieldRepr :: (Symbol, Schema) -> Type where

326data FieldRepr :: (Symbol, Schema) -> Type where

150 FieldRepr

327 FieldRepr

@@ -182,53 +359,77 @@ instance

182 => Serial m (FieldRepr '(name, schema)) where

359 => Serial m (FieldRepr '(name, schema)) where

183 series = FieldRepr <$> series

360 series = FieldRepr <$> series

184

361

362+type family USubsets (u :: [k]) :: Constraint where

363+ USubsets '[] = ()

364+ USubsets (h ': tl) = (USubset tl (h ': tl) (V.RImage tl (h ': tl)), USubsets tl)

365+

185data JsonRepr :: Schema -> Type where

366data JsonRepr :: Schema -> Type where

186 ReprText :: Text -> JsonRepr ('SchemaText cs)

367 ReprText :: Text -> JsonRepr ('SchemaText cs)

187 ReprNumber :: Scientific -> JsonRepr ('SchemaNumber cs)

368 ReprNumber :: Scientific -> JsonRepr ('SchemaNumber cs)

369+ ReprBoolean :: Bool -> JsonRepr 'SchemaBoolean

188 ReprNull :: JsonRepr 'SchemaNull

370 ReprNull :: JsonRepr 'SchemaNull

189 ReprArray :: V.Vector (JsonRepr s) -> JsonRepr ('SchemaArray cs s)

371 ReprArray :: V.Vector (JsonRepr s) -> JsonRepr ('SchemaArray cs s)

190 ReprObject :: Rec FieldRepr fs -> JsonRepr ('SchemaObject fs)

372 ReprObject :: Rec FieldRepr fs -> JsonRepr ('SchemaObject fs)

191 ReprOptional :: Maybe (JsonRepr s) -> JsonRepr ('SchemaOptional s)

373 ReprOptional :: Maybe (JsonRepr s) -> JsonRepr ('SchemaOptional s)

374+ ReprUnion :: Union JsonRepr (h ': tl) -> JsonRepr ('SchemaUnion (h ': tl))

375+

376+instance (Monad m, Serial m Text, SingI cs)

377+ => Serial m (JsonRepr ('SchemaText cs)) where

378+ series = decDepth $ fmap ReprText $ textSeries $ fromSing (sing :: Sing cs)

379+

380+instance (Monad m, Serial m Scientific, SingI cs)

381+ => Serial m (JsonRepr ('SchemaNumber cs)) where

382+ series = decDepth $ fmap ReprNumber

383+ $ numberSeries $ fromSing (sing :: Sing cs)

384+

385+instance Monad m => Serial m (JsonRepr 'SchemaNull) where

386+ series = cons0 ReprNull

387+

388+instance (Serial m (JsonRepr s), Serial m (V.Vector (JsonRepr s)), SingI cs)

389+ => Serial m (JsonRepr ('SchemaArray cs s)) where

390+ series = decDepth $ fmap ReprArray

391+ $ arraySeries $ fromSing (sing :: Sing cs)

192

392

393+instance (Serial m (JsonRepr s))

394+ => Serial m (JsonRepr ('SchemaOptional s)) where

395+ series = cons1 ReprOptional

396+

397+instance (Monad m, Serial m (Rec FieldRepr fs))

398+ => Serial m (JsonRepr ('SchemaObject fs)) where

399+ series = cons1 ReprObject

400+

401+-- | Move to the union package

193instance Show (JsonRepr ('SchemaText cs)) where

402instance Show (JsonRepr ('SchemaText cs)) where

194 show (ReprText t) = "ReprText " P.++ show t

403 show (ReprText t) = "ReprText " P.++ show t

195

404

196instance Show (JsonRepr ('SchemaNumber cs)) where

405instance Show (JsonRepr ('SchemaNumber cs)) where

197 show (ReprNumber n) = "ReprNumber " P.++ show n

406 show (ReprNumber n) = "ReprNumber " P.++ show n

198

407

408+instance Show (JsonRepr 'SchemaBoolean) where

409+ show (ReprBoolean n) = "ReprBoolean " P.++ show n

410+

199instance Show (JsonRepr 'SchemaNull) where show _ = "ReprNull"

411instance Show (JsonRepr 'SchemaNull) where show _ = "ReprNull"

200

412

201instance Show (JsonRepr s) => Show (JsonRepr ('SchemaArray acs s)) where

413instance Show (JsonRepr s) => Show (JsonRepr ('SchemaArray acs s)) where

202 show (ReprArray v) = "ReprArray " P.++ show v

414 show (ReprArray v) = "ReprArray " P.++ show v

203

415

416+#if MIN_VERSION_base(4,12,0)

417+instance

418+ ( V.RecAll FieldRepr fs Show, RMap fs, ReifyConstraint Show FieldRepr fs

419+ , RecordToList fs )

420+ => Show (JsonRepr ('SchemaObject fs)) where

421+ show (ReprObject fs) = "ReprObject " P.++ show fs

422+#else

204instance V.RecAll FieldRepr fs Show => Show (JsonRepr ('SchemaObject fs)) where

423instance V.RecAll FieldRepr fs Show => Show (JsonRepr ('SchemaObject fs)) where

205 show (ReprObject fs) = "ReprObject " P.++ show fs

424 show (ReprObject fs) = "ReprObject " P.++ show fs

425+#endif

206

426

207instance Show (JsonRepr s) => Show (JsonRepr ('SchemaOptional s)) where

427instance Show (JsonRepr s) => Show (JsonRepr ('SchemaOptional s)) where

208 show (ReprOptional s) = "ReprOptional " P.++ show s

428 show (ReprOptional s) = "ReprOptional " P.++ show s

209

429

210−instance (Monad m, Serial m Text)

430+instance Show (Union JsonRepr (h ': tl))

211− => Serial m (JsonRepr ('SchemaText cs)) where

431+ => Show (JsonRepr ('SchemaUnion (h ': tl))) where

212− series = cons1 ReprText

432+ show (ReprUnion s) = "ReprUnion " P.++ show s

213−

214−instance (Monad m, Serial m Scientific)

215− => Serial m (JsonRepr ('SchemaNumber cs)) where

216− series = cons1 ReprNumber

217−

218−instance Monad m => Serial m (JsonRepr 'SchemaNull) where

219− series = cons0 ReprNull

220−

221−instance (Serial m (V.Vector (JsonRepr s)))

222− => Serial m (JsonRepr ('SchemaArray cs s)) where

223− series = cons1 ReprArray

224−

225−instance (Serial m (JsonRepr s))

226− => Serial m (JsonRepr ('SchemaOptional s)) where

227− series = cons1 ReprOptional

228−

229−instance (Monad m, Serial m (Rec FieldRepr fs))

230− => Serial m (JsonRepr ('SchemaObject fs)) where

231− series = cons1 ReprObject

232

433

233instance Eq (Rec FieldRepr fs) => Eq (JsonRepr ('SchemaObject fs)) where

434instance Eq (Rec FieldRepr fs) => Eq (JsonRepr ('SchemaObject fs)) where

234 ReprObject a == ReprObject b = a == b

435 ReprObject a == ReprObject b = a == b

@@ -239,6 +440,9 @@ instance Eq (JsonRepr ('SchemaText cs)) where

239instance Eq (JsonRepr ('SchemaNumber cs)) where

440instance Eq (JsonRepr ('SchemaNumber cs)) where

240 ReprNumber a == ReprNumber b = a == b

441 ReprNumber a == ReprNumber b = a == b

241

442

443+instance Eq (JsonRepr 'SchemaBoolean) where

444+ ReprBoolean a == ReprBoolean b = a == b

445+

242instance Eq (JsonRepr 'SchemaNull) where

446instance Eq (JsonRepr 'SchemaNull) where

243 ReprNull == ReprNull = True

447 ReprNull == ReprNull = True

244

448

@@ -248,6 +452,51 @@ instance Eq (JsonRepr s) => Eq (JsonRepr ('SchemaArray as s)) where

248instance Eq (JsonRepr s) => Eq (JsonRepr ('SchemaOptional s)) where

452instance Eq (JsonRepr s) => Eq (JsonRepr ('SchemaOptional s)) where

249 ReprOptional a == ReprOptional b = a == b

453 ReprOptional a == ReprOptional b = a == b

250

454

455+instance Eq (Union JsonRepr (h ': tl))

456+ => Eq (JsonRepr ('SchemaUnion (h ': tl))) where

457+ ReprUnion a == ReprUnion b = a == b

458+

459+instance Ord (Rec FieldRepr fs) => Ord (JsonRepr ('SchemaObject fs)) where

460+ ReprObject a `compare` ReprObject b = a `compare` b

461+

462+instance Ord (JsonRepr ('SchemaText cs)) where

463+ ReprText a `compare` ReprText b = a `compare` b

464+

465+instance Ord (JsonRepr ('SchemaNumber cs)) where

466+ ReprNumber a `compare` ReprNumber b = a `compare` b

467+

468+instance Ord (JsonRepr 'SchemaBoolean) where

469+ ReprBoolean a `compare` ReprBoolean b = a `compare` b

470+

471+instance Ord (JsonRepr 'SchemaNull) where

472+ compare _ _ = EQ

473+

474+instance Ord (JsonRepr s) => Ord (JsonRepr ('SchemaArray as s)) where

475+ ReprArray a `compare` ReprArray b = a `compare` b

476+

477+instance Ord (JsonRepr s) => Ord (JsonRepr ('SchemaOptional s)) where

478+ ReprOptional a `compare` ReprOptional b = a `compare` b

479+

480+instance Ord (Union JsonRepr (h ': tl))

481+ => Ord (JsonRepr ('SchemaUnion (h ': tl))) where

482+ ReprUnion a `compare` ReprUnion b = a `compare` b

483+

484+instance IsList (JsonRepr ('SchemaArray cs s)) where

485+ type Item (JsonRepr ('SchemaArray cs s)) = JsonRepr s

486+ fromList = ReprArray . GHC.Exts.fromList

487+ toList (ReprArray v) = GHC.Exts.toList v

488+

489+instance Num (JsonRepr ('SchemaNumber cs)) where

490+ ReprNumber a + ReprNumber b = ReprNumber $ a + b

491+ ReprNumber a - ReprNumber b = ReprNumber $ a - b

492+ ReprNumber a * ReprNumber b = ReprNumber $ a * b

493+ abs (ReprNumber a) = ReprNumber $ abs a

494+ signum (ReprNumber a) = ReprNumber $ signum a

495+ fromInteger = ReprNumber . fromIntegral

496+

497+instance IsString (JsonRepr ('SchemaText cs)) where

498+ fromString = ReprText . fromString

499+

251fromOptional

500fromOptional

252 :: SingI s

501 :: SingI s

253 => Sing ('SchemaOptional s)

502 => Sing ('SchemaOptional s)

@@ -255,10 +504,29 @@ fromOptional

255 -> Parser (Maybe (JsonRepr s))

504 -> Parser (Maybe (JsonRepr s))

256fromOptional _ = parseJSON

505fromOptional _ = parseJSON

257

506

507+parseUnion

508+ :: FromJSON (JsonRepr ('SchemaUnion ss))

509+ => sing (ss :: [Schema])

510+ -> Value

511+ -> Parser (JsonRepr ('SchemaUnion ss))

512+parseUnion _ val = parseJSON val

513+

514+instance FromJSON (Union JsonRepr '[]) where

515+ parseJSON = fail "empty union"

516+

517+instance (SingI a, FromJSON (Union JsonRepr as)) => FromJSON (Union JsonRepr (a ': as)) where

518+ parseJSON val = (This <$> parseJSON val)

519+ <|> (That <$> (parseJSON val :: Parser (Union JsonRepr as)))

520+

521+instance ToJSON (Union JsonRepr as) where

522+ toJSON (This fa) = toJSON fa

523+ toJSON (That u) = toJSON u

524+

258instance SingI schema => J.FromJSON (JsonRepr schema) where

525instance SingI schema => J.FromJSON (JsonRepr schema) where

259 parseJSON value = case sing :: Sing schema of

526 parseJSON value = case sing :: Sing schema of

260 SSchemaText _ -> withText "String" (pure . ReprText) value

527 SSchemaText _ -> withText "String" (pure . ReprText) value

261 SSchemaNumber _ -> withScientific "Number" (pure . ReprNumber) value

528 SSchemaNumber _ -> withScientific "Number" (pure . ReprNumber) value

529+ SSchemaBoolean -> ReprBoolean <$> parseJSON value

262 SSchemaNull -> case value of

530 SSchemaNull -> case value of

263 J.Null -> pure ReprNull

531 J.Null -> pure ReprNull

264 _ -> typeMismatch "Null" value

532 _ -> typeMismatch "Null" value

@@ -274,31 +542,37 @@ instance SingI schema => J.FromJSON (JsonRepr schema) where

274 fieldRepr <- case s of

542 fieldRepr <- case s of

275 SSchemaText so -> case H.lookup fieldName h of

543 SSchemaText so -> case H.lookup fieldName h of

276 Just v -> withSingI so $ FieldRepr <$> parseJSON v

544 Just v -> withSingI so $ FieldRepr <$> parseJSON v

277− Nothing -> fail "schematext"

545+ Nothing -> fail $ "No text field: " P.++ show fieldName

278 SSchemaNumber so -> case H.lookup fieldName h of

546 SSchemaNumber so -> case H.lookup fieldName h of

279 Just v -> withSingI so $ FieldRepr <$> parseJSON v

547 Just v -> withSingI so $ FieldRepr <$> parseJSON v

280− Nothing -> fail "schemanumber"

548+ Nothing -> fail $ "No number field: " P.++ show fieldName

549+ SSchemaBoolean -> case H.lookup fieldName h of

550+ Just v -> FieldRepr <$> parseJSON v

551+ Nothing -> fail $ "No boolean field: " P.++ show fieldName

281 SSchemaNull -> case H.lookup fieldName h of

552 SSchemaNull -> case H.lookup fieldName h of

282 Just v -> FieldRepr <$> parseJSON v

553 Just v -> FieldRepr <$> parseJSON v

283− Nothing -> fail "schemanull"

554+ Nothing -> fail $ "No null field: " P.++ show fieldName

284 SSchemaArray sa sb -> case H.lookup fieldName h of

555 SSchemaArray sa sb -> case H.lookup fieldName h of

285 Just v -> withSingI sa $ withSingI sb $ FieldRepr <$> parseJSON v

556 Just v -> withSingI sa $ withSingI sb $ FieldRepr <$> parseJSON v

286− Nothing -> fail "schemaarray"

557+ Nothing -> fail $ "No array field: " P.++ show fieldName

287 SSchemaObject so -> case H.lookup fieldName h of

558 SSchemaObject so -> case H.lookup fieldName h of

288 Just v -> withSingI so $ FieldRepr <$> parseJSON v

559 Just v -> withSingI so $ FieldRepr <$> parseJSON v

289− Nothing -> fail "schemaobject"

560+ Nothing -> fail $ "No object field" P.++ show fieldName

290 SSchemaOptional so -> case H.lookup fieldName h of

561 SSchemaOptional so -> case H.lookup fieldName h of

291 Just v -> withSingI so $ FieldRepr <$> parseJSON v

562 Just v -> withSingI so $ FieldRepr <$> parseJSON v

292− Nothing -> fail "schemaoptional"

563+ Nothing -> withSingI so $ pure $ FieldRepr $ ReprOptional Nothing

564+ SSchemaUnion ss -> withSingI ss $ FieldRepr <$> parseUnion ss value

293 (fieldRepr :&) <$> demoteFields tl h

565 (fieldRepr :&) <$> demoteFields tl h

294 ReprObject <$> withObject "Object" (demoteFields fs) value

566 ReprObject <$> withObject "Object" (demoteFields fs) value

567+ SSchemaUnion ss -> parseUnion ss value

295

568

296instance J.ToJSON (JsonRepr a) where

569instance J.ToJSON (JsonRepr a) where

297 toJSON ReprNull = J.Null

570 toJSON ReprNull = J.Null

571+ toJSON (ReprBoolean b) = J.Bool b

298 toJSON (ReprText t) = J.String t

572 toJSON (ReprText t) = J.String t

299 toJSON (ReprNumber n) = J.Number n

573 toJSON (ReprNumber n) = J.Number n

300 toJSON (ReprOptional s) = case s of

574 toJSON (ReprOptional s) = case s of

301− Just v -> toJSON v

575+ Just v -> toJSON v

302 Nothing -> J.Null

576 Nothing -> J.Null

303 toJSON (ReprArray v) = J.Array $ toJSON <$> v

577 toJSON (ReprArray v) = J.Array $ toJSON <$> v

304 toJSON (ReprObject r) = J.Object . H.fromList . fold $ r

578 toJSON (ReprObject r) = J.Object . H.fromList . fold $ r

@@ -311,6 +585,7 @@ instance J.ToJSON (JsonRepr a) where

311 fold = \case

585 fold = \case

312 RNil -> []

586 RNil -> []

313 fr@(FieldRepr _) :& tl -> (extract fr) : fold tl

587 fr@(FieldRepr _) :& tl -> (extract fr) : fold tl

588+ toJSON (ReprUnion u) = toJSON u

314

589

315class FalseConstraint a

590class FalseConstraint a

316

591

src/Data/Schematic/Schema.hs-bootnew file+95

@@ -0,0 +1,95 @@

1+module Data.Schematic.Schema where

3+import Data.Kind

4+import Data.Maybe

5+import Data.Schematic.Instances ()

6+import Data.Scientific

7+import Data.Singletons.TH

8+import Data.Singletons.TypeLits

9+import Data.Text as T

10+import Data.Union

11+import Data.Vector as V

12+import Data.Vinyl hiding (Dict)

13+import Prelude as P

14+

15+data TextConstraint

16+ = TEq Nat

17+ | TLt Nat

18+ | TLe Nat

19+ | TGt Nat

20+ | TGe Nat

21+ | TRegex Symbol

22+ | TEnum [Symbol]

23+

24+data DemotedTextConstraint

25+ = DTEq Integer

26+ | DTLt Integer

27+ | DTLe Integer

28+ | DTGt Integer

29+ | DTGe Integer

30+ | DTRegex Text

31+ | DTEnum [Text]

32+

33+data NumberConstraint

34+ = NLe Nat

35+ | NLt Nat

36+ | NGt Nat

37+ | NGe Nat

38+ | NEq Nat

39+

40+data DemotedNumberConstraint

41+ = DNLe Integer

42+ | DNLt Integer

43+ | DNGt Integer

44+ | DNGe Integer

45+ | DNEq Integer

46+

47+data ArrayConstraint

48+ = AEq Nat

49+ | AGt Nat

50+ | AGe Nat

51+ | ALt Nat

52+ | ALe Nat

53+

54+data DemotedArrayConstraint

55+ = DAEq Integer

56+ | DAGt Integer

57+ | DAGe Integer

58+ | DALt Integer

59+ | DALe Integer

60+

61+data Schema

62+ = SchemaText [TextConstraint]

63+ | SchemaBoolean

64+ | SchemaNumber [NumberConstraint]

65+ | SchemaObject [(Symbol, Schema)]

66+ | SchemaArray [ArrayConstraint] Schema

67+ | SchemaNull

68+ | SchemaOptional Schema

69+ | SchemaUnion [Schema]

70+

71+data DemotedSchema

72+ = DSchemaText [DemotedTextConstraint]

73+ | DSchemaNumber [DemotedNumberConstraint]

74+ | DSchemaBoolean

75+ | DSchemaObject [(Text, DemotedSchema)]

76+ | DSchemaArray [DemotedArrayConstraint] DemotedSchema

77+ | DSchemaNull

78+ | DSchemaOptional DemotedSchema

79+ | DSchemaUnion [DemotedSchema]

80+

81+data FieldRepr :: (Symbol, Schema) -> Type where

82+ FieldRepr

83+ :: (SingI schema, KnownSymbol name)

84+ => JsonRepr schema

85+ -> FieldRepr '(name, schema)

86+

87+data JsonRepr :: Schema -> Type where

88+ ReprText :: Text -> JsonRepr ('SchemaText cs)

89+ ReprNumber :: Scientific -> JsonRepr ('SchemaNumber cs)

90+ ReprBoolean :: Bool -> JsonRepr 'SchemaBoolean

91+ ReprNull :: JsonRepr 'SchemaNull

92+ ReprArray :: V.Vector (JsonRepr s) -> JsonRepr ('SchemaArray cs s)

93+ ReprObject :: Rec FieldRepr fs -> JsonRepr ('SchemaObject fs)

94+ ReprOptional :: Maybe (JsonRepr s) -> JsonRepr ('SchemaOptional s)

95+ ReprUnion :: Union JsonRepr (h ': tl) -> JsonRepr ('SchemaUnion (h ': tl))

src/Data/Schematic/Utils.hsdeleted−42

@@ -1,42 +0,0 @@

1−{-# LANGUAGE AllowAmbiguousTypes #-}

2−

3−module Data.Schematic.Utils where

4−

5−import Data.Proxy

6−import Data.Singletons

7−import Data.Singletons.Prelude

8−import Data.Singletons.TypeLits

9−import Data.Vinyl hiding (Dict)

10−

11−

12−class Known a where

13− known :: a

14−

15−instance Known (Proxy a) where

16− known = Proxy

17−

18−instance KnownNat n => Known (Sing n) where

19− known = SNat

20−

21−instance KnownSymbol s => Known (Sing s) where

22− known = SSym

23−

24−instance (Known (Sing a), Known (Sing b)) => Known (Sing '(a,b)) where

25− known = STuple2 known known

26−

27−instance Known (Sing '[]) where known = SNil

28−

29−instance (Known (Sing a), Known (Sing as)) => Known (Sing (a ': as)) where

30− known = SCons known known

31−

32−instance Known (Rec Sing '[]) where

33− known = RNil

34−

35−instance (Known (Sing a), Known (Rec Sing tl)) => Known (Rec Sing (a ': tl)) where

36− known = known :& known

37−

38−data Dict c where

39− Dict :: c => Dict c

40−

41−instance c => Known (Dict c) where

42− known = Dict

src/Data/Schematic/Validation.hs+125−25

@@ -2,20 +2,24 @@ module Data.Schematic.Validation where

3import Control.Monad

4import Control.Monad.Validation

5+import Data.Aeson

6+import Data.Aeson.Types

5import Data.Foldable

7import Data.Foldable

6import Data.Functor.Identity

8import Data.Functor.Identity

7import Data.Monoid

9import Data.Monoid

8import Data.Schematic.Path

10import Data.Schematic.Path

9import Data.Schematic.Schema

11import Data.Schematic.Schema

10−import Data.Schematic.Utils ()

11import Data.Scientific

12import Data.Scientific

12import Data.Singletons.Prelude

13import Data.Singletons.Prelude

13import Data.Singletons.TypeLits

14import Data.Singletons.TypeLits

14import Data.Text as T

15import Data.Text as T

16+import Data.Traversable

17+import Data.Union

15import Data.Vector as V

18import Data.Vector as V

16import Data.Vinyl

19import Data.Vinyl

20+import Data.Vinyl.TypeLevel

17import Prelude as P

21import Prelude as P

18−import Text.Regex

22+import Text.Regex.TDFA

21type Validation a = ValidationT ErrorMap Identity a

25type Validation a = ValidationT ErrorMap Identity a

@@ -26,7 +30,11 @@ data ParseResult a

26 = Valid a

30 = Valid a

27 | DecodingError Text -- static

31 | DecodingError Text -- static

28 | ValidationError ErrorMap -- runtime

32 | ValidationError ErrorMap -- runtime

29− deriving (Show, Eq, Functor)

33+ deriving (Show, Eq, Functor, Foldable, Traversable)

34+

35+instance (TopLevel a, SingI a, FromJSON (JsonRepr a))

36+ => FromJSON (ParseResult (JsonRepr a)) where

37+ parseJSON = pure . parseAndValidateJson @a

31isValid :: ParseResult a -> Bool

39isValid :: ParseResult a -> Bool

32isValid (Valid _) = True

40isValid (Valid _) = True

@@ -50,42 +58,42 @@ validateTextConstraint (JSONPath path) t = \case

50 let

58 let

51 nlen = withKnownNat n $ natVal n

59 nlen = withKnownNat n $ natVal n

52 predicate = nlen == (fromIntegral $ T.length t)

60 predicate = nlen == (fromIntegral $ T.length t)

53− errMsg = "length of " <> path <> " should be == " <> T.pack (show nlen)

61+ errMsg = "length should be == " <> T.pack (show nlen)

54 warn = vWarning $ mmSingleton path (pure errMsg)

62 warn = vWarning $ mmSingleton path (pure errMsg)

55 unless predicate warn

63 unless predicate warn

56 STLt n -> do

64 STLt n -> do

57 let

65 let

58 nlen = withKnownNat n $ natVal n

66 nlen = withKnownNat n $ natVal n

59− predicate = nlen < (fromIntegral $ T.length t)

67+ predicate = nlen > (fromIntegral $ T.length t)

60− errMsg = "length of " <> path <> " should be < " <> T.pack (show nlen)

68+ errMsg = "length should be < " <> T.pack (show nlen)

61 warn = vWarning $ mmSingleton path (pure errMsg)

69 warn = vWarning $ mmSingleton path (pure errMsg)

62 unless predicate warn

70 unless predicate warn

63 STLe n -> do

71 STLe n -> do

64 let

72 let

65 nlen = withKnownNat n $ natVal n

73 nlen = withKnownNat n $ natVal n

66− predicate = nlen <= (fromIntegral $ T.length t)

74+ predicate = nlen >= (fromIntegral $ T.length t)

67− errMsg = "length of " <> path <> " should be <= " <> T.pack (show nlen)

75+ errMsg = "length should be <= " <> T.pack (show nlen)

68 warn = vWarning $ mmSingleton path (pure errMsg)

76 warn = vWarning $ mmSingleton path (pure errMsg)

69 unless predicate warn

77 unless predicate warn

70 STGt n -> do

78 STGt n -> do

71 let

79 let

72 nlen = withKnownNat n $ natVal n

80 nlen = withKnownNat n $ natVal n

73− predicate = nlen > (fromIntegral $ T.length t)

81+ predicate = nlen < (fromIntegral $ T.length t)

74− errMsg = "length of " <> path <> " should be > " <> T.pack (show nlen)

82+ errMsg = "length should be > " <> T.pack (show nlen)

75 warn = vWarning $ mmSingleton path (pure errMsg)

83 warn = vWarning $ mmSingleton path (pure errMsg)

76 unless predicate warn

84 unless predicate warn

77 STGe n -> do

85 STGe n -> do

78 let

86 let

79 nlen = withKnownNat n $ natVal n

87 nlen = withKnownNat n $ natVal n

80− predicate = nlen >= (fromIntegral $ T.length t)

88+ predicate = nlen <= (fromIntegral $ T.length t)

81− errMsg = "length of " <> path <> " should be >= " <> T.pack (show nlen)

89+ errMsg = "length should be >= " <> T.pack (show nlen)

82 warn = vWarning $ mmSingleton path (pure errMsg)

90 warn = vWarning $ mmSingleton path (pure errMsg)

83 unless predicate warn

91 unless predicate warn

84 STRegex r -> do

92 STRegex r -> do

85 let

93 let

86− regex = withKnownSymbol r $ symbolVal r

94+ regex = withKnownSymbol r $ fromSing r

87− predicate = maybe False (const True) $ matchRegex (mkRegex regex) (T.unpack t)

95+ predicate = matchTest (makeRegex (T.unpack regex) :: Regex) (T.unpack t)

88− errMsg = path <> " must match " <> T.pack (show regex)

96+ errMsg = "must match " <> regex

89 warn = vWarning $ mmSingleton path (pure errMsg)

97 warn = vWarning $ mmSingleton path (pure errMsg)

90 unless predicate warn

98 unless predicate warn

91 STEnum ss -> do

99 STEnum ss -> do

@@ -93,7 +101,7 @@ validateTextConstraint (JSONPath path) t = \case

93 matching :: Sing (s :: [Symbol]) -> Bool

101 matching :: Sing (s :: [Symbol]) -> Bool

94 matching SNil = False

102 matching SNil = False

95 matching (SCons s@SSym fs) = T.pack (symbolVal s) == t || matching fs

103 matching (SCons s@SSym fs) = T.pack (symbolVal s) == t || matching fs

96− errMsg = path <> " must be one of " <> T.pack (show (fromSing ss))

104+ errMsg = "must be one of " <> T.pack (show (fromSing ss))

97 warn = vWarning $ mmSingleton path (pure errMsg)

105 warn = vWarning $ mmSingleton path (pure errMsg)

98 unless (matching ss) warn

106 unless (matching ss) warn

107

@@ -107,35 +115,35 @@ validateNumberConstraint (JSONPath path) num = \case

107 let

115 let

108 nlen = withKnownNat n $ natVal n

116 nlen = withKnownNat n $ natVal n

109 predicate = fromIntegral nlen == num

117 predicate = fromIntegral nlen == num

110− errMsg = path <> " should be == " <> T.pack (show nlen)

118+ errMsg = "should be == " <> T.pack (show nlen)

111 warn = vWarning $ mmSingleton path (pure errMsg)

119 warn = vWarning $ mmSingleton path (pure errMsg)

112 unless predicate warn

120 unless predicate warn

113 SNGt n -> do

121 SNGt n -> do

114 let

122 let

115 nlen = withKnownNat n $ natVal n

123 nlen = withKnownNat n $ natVal n

116 predicate = num > fromIntegral nlen

124 predicate = num > fromIntegral nlen

117− errMsg = path <> " should be > " <> T.pack (show nlen)

125+ errMsg = "should be > " <> T.pack (show nlen)

118 warn = vWarning $ mmSingleton path (pure errMsg)

126 warn = vWarning $ mmSingleton path (pure errMsg)

119 unless predicate warn

127 unless predicate warn

120 SNGe n -> do

128 SNGe n -> do

121 let

129 let

122 nlen = withKnownNat n $ natVal n

130 nlen = withKnownNat n $ natVal n

123 predicate = num >= fromIntegral nlen

131 predicate = num >= fromIntegral nlen

124− errMsg = path <> " should be >= " <> T.pack (show nlen)

132+ errMsg = "should be >= " <> T.pack (show nlen)

125 warn = vWarning $ mmSingleton path (pure errMsg)

133 warn = vWarning $ mmSingleton path (pure errMsg)

126 unless predicate warn

134 unless predicate warn

127 SNLt n -> do

135 SNLt n -> do

128 let

136 let

129 nlen = withKnownNat n $ natVal n

137 nlen = withKnownNat n $ natVal n

130− predicate = fromIntegral nlen < num

138+ predicate = num < fromIntegral nlen

131− errMsg = path <> " should be < " <> T.pack (show nlen)

139+ errMsg = "should be < " <> T.pack (show nlen)

132 warn = vWarning $ mmSingleton path (pure errMsg)

140 warn = vWarning $ mmSingleton path (pure errMsg)

133 unless predicate warn

141 unless predicate warn

134 SNLe n -> do

142 SNLe n -> do

135 let

143 let

136 nlen = withKnownNat n $ natVal n

144 nlen = withKnownNat n $ natVal n

137− predicate = fromIntegral nlen <= num

145+ predicate = num <= fromIntegral nlen

138− errMsg = path <> " should be <= " <> T.pack (show nlen)

146+ errMsg = "should be <= " <> T.pack (show nlen)

139 warn = vWarning $ mmSingleton path (pure errMsg)

147 warn = vWarning $ mmSingleton path (pure errMsg)

140 unless predicate warn

148 unless predicate warn

141

149

@@ -149,7 +157,35 @@ validateArrayConstraint (JSONPath path) v = \case

149 let

157 let

150 nlen = withKnownNat n $ natVal n

158 nlen = withKnownNat n $ natVal n

151 predicate = nlen == fromIntegral (V.length v)

159 predicate = nlen == fromIntegral (V.length v)

152− errMsg = "length of " <> path <> " should be == " <> T.pack (show nlen)

160+ errMsg = "length should be == " <> T.pack (show nlen)

161+ warn = vWarning $ mmSingleton path (pure errMsg)

162+ unless predicate warn

163+ SAGt n -> do

164+ let

165+ nlen = withKnownNat n $ natVal n

166+ predicate = fromIntegral (V.length v) > nlen

167+ errMsg = "length should be > " <> T.pack (show nlen)

168+ warn = vWarning $ mmSingleton path (pure errMsg)

169+ unless predicate warn

170+ SAGe n -> do

171+ let

172+ nlen = withKnownNat n $ natVal n

173+ predicate = fromIntegral (V.length v) >= nlen

174+ errMsg = "length should be >= " <> T.pack (show nlen)

175+ warn = vWarning $ mmSingleton path (pure errMsg)

176+ unless predicate warn

177+ SALt n -> do

178+ let

179+ nlen = withKnownNat n $ natVal n

180+ predicate = fromIntegral (V.length v) < nlen

181+ errMsg = "length should be < " <> T.pack (show nlen)

182+ warn = vWarning $ mmSingleton path (pure errMsg)

183+ unless predicate warn

184+ SALe n -> do

185+ let

186+ nlen = withKnownNat n $ natVal n

187+ predicate = fromIntegral (V.length v) <= nlen

188+ errMsg = "length should be <= " <> T.pack (show nlen)

153 warn = vWarning $ mmSingleton path (pure errMsg)

189 warn = vWarning $ mmSingleton path (pure errMsg)

154 unless predicate warn

190 unless predicate warn

155

191

@@ -178,6 +214,7 @@ validateJsonRepr sschema dpath jr = case jr of

178 process cs

214 process cs

179 process scs

215 process scs

180 ReprNull -> pure ()

216 ReprNull -> pure ()

217+ ReprBoolean _ -> pure ()

181 ReprArray v -> case sschema of

218 ReprArray v -> case sschema of

182 SSchemaArray acs s -> do

219 SSchemaArray acs s -> do

183 let

220 let

@@ -197,9 +234,72 @@ validateJsonRepr sschema dpath jr = case jr of

197 ReprObject fs -> case sschema of

234 ReprObject fs -> case sschema of

198 SSchemaObject _ -> go fs

235 SSchemaObject _ -> go fs

199 where

236 where

200− go :: Rec FieldRepr (ts :: [ (Symbol, Schema) ] ) -> Validation ()

237+ go :: Rec FieldRepr (ts :: [(Symbol, Schema)] ) -> Validation ()

201 go RNil = pure ()

238 go RNil = pure ()

202 go (f@(FieldRepr d) :& ftl) = do

239 go (f@(FieldRepr d) :& ftl) = do

203 let newPath = dpath <> [DKey (knownFieldName f)]

240 let newPath = dpath <> [DKey (knownFieldName f)]

204 validateJsonRepr (knownFieldSchema f) newPath d

241 validateJsonRepr (knownFieldSchema f) newPath d

205 go ftl

242 go ftl

243+ ReprUnion _ -> pure () -- FIXME

244+ -- case sschema of

245+ -- SSchemaUnion ss -> case ss of

246+ -- SCons s stl -> case umatch' s u of

247+ -- Nothing -> case urestrict u of

248+ -- Nothing ->

249+ -- fail "impossible to produce subUnion, please report this as a bug"

250+ -- Just x -> do

251+ -- let

252+ -- JSONPath path = demotedPathToText dpath

253+ -- case stl of

254+ -- SNil -> void $ vWarning $ mmSingleton path

255+ -- $ pure "union handling error, please report this as bug"

256+ -- SCons s' stl' ->

257+ -- validateJsonRepr (SSchemaUnion (SCons s' stl')) dpath

258+ -- $ toUnion (SCons s' stl') x

259+ -- Just x -> validateJsonRepr s dpath x

260+

261+-- subUnion

262+-- :: Sing (s ': stl)

263+-- -> ( USubset stl (s ': stl) (RImage stl (s ': stl))

264+-- => Union f (s ': stl)

265+-- -> Maybe (Union f stl) )

266+-- subUnion (SCons s stl) = urestrict

267+

268+-- withUSubset

269+-- :: Sing (s ': stl)

270+-- -> (USubset stl (s ': stl) (RImage stl (s ': stl)) => Maybe (Union f stl))

271+-- -> Maybe (Union f stl)

272+-- withUSubset (SCons s stl) r = r

273+

274+toUnion

275+ :: USubset s' (s ': ss) (RImage s' (s ': ss))

276+ => Sing (s ': ss)

277+ -> Union JsonRepr s'

278+ -> JsonRepr ('SchemaUnion (s ': ss))

279+toUnion _ = ReprUnion . urelax

280+

281+umatch' :: UElem a as i => Sing a -> Union f as -> Maybe (f a)

282+umatch' _ u = umatch u

283+

284+parseAndValidateJson

285+ :: forall schema

286+ . (FromJSON (JsonRepr schema), TopLevel schema, SingI schema)

287+ => Value

288+ -> ParseResult (JsonRepr schema)

289+parseAndValidateJson v =

290+ case parseEither parseJSON v of

291+ Left s -> DecodingError $ T.pack s

292+ Right jsonRepr ->

293+ let

294+ validate = validateJsonRepr (sing :: Sing schema) [] jsonRepr

295+ res = runIdentity . runValidationTEither $ validate

296+ in case res of

297+ Left em -> ValidationError em

298+ Right () -> Valid jsonRepr

299+

300+parseAndValidateJsonBy

301+ :: (FromJSON (JsonRepr schema), TopLevel schema, SingI schema)

302+ => proxy schema

303+ -> Value

304+ -> ParseResult (JsonRepr schema)

305+parseAndValidateJsonBy _ = parseAndValidateJson

src/Data/Schematic/Verifier.hsnew file+5

@@ -0,0 +1,5 @@

1+module Data.Schematic.Verifier (module X) where

3+import Data.Schematic.Verifier.Array as X

4+import Data.Schematic.Verifier.Number as X

5+import Data.Schematic.Verifier.Text as X

src/Data/Schematic/Verifier/Array.hsnew file+14

@@ -0,0 +1,14 @@

1+module Data.Schematic.Verifier.Array where

3+import {-# SOURCE #-} Data.Schematic.Schema

4+import Data.Schematic.Verifier.Common

6+data VerifiedArrayConstraint =

7+ VAEq Integer

8+ deriving (Show)

10+verifyArrayConstraint ::

11+ [DemotedArrayConstraint] -> Maybe (Maybe VerifiedArrayConstraint)

12+verifyArrayConstraint cs = do

13+ x <- verifyDNEq [x | DAEq x <- cs]

14+ pure $ VAEq <$> x

src/Data/Schematic/Verifier/Common.hsnew file+43

@@ -0,0 +1,43 @@

1+module Data.Schematic.Verifier.Common where

3+import Data.List (nub)

5+simplifyNumberConstraint :: ([Integer] -> Integer) -> [Integer] -> Maybe Integer

6+simplifyNumberConstraint f =

7+ \case

8+ [] -> Nothing

9+ x -> Just $ f x

10+

11+simplifyDNLs :: [Integer] -> Maybe Integer

12+simplifyDNLs = simplifyNumberConstraint minimum

13+

14+simplifyDNGs :: [Integer] -> Maybe Integer

15+simplifyDNGs = simplifyNumberConstraint maximum

16+

17+verifyDNEq :: [Integer] -> Maybe (Maybe Integer)

18+verifyDNEq x =

19+ case nub x of

20+ [] -> Just Nothing

21+ [y] -> Just $ Just y

22+ (_:_:_) -> Nothing

23+

24+verify3 :: Maybe Integer -> Maybe Integer -> Maybe Integer -> Maybe ()

25+verify3 (Just x) (Just y) (Just z) =

26+ if x < y && y < z

27+ then Just ()

28+ else Nothing

29+verify3 _ _ _ = Just ()

30+

31+verify2 :: Maybe Integer -> Maybe Integer -> Maybe ()

32+verify2 (Just x) (Just y) =

33+ if x < y

34+ then Just ()

35+ else Nothing

36+verify2 _ _ = Just ()

37+

38+verifyEquations :: Maybe Integer -> Maybe Integer -> Maybe Integer -> Maybe ()

39+verifyEquations mgt meq mlt = do

40+ verify3 mgt meq mlt

41+ verify2 mgt meq

42+ verify2 meq mlt

43+ verify2 mgt mlt

src/Data/Schematic/Verifier/Number.hsnew file+31

@@ -0,0 +1,31 @@

1+module Data.Schematic.Verifier.Number where

3+import {-# SOURCE #-} Data.Schematic.Schema

4+import Data.Schematic.Verifier.Common

6+toStrictNumber :: [DemotedNumberConstraint] -> [DemotedNumberConstraint]

7+toStrictNumber = map f

8+ where

9+ f (DNLe x) = DNLt (x + 1)

10+ f (DNGe x) = DNGt (x - 1)

11+ f x = x

12+

13+data VerifiedNumberConstraint

14+ = VNEq Integer

15+ | VNBounds (Maybe Integer) (Maybe Integer)

16+ deriving (Show)

17+

18+verifyNumberConstraints

19+ :: [DemotedNumberConstraint]

20+ -> Maybe VerifiedNumberConstraint

21+verifyNumberConstraints cs' = do

22+ let

23+ cs = toStrictNumber cs'

24+ mlt = simplifyDNLs [x | DNLt x <- cs]

25+ mgt = simplifyDNGs [x | DNGt x <- cs]

26+ meq <- verifyDNEq [x | DNEq x <- cs]

27+ verifyEquations mgt meq mlt

28+ Just $

29+ case meq of

30+ Just eq -> VNEq eq

31+ Nothing -> VNBounds mgt mlt

src/Data/Schematic/Verifier/Text.hsnew file+121

@@ -0,0 +1,121 @@

1+module Data.Schematic.Verifier.Text where

3+import Control.Monad

4+import Data.Maybe

5+import {-# SOURCE #-} Data.Schematic.Schema

6+import Data.Schematic.Verifier.Common

7+import Data.Text (Text, unpack)

8+import Text.Regex.TDFA.Pattern

9+import Text.Regex.TDFA.ReadRegex (parseRegex)

10+

11+toStrictTextLength :: [DemotedTextConstraint] -> [DemotedTextConstraint]

12+toStrictTextLength = map f

13+ where

14+ f (DTLe x) = DTLt (x + 1)

15+ f (DTGe x) = DTGt (x - 1)

16+ f x = x

17+

18+data VerifiedTextConstraint

19+ = VTEq Integer

20+ | VTBounds (Maybe Integer) (Maybe Integer)

21+ | VTRegex Text Integer (Maybe Integer)

22+ | VTEnum [Text]

23+ deriving (Show)

24+

25+verifyTextLengthConstraints

26+ :: [DemotedTextConstraint]

27+ -> Maybe (Maybe VerifiedTextConstraint)

28+verifyTextLengthConstraints cs' = do

29+ let

30+ cs = toStrictTextLength cs'

31+ mlt = simplifyDNLs [x | DTLt x <- cs]

32+ mgt = simplifyDNGs [x | DTGt x <- cs]

33+ meq <- verifyDNEq [x | DTEq x <- cs]

34+ verifyEquations mgt meq mlt

35+ case all isNothing ([mgt, meq, mlt] :: [Maybe Integer]) of

36+ True -> Just Nothing

37+ _ ->

38+ Just $

39+ Just $

40+ case meq of

41+ Just eq -> VTEq eq

42+ Nothing -> VTBounds mgt mlt

43+

44+regexLength :: Text -> Maybe (Int, Maybe Int)

45+regexLength regexp =

46+ case parseRegex . unpack $ regexp of

47+ Right (p, _) -> Just (minRegexLength p, maxRegexLength p)

48+ Left _ -> Nothing

49+

50+minRegexLength :: Pattern -> Int

51+minRegexLength p =

52+ case p of

53+ PEmpty -> 0

54+ PChar {..} -> 1

55+ PAny {..} -> 1

56+ PAnyNot {..} -> 1

57+ PQuest _ -> 0

58+ PPlus sch -> minRegexLength $ PBound 1 Nothing sch

59+ PStar _ sch -> minRegexLength $ PBound 0 Nothing sch

60+ PBound low _ sch -> low * minRegexLength sch

61+ PConcat ps -> sum $ fmap minRegexLength ps

62+ POr xs -> minimum $ fmap minRegexLength xs

63+ PDot _ -> 1

64+ PEscape {..} -> 1

65+ PCarat _ -> 0

66+ PDollar _ -> 0

67+ _ -> 0

68+

69+maxRegexLength :: Pattern -> Maybe Int

70+maxRegexLength p =

71+ case p of

72+ PEmpty -> Just 0

73+ PChar _ _ -> Just 1

74+ PAny _ _ -> Just 1

75+ PAnyNot _ _ -> Just 1

76+ PQuest _ -> Just 0

77+ PPlus _ -> Nothing

78+ PStar _ _ -> Nothing

79+ PBound _ mhigh sch -> (*) <$> mhigh <*> maxRegexLength sch

80+ PConcat ps -> sum <$> mapM maxRegexLength ps

81+ POr xs -> maximum <$> mapM maxRegexLength xs

82+ PDot _ -> Just 1

83+ PEscape _ _ -> Just 1

84+ PCarat _ -> Just 0

85+ PDollar _ -> Just 0

86+ _ -> Just 0

87+

88+verifyTextRegexConstraint

89+ :: [DemotedTextConstraint]

90+ -> Maybe (Maybe VerifiedTextConstraint)

91+verifyTextRegexConstraint cs = do

92+ let regexps = [x | DTRegex x <- cs]

93+ case regexps of

94+ [] -> Just Nothing

95+ [x] -> do

96+ (l, mh) <- regexLength x

97+ Just $ Just $ VTRegex x (fromIntegral l) (fromIntegral <$> mh)

98+ _ -> Nothing

99+

100+verifyTextEnumConstraint

101+ :: [DemotedTextConstraint]

102+ -> Maybe (Maybe VerifiedTextConstraint)

103+verifyTextEnumConstraint cs = do

104+ let enums = concat [x | DTEnum x <- cs]

105+ case enums of

106+ [] -> Just Nothing

107+ x -> Just $ Just $ VTEnum x

108+

109+verifyTextConstraints

110+ :: [DemotedTextConstraint]

111+ -> Maybe [VerifiedTextConstraint]

112+verifyTextConstraints cs = do

113+ regexp <- verifyTextRegexConstraint cs

114+ void $

115+ case regexp of

116+ Just (VTRegex _ l mh) ->

117+ verifyTextLengthConstraints (DTGe l : cs ++ maybeToList (DTLe <$> mh))

118+ _ -> pure Nothing

119+ lengths <- verifyTextLengthConstraints cs

120+ enums <- verifyTextEnumConstraint cs

121+ return $ catMaybes [lengths, enums, regexp]

stack-13.7.yamlnew file+5

@@ -0,0 +1,5 @@

1+resolver: lts-13.7

2+extra-deps:

3+ - hjsonpointer-1.4.0@rev:0

4+ - hjsonschema-1.9.0@rev:0

5+ - validationt-0.2.1.0

stack.yaml+4−52

@@ -1,53 +1,5 @@

1−resolver: lts-9.01

1+resolver: lts-12.0

2−

3−# User packages to be built.

4−# Various formats can be used as shown in the example below.

5−#

6−# packages:

7−# - some-directory

8−# - https://example.com/foo/bar/baz-0.0.2.tar.gz

9−# - location:

10−# git: https://github.com/commercialhaskell/stack.git

11−# commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a

12−# - location: https://github.com/commercialhaskell/stack/commit/e7b331f14bcffb8367cd58fbfc8b40ec7642100a

13−# extra-dep: true

14−# subdirs:

15−# - auto-update

16−# - wai

17−#

18−# A package marked 'extra-dep: true' will only be built if demanded by a

19−# non-dependency (i.e. a user package), and its test suites and benchmarks

20−# will not be run. This is useful for tweaking upstream packages.

21−packages:

22−#- location:

23− #git: https://github.com/typeable/validationt.git

24− #commit: 24578c9fd408179358c641ee1fff0eb182591f4b

25−- '.'

26−

27extra-deps:

2extra-deps:

3+ - hjsonpointer-1.4.0@rev:0

4+ - hjsonschema-1.9.0@rev:0

28−- validationt-0.2.0.0

5+ - validationt-0.2.1.0

29−- smallcheck-series-0.6

30−

31−# Override default flag values for local packages and extra-deps

32−flags: {}

33−

34−# Extra package databases containing global packages

35−extra-package-dbs: []

36−

37−# Control whether we use the GHC we find on the path

38−# system-ghc: true

39−#

40−# Require a specific version of stack, using version ranges

41−# require-stack-version: -any # Default

42−# require-stack-version: ">=1.4"

43−#

44−# Override the architecture used by stack, especially useful on Windows

45−# arch: i386

46−# arch: x86_64

47−#

48−# Extra directories used by stack for building

49−# extra-include-dirs: [/path/to/dir]

50−# extra-lib-dirs: [/path/to/dir]

51−#

52−# Allow a newer minor version of GHC than the snapshot specifies

53−# compiler-check: newer-minor

test/HelpersSpec.hsnew file+124

@@ -0,0 +1,124 @@

1+{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}

3+{-# LANGUAGE LambdaCase #-}

5+{-# LANGUAGE DataKinds #-}

6+{-# LANGUAGE TypeApplications #-}

7+{-# LANGUAGE OverloadedStrings #-}

9+module HelpersSpec (spec, main) where

10+

11+import Control.Lens

12+import Data.ByteString.Lazy.Lens

13+import Data.Foldable

14+import Data.Monoid

15+import Data.Schematic

16+import Data.Text as T

17+import Data.Text.Lens

18+import Test.Hspec

19+

20+

21+type UUIDSchema = 'SchemaObject '[ '("uuid", 'SchemaText IsUUID) ]

22+

23+-- | Taken from UUID RFC 4122

24+uuid :: Text

25+uuid = "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"

26+

27+type ISO8601DateSchema = 'SchemaObject '[ '("date", 'SchemaText IsDate) ]

28+

29+iso8601dates :: [Text]

30+iso8601dates = [ "1985-04-12" ]

31+

32+invalidIso8601dates :: [Text]

33+invalidIso8601dates = [ "1999-13-12" ]

34+

35+type ISO8601TimeSchema = 'SchemaObject '[ '("time", 'SchemaText IsTime) ]

36+

37+iso8601times :: [Text]

38+iso8601times =

39+ [ "19:23:00"

40+ , "00:00:00"

41+ , "23:47:12" ]

42+

43+invalidIso8601times :: [Text]

44+invalidIso8601times =

45+ [ "00:60:00"

46+ , "24:01:02" ]

47+

48+type ISO8601DateTimeSchema = 'SchemaObject '[ '("datetime", 'SchemaText IsDateTime) ]

49+

50+-- | Taken from ISO8601 RFC 3339

51+iso8601datetimes :: [Text]

52+iso8601datetimes =

53+ iso8601dates <>

54+ [ "1985-04-12T23:20:50.52Z"

55+ , "1996-12-19T16:39:57-08:00"

56+ , "1990-12-31T23:59:60Z"

57+ , "1990-12-31T15:59:60-08:00"

58+ , "1937-01-01T12:00:27.87+00:20"

59+ ]

60+

61+invalidIso8601datetimes :: [Text]

62+invalidIso8601datetimes =

63+ [ "1996-13-129T16:39:57-08:00"

64+ , "1990-2-31T23:59:60Z"

65+ , "1990-12-32T15:59:70"

66+ , "1937-01-1T12::27.87+24:20"

67+ ]

68+

69+spec :: Spec

70+spec = do

71+ describe "UUID: " $ do

72+ it "validates correct UUID" $ do

73+ let

74+ uuidJson = "{\"uuid\": \"" <> (uuid ^. unpacked . packedChars) <> "\" }"

75+ (decodeAndValidateJson uuidJson :: ParseResult (JsonRepr UUIDSchema))

76+ `shouldSatisfy` isValid

77+

78+ it "fails to validate incorrect UUID" $ do

79+ let

80+ incorrectJson = "{\"uuid\": \"incorrect\" }"

81+ (decodeAndValidateJson incorrectJson :: ParseResult (JsonRepr UUIDSchema))

82+ `shouldSatisfy` isValidationError

83+

84+ describe "ISO8601 date: " $ do

85+ for_ iso8601dates $ \dt -> do

86+ it ("validates correct date - " <> dt ^. unpacked) $ do

87+ let json = "{\"date\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

88+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601DateSchema))

89+ `shouldSatisfy` isValid

90+

91+ for_ invalidIso8601dates $ \dt -> do

92+ it ("fails to validate incorrect date - " <> dt ^. unpacked) $ do

93+ let json = "{\"date\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

94+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601DateSchema))

95+ `shouldSatisfy` isValidationError

96+

97+ describe "ISO8601 time: " $ do

98+ for_ iso8601times $ \dt -> do

99+ it ("validates correct time - " <> dt ^. unpacked) $ do

100+ let json = "{\"time\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

101+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601TimeSchema))

102+ `shouldSatisfy` isValid

103+

104+ for_ invalidIso8601times $ \dt -> do

105+ it ("fails to validate incorrect time - " <> dt ^. unpacked) $ do

106+ let json = "{\"time\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

107+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601TimeSchema))

108+ `shouldSatisfy` isValidationError

109+

110+ describe "ISO8601 datetime: " $ do

111+ for_ iso8601datetimes $ \dt -> do

112+ it ("validates correct datetime - " <> dt ^. unpacked) $ do

113+ let json = "{\"datetime\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

114+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601DateTimeSchema))

115+ `shouldSatisfy` isValid

116+

117+ for_ invalidIso8601datetimes $ \dt -> do

118+ it ("fails to validate incorrect datetime - " <> dt ^. unpacked) $ do

119+ let json = "{\"datetime\": \"" <> (dt ^. unpacked . packedChars) <> "\" }"

120+ (decodeAndValidateJson json :: ParseResult (JsonRepr ISO8601DateTimeSchema))

121+ `shouldSatisfy` isValidationError

122+

123+main :: IO ()

124+main = hspec spec

test/JsonSchemaSpec.hsnew file+101

@@ -0,0 +1,101 @@

1+{-# LANGUAGE LambdaCase #-}

3+{-# LANGUAGE DataKinds #-}

4+{-# LANGUAGE TypeApplications #-}

5+{-# LANGUAGE OverloadedLists #-}

6+{-# LANGUAGE OverloadedStrings #-}

8+module JsonSchemaSpec (spec, main) where

10+import Data.Aeson as J

11+import Data.Maybe

12+import Data.Proxy

13+import Data.ByteString.Lazy as B

14+import Data.Schematic

15+import Data.Vinyl

16+import JSONSchema.Draft4 as D4

17+import Test.Hspec

18+

19+

20+type ArraySchema = 'SchemaArray '[ 'AEq 1] ('SchemaNumber '[ 'NGt 10])

21+

22+type ArrayField = '("foo", ArraySchema)

23+

24+type FieldsSchema =

25+ '[ ArrayField, '("bar", 'SchemaOptional ('SchemaText '[ 'TEnum '["foo", "bar"]]))]

26+

27+type SchemaExample = 'SchemaObject FieldsSchema

28+

29+exampleData :: JsonRepr SchemaExample

30+exampleData = withRepr @SchemaExample $

31+ field @"foo" [ReprNumber 13]

32+ :& field @"bar" (pure (ReprText "foo"))

33+ :& RNil

34+

35+type SchemaArrayExample = 'SchemaObject

36+ '[ '("a1", 'SchemaArray '[ 'AGt 1 ] ('SchemaNumber '[]))

37+ , '("a2", 'SchemaArray '[ 'AGe 1 ] ('SchemaNumber '[]))

38+ , '("a3", 'SchemaArray '[ 'ALt 1 ] ('SchemaNumber '[]))

39+ , '("a4", 'SchemaArray '[ 'ALe 1 ] ('SchemaNumber '[]))

40+ ]

41+

42+type SchemaNumberExample = 'SchemaObject

43+ '[ '("n1", 'SchemaNumber '[ 'NGt 1 ])

44+ , '("n2", 'SchemaNumber '[ 'NGe 1 ])

45+ , '("n3", 'SchemaNumber '[ 'NLt 1 ])

46+ , '("n4", 'SchemaNumber '[ 'NLe 1 ])

47+ ]

48+

49+type SchemaTextExample = 'SchemaObject

50+ '[ '("t1", 'SchemaText '[ 'TGt 1 ])

51+ , '("t2", 'SchemaText '[ 'TGe 1 ])

52+ , '("t3", 'SchemaText '[ 'TLt 1 ])

53+ , '("t4", 'SchemaText '[ 'TLe 1 ])

54+ ]

55+

56+spec :: Spec

57+spec = do

58+ it "validates simple schema" $ do

59+ let schema = D4.SchemaWithURI (fromJust $ toJsonSchema (Proxy @SchemaExample)) Nothing

60+ fetchHTTPAndValidate schema (toJSON exampleData) >>= \case

61+ Left _ -> fail "failed to validate test example"

62+ Right _ -> pure ()

63+ it "validates schema with arrays" $ do

64+ let

65+ schema = D4.SchemaWithURI (fromJust $ toJsonSchema (Proxy @SchemaArrayExample)) Nothing

66+ obj = withRepr @SchemaArrayExample $

67+ field @"a1" [ReprNumber 13, ReprNumber 13]

68+ :& field @"a2" [ReprNumber 13]

69+ :& field @"a3" []

70+ :& field @"a4" [ReprNumber 13]

71+ :& RNil

72+ fetchHTTPAndValidate schema (toJSON obj) >>= \case

73+ Left e -> fail "failed to validate test example"

74+ Right _ -> pure ()

75+ it "validates schema with numbers" $ do

76+ let

77+ schema = D4.SchemaWithURI (fromJust $ toJsonSchema (Proxy @SchemaNumberExample)) Nothing

78+ obj = withRepr @SchemaNumberExample $

79+ field @"n1" 1.1

80+ :& field @"n2" 1

81+ :& field @"n3" 0.9

82+ :& field @"n4" 1.0

83+ :& RNil

84+ fetchHTTPAndValidate schema (toJSON obj) >>= \case

85+ Left e -> fail "failed to validate test example"

86+ Right _ -> pure ()

87+ it "validates schema with strings" $ do

88+ let

89+ schema = D4.SchemaWithURI (fromJust $ toJsonSchema (Proxy @SchemaTextExample)) Nothing

90+ obj = withRepr @SchemaTextExample $

91+ field @"t1" "11"

92+ :& field @"t2" "1"

93+ :& field @"t3" ""

94+ :& field @"t4" "1"

95+ :& RNil

96+ fetchHTTPAndValidate schema (toJSON obj) >>= \case

97+ Left e -> fail "failed to validate test example"

98+ Right _ -> pure ()

99+

100+main :: IO ()

101+main = hspec spec

test/LensSpec.hs+16−18

@@ -1,21 +1,23 @@

1+{-# LANGUAGE DataKinds #-}

2+{-# LANGUAGE TypeApplications #-}

3+{-# LANGUAGE OverloadedLists #-}

4+{-# LANGUAGE OverloadedStrings #-}

1module LensSpec (spec, main) where

6module LensSpec (spec, main) where

3import Control.Lens

8import Control.Lens

4−import Data.Kind

5import Data.Proxy

9import Data.Proxy

6import Data.Schematic

10import Data.Schematic

7import Data.Vinyl

11import Data.Vinyl

8import Test.Hspec

12import Test.Hspec

11−type ArraySchema = 'SchemaArray '[AEq 1] ('SchemaNumber '[NGt 10])

15+type ArraySchema = 'SchemaArray '[ 'AEq 1] ('SchemaNumber '[ 'NGt 10])

13type ArrayField = '("foo", ArraySchema)

17type ArrayField = '("foo", ArraySchema)

15type FieldsSchema =

19type FieldsSchema =

16− '[ ArrayField, '("bar", 'SchemaOptional ('SchemaText '[TEnum '["foo", "bar"]]))]

20+ '[ '("bar", 'SchemaOptional ('SchemaText '[ 'TEnum '["foo", "bar"]])), ArrayField]

17−

18−type SchemaExample = 'SchemaObject FieldsSchema

20arrayData :: JsonRepr ArraySchema

22arrayData :: JsonRepr ArraySchema

21arrayData = ReprArray [ReprNumber 13]

23arrayData = ReprArray [ReprNumber 13]

@@ -24,13 +26,10 @@ arrayField :: FieldRepr ArrayField

24arrayField = FieldRepr arrayData

26arrayField = FieldRepr arrayData

26objectData :: Rec FieldRepr FieldsSchema

28objectData :: Rec FieldRepr FieldsSchema

27−objectData = FieldRepr arrayData

28− :& FieldRepr (ReprOptional (Just (ReprText "foo")))

29+objectData = FieldRepr (ReprOptional (Just (ReprText "foo")))

30+ :& FieldRepr arrayData

29 :& RNil

31 :& RNil

31−exampleData :: JsonRepr SchemaExample

32−exampleData = ReprObject objectData

33−

34type BigRecord = Rec FieldRepr

33type BigRecord = Rec FieldRepr

35 '[ '("f1", 'SchemaNumber '[])

34 '[ '("f1", 'SchemaNumber '[])

36 , '("f2", 'SchemaNumber '[])

35 , '("f2", 'SchemaNumber '[])

@@ -164,8 +163,8 @@ type BigRecord = Rec FieldRepr

164 , '("f130", 'SchemaNumber '[])

163 , '("f130", 'SchemaNumber '[])

165 ]

164 ]

166

165

167−bigRecord :: BigRecord

166+_bigRecord :: BigRecord

168−bigRecord =

167+_bigRecord =

169 FieldRepr (ReprNumber 1)

168 FieldRepr (ReprNumber 1)

170 :& FieldRepr (ReprNumber 2)

169 :& FieldRepr (ReprNumber 2)

171 :& FieldRepr (ReprNumber 3)

170 :& FieldRepr (ReprNumber 3)

@@ -298,23 +297,22 @@ bigRecord =

298 :& FieldRepr (ReprNumber 130)

297 :& FieldRepr (ReprNumber 130)

299 :& RNil

298 :& RNil

300

299

301−

302spec :: Spec

300spec :: Spec

303spec = do

301spec = do

304 let

302 let

305 newFooVal = FieldRepr $ ReprArray [ReprNumber 15]

303 newFooVal = FieldRepr $ ReprArray [ReprNumber 15]

306 fooProxy = Proxy @"foo"

304 fooProxy = Proxy @"foo"

307 it "gets the field from an object" $ do

305 it "gets the field from an object" $ do

308− fget fooProxy objectData == arrayField

306+ fget @"foo" objectData `shouldBe` arrayField

309 it "sets the object field" $ do

307 it "sets the object field" $ do

310− fget fooProxy (fput newFooVal objectData) == newFooVal

308+ fget @"foo" (fput newFooVal objectData) `shouldBe` newFooVal

311

309

312 describe "(using lens library) " $ do

310 describe "(using lens library) " $ do

313 it "get the field from an object" $ do

311 it "get the field from an object" $ do

314− objectData ^. flens (Proxy @"foo") == arrayField

312+ objectData ^. flens @"foo" `shouldBe` arrayField

315 it "sets the object field" $ do

313 it "sets the object field" $ do

316− set (flens (Proxy @"foo")) newFooVal objectData ^. flens (Proxy @"foo")

314+ set (flens @"foo") newFooVal objectData ^. flens @"foo"

317− == newFooVal

315+ `shouldBe` newFooVal

318

316

319main :: IO ()

317main :: IO ()

320main = hspec spec

318main = hspec spec

test/SchemaSpec.hs+78−55

@@ -1,47 +1,78 @@

1{-# OPTIONS_GHC -fprint-potential-instances #-}

3+{-# LANGUAGE DataKinds #-}

4+{-# LANGUAGE FlexibleContexts #-}

5+{-# LANGUAGE GADTs #-}

6+{-# LANGUAGE OverloadedLists #-}

7+{-# LANGUAGE OverloadedStrings #-}

8+{-# LANGUAGE RankNTypes #-}

9+{-# LANGUAGE ScopedTypeVariables #-}

10+{-# LANGUAGE TypeApplications #-}

11+

3module SchemaSpec (spec, main) where

12module SchemaSpec (spec, main) where

5−import Control.Monad

14+import Control.Lens

6−import Data.ByteString.Lazy

7import Data.Aeson

15import Data.Aeson

16+import Data.ByteString.Lazy

17+import Data.Functor.Identity

8import Data.Proxy

18import Data.Proxy

9import Data.Schematic

19import Data.Schematic

20+import Data.Schematic.Generator

10import Data.Singletons

21import Data.Singletons

11−import Data.Singletons.Prelude

22+import Data.Tagged

12import Data.Vinyl

23import Data.Vinyl

13import Test.Hspec

24import Test.Hspec

14import Test.Hspec.SmallCheck

25import Test.Hspec.SmallCheck

15−import Test.SmallCheck

26+import Test.SmallCheck as SC

27+import Test.SmallCheck.Drivers as SC

16−import Test.SmallCheck.Series.Instances

28+import Test.SmallCheck.Series as SC

17−

18−

19−type SchemaExample

20− = 'SchemaObject

21− '[ '("foo", 'SchemaArray '[AEq 1] ('SchemaNumber '[NGt 10]))

22− , '("bar", 'SchemaOptional ('SchemaText '[TEnum '["foo", "bar"]]))]

24−type TestMigration =

30+import Debug.Trace

25− 'Migration "test_revision"

26− '[ 'Diff '[ 'PKey "bar" ] ('Update ('SchemaText '[]))

27− , 'Diff '[ 'PKey "foo" ] ('Update ('SchemaNumber '[])) ]

29−type VS = 'Versioned SchemaExample '[ TestMigration ]

32+type SchemaExample = 'SchemaObject

33+ '[ '("foo", 'SchemaArray '[ 'AEq 1] ('SchemaNumber '[ 'NGt 10]))

34+ , '("bar", 'SchemaOptional ('SchemaText '[ 'TEnum '["foo", "bar"]]))]

31−exampleTest :: JsonRepr (SchemaOptional (SchemaText '[TEq 3]))

36+type SchemaExample2 = 'SchemaObject

32−exampleTest = ReprOptional (Just (ReprText "lil"))

37+ '[ '("foo", 'SchemaArray '[ 'AEq 2] ('SchemaText '[ 'TGt 10]))

33−

38+ , '("bar", 'SchemaOptional ('SchemaText '[ 'TRegex "[0-9]+"]))]

34−exampleNumber :: JsonRepr (SchemaNumber '[NGt 10])

35−exampleNumber = ReprNumber 12

36−

37−exampleArray :: JsonRepr (SchemaArray '[AEq 1] (SchemaNumber '[NGt 10]))

38−exampleArray = ReprArray [exampleNumber]

40jsonExample :: JsonRepr SchemaExample

41−jsonExample = ReprObject $

41+jsonExample = withRepr @SchemaExample

42− FieldRepr (ReprArray [ReprNumber 12])

42+ $ field @"bar" (Just "bar")

43− :& FieldRepr (ReprOptional (Just (ReprText "bar")))

43+ :& field @"foo" [12]

44+ :& RNil

45+

46+type AddQuuz =

47+ 'Migration "add_field_quuz"

48+ '[ 'Diff '[] ('AddKey "quuz" (SchemaNumber '[])) ]

49+

50+type DeleteQuuz =

51+ 'Migration "remove_field_quuz"

52+ '[ 'Diff '[] ( 'DeleteKey "quuz") ]

53+

54+type SwapFields =

55+ 'Migration "swap_fields"

56+ '[ 'Diff '[ 'PKey "bar" ] ('Update

57+ ('SchemaArray '[ 'AEq 1] ('SchemaNumber '[ 'NGt 10])))

58+ , 'Diff '[ 'PKey "foo" ] ('Update

59+ ('SchemaOptional ('SchemaText '[ 'TEnum '["foo", "bar"]]))) ]

60+

61+type Migrations = '[ AddQuuz

62+ , DeleteQuuz ]

63+ -- , SwapFields ]

64+

65+type VersionedJson = 'Versioned SchemaExample Migrations

66+

67+migrationList :: MigrationList Identity VersionedJson

68+migrationList

69+ = (migrateObject (\r -> Identity $ field @"quuz" 42 :& r))

70+ :&& shrinkObject

71+ -- :&& (migrateObject (\r -> Identity

72+ -- $ field @"foo" (r ^. flens (Proxy @"bar") . _Just . optionalRepr)

73+ -- :& field @"bar" (r ^. flens (Proxy @"foo") . arrayRepr)

44− :& RNil

74+ -- :& RNil))

75+ :&& MNil

46schemaJson :: ByteString

77schemaJson :: ByteString

47schemaJson = "{\"foo\": [13], \"bar\": null}"

78schemaJson = "{\"foo\": [13], \"bar\": null}"

@@ -49,26 +80,11 @@ schemaJson = "{\"foo\": [13], \"bar\": null}"

49schemaJson2 :: ByteString

80schemaJson2 :: ByteString

50schemaJson2 = "{\"foo\": [3], \"bar\": null}"

81schemaJson2 = "{\"foo\": [3], \"bar\": null}"

52−schemaJsonTopVersion :: ByteString

53−schemaJsonTopVersion = "{ \"foo\": 42, \"bar\": \"bar\" }"

54−

55−topObject

56− :: JsonRepr

57− ('SchemaObject

58− '[ '("foo", 'SchemaNumber '[])

59− , '("bar", 'SchemaText '[])])

60−topObject = ReprObject $

61− FieldRepr (ReprNumber 42)

62− :& FieldRepr (ReprText "test")

63− :& RNil

64−

65−instance

66− MigrateSchema

67− SchemaExample

83+schemaJsonSeries :: Monad m => SC.Series m (JsonRepr SchemaExample)

68− ('SchemaObject

84+schemaJsonSeries = series

69− '[ '("foo", 'SchemaNumber '[]), '("bar", 'SchemaText '[])])

85+

70− where

86+schemaJsonSeries2 :: Monad m => SC.Series m (JsonRepr SchemaExample2)

71− migrate = const topObject

87+schemaJsonSeries2 = series

73spec :: Spec

89spec :: Spec

74spec = do

90spec = do

@@ -85,15 +101,22 @@ spec = do

85 it "validates incorrect representation" $

101 it "validates incorrect representation" $

86 ((decodeAndValidateJson schemaJson2) :: ParseResult (JsonRepr SchemaExample))

102 ((decodeAndValidateJson schemaJson2) :: ParseResult (JsonRepr SchemaExample))

87 `shouldSatisfy` isValidationError

103 `shouldSatisfy` isValidationError

88− it "validates versioned json" $ do

104+ -- it "validates versioned json" $ do

89− decodeAndValidateVersionedJson (Proxy @VS) schemaJson

105+ -- decodeAndValidateVersionedJson (Proxy @VS) schemaJson

90− `shouldSatisfy` isValid

106+ -- `shouldSatisfy` isValid

91− it "validates with Migration List" $ do

107+ it "validates versioned json with a migration list" $ do

92− decodeAndValidateVersionedWithMList

108+ decodeAndValidateVersionedWithPureMList

93− (Proxy @VS)

109+ (Proxy @VersionedJson)

94− ((:&&) (Proxy @(SchemaByRevision "test_revision" VS)) (const topObject) MNil)

110+ migrationList

95 schemaJson

111 schemaJson

96 `shouldSatisfy` isValid

112 `shouldSatisfy` isValid

113+ it "validates json series" $ property $

114+ SC.over schemaJsonSeries $ \x ->

115+ isValid (parseAndValidateJson @SchemaExample (toJSON x))

116+ it "validates json series 2" $ property $

117+ SC.over schemaJsonSeries2 $ \x ->

118+ isValid (parseAndValidateJson @SchemaExample2 (toJSON x))

119+

120

98main :: IO ()

121main :: IO ()

99main = hspec spec

122main = hspec spec