Merge branch 'wip/yuras/omit_nothing' and add a little more testing

Author: thomasjm

aeson-typescript.cabal

@@ -4,7 +4,7 @@ cabal-version: 1.12
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 4cd249b25ad05ebb75210b2d877c1c9db25c3e5ad7ea0e05ca414f3120c3d342
+-- hash: b77cd606ddb441b9a4bc9592c1257172003cb38a9b39c2cc9b693a90110c1b52
 
 name:           aeson-typescript
 version:        0.2.0.0
@@ -81,8 +81,10 @@ test-suite aeson-typescript-test
     , unordered-containers
   other-modules:
       HigherKind
+      NoOmitNothingFields
       ObjectWithSingleFieldNoTagSingleConstructors
       ObjectWithSingleFieldTagSingleConstructors
+      OmitNothingFields
       TaggedObjectNoTagSingleConstructors
       TaggedObjectTagSingleConstructors
       TestBoilerplate

src/Data/Aeson/TypeScript/TH.hs

@@ -263,9 +263,9 @@ handleConstructor options (DatatypeInfo {..}) genericVariables ci@(ConstructorIn
     stringEncoding = (stringE [i|"#{(constructorTagModifier options) $ getTypeName (constructorName ci)}"|], Nothing, True)
 
     singleConstructorEncoding = if | constructorVariant ci == NormalConstructor -> tupleEncoding
-                                   | otherwise -> Just $ assembleInterfaceDeclaration (ListE (getTSFields namesAndTypes))
+                                   | otherwise -> Just $ assembleInterfaceDeclaration (ListE (getTSFields options namesAndTypes))
 
-    taggedConstructorEncoding = Just $ assembleInterfaceDeclaration (ListE (tagField ++ getTSFields namesAndTypes))
+    taggedConstructorEncoding = Just $ assembleInterfaceDeclaration (ListE (tagField ++ getTSFields options namesAndTypes))
 
     -- * Type declaration to use
     interfaceName = getInterfaceName ci
@@ -300,11 +300,19 @@ handleConstructor options (DatatypeInfo {..}) genericVariables ci@(ConstructorIn
 
 
 -- | Helper for handleConstructor
-getTSFields :: [(String, Type)] -> [Exp]
-getTSFields namesAndTypes = [(AppE (AppE (AppE (ConE 'TSField) (getOptionalAsBoolExp typ))
-                                     (stringE nameString))
-                               (getTypeAsStringExp typ))
-                            | (nameString, typ) <- namesAndTypes]
+getTSFields :: Options -> [(String, Type)] -> [Exp]
+getTSFields options namesAndTypes =
+  [ (AppE (AppE (AppE (ConE 'TSField) optAsBool)
+             (stringE nameString))
+       fieldTyp)
+  | (nameString, typ) <- namesAndTypes
+  , let (fieldTyp, optAsBool) = getFieldType options typ]
+
+getFieldType :: Options -> Type -> (Exp, Exp)
+getFieldType options (AppT (ConT name) t)
+  | not (omitNothingFields options) && name == ''Maybe
+  = (AppE (AppE (VarE 'mappend) (getTypeAsStringExp t)) (stringE " | null"), getOptionalAsBoolExp t)
+getFieldType _ typ = (getTypeAsStringExp typ, getOptionalAsBoolExp typ)
 
 
 -- * Getting type expression

test/NoOmitNothingFields.hs

@@ -0,0 +1,28 @@
+{-# LANGUAGE CPP, QuasiQuotes, OverloadedStrings, TemplateHaskell, RecordWildCards, ScopedTypeVariables, NamedFieldPuns, KindSignatures #-}
+
+module NoOmitNothingFields (tests) where
+
+import Data.Aeson as A
+import Data.Aeson.TypeScript.TH
+import Data.Aeson.TypeScript.Types
+import Data.Proxy
+import Test.Hspec
+import TestBoilerplate
+
+$(testDeclarations "NoOmitNothingFields" (A.defaultOptions {omitNothingFields=False}))
+
+main = hspec $ describe "NoOmitNothingFields" $ do
+  it "encodes as expected" $ do
+    let decls = getTypeScriptDeclarations (Proxy :: Proxy Optional)
+
+    decls `shouldBe` [TSInterfaceDeclaration {
+                         interfaceName = "Optional"
+                         , interfaceGenericVariables = []
+                         , interfaceMembers = [
+                             TSField {fieldOptional = False
+                                     , fieldName = "optionalInt"
+                                     , fieldType = "number | null"}
+                             ]
+                         }]
+
+  tests

test/OmitNothingFields.hs

@@ -0,0 +1,28 @@
+{-# LANGUAGE CPP, QuasiQuotes, OverloadedStrings, TemplateHaskell, RecordWildCards, ScopedTypeVariables, NamedFieldPuns, KindSignatures #-}
+
+module OmitNothingFields (tests) where
+
+import Data.Aeson as A
+import Data.Aeson.TypeScript.TH
+import Data.Aeson.TypeScript.Types
+import Data.Proxy
+import Test.Hspec
+import TestBoilerplate
+
+$(testDeclarations "OmitNothingFields" (A.defaultOptions {omitNothingFields=True}))
+
+main = hspec $ describe "OmitNothingFields" $ do
+  it "encodes as expected" $ do
+    let decls = getTypeScriptDeclarations (Proxy :: Proxy Optional)
+
+    decls `shouldBe` [TSInterfaceDeclaration {
+                         interfaceName = "Optional"
+                         , interfaceGenericVariables = []
+                         , interfaceMembers = [
+                             TSField {fieldOptional = True
+                                     , fieldName = "optionalInt"
+                                     , fieldType = "number"}
+                             ]
+                         }]
+
+  tests

test/Spec.hs

@@ -12,6 +12,8 @@ import qualified TwoElemArrayNoTagSingleConstructors
 import qualified TwoElemArrayTagSingleConstructors
 import qualified UntaggedNoTagSingleConstructors
 import qualified UntaggedTagSingleConstructors
+import qualified OmitNothingFields
+import qualified NoOmitNothingFields
 
 main = hspec $ do
   ObjectWithSingleFieldTagSingleConstructors.tests
@@ -23,3 +25,5 @@ main = hspec $ do
   UntaggedTagSingleConstructors.tests
   UntaggedNoTagSingleConstructors.tests
   HigherKind.tests
+  OmitNothingFields.tests
+  NoOmitNothingFields.tests

test/TestBoilerplate.hs

@@ -19,6 +19,7 @@ data TwoField = TwoField { doubleInt :: Int, doubleString :: String }
 data Hybrid = HybridSimple Int | HybridRecord { hybridString :: String }
 data TwoConstructor = Con1 { con1String :: String } | Con2 { con2String :: String, con2Int :: Int }
 data Complex a = Nullary | Unary Int | Product String Char a | Record { testOne :: Int, testTwo :: Bool, testThree :: Complex a} deriving Eq
+data Optional = Optional {optionalInt :: Maybe Int}
 
 
 testDeclarations :: String -> A.Options -> Q [Dec]
@@ -32,6 +33,7 @@ testDeclarations testName aesonOptions = do
     deriveInstances ''Hybrid
     deriveInstances ''TwoConstructor
     deriveInstances ''Complex
+    deriveInstances ''Optional
 
   typesAndValues :: Exp <- [e|[(getTypeScriptType (Proxy :: Proxy Unit), A.encode Unit)
 
@@ -52,7 +54,9 @@ testDeclarations testName aesonOptions = do
                               , (getTypeScriptType (Proxy :: Proxy (Complex Int)), A.encode (Nullary :: Complex Int))
                               , (getTypeScriptType (Proxy :: Proxy (Complex Int)), A.encode (Unary 42 :: Complex Int))
                               , (getTypeScriptType (Proxy :: Proxy (Complex Int)), A.encode (Product "asdf" 'g' 42 :: Complex Int))
-                              , (getTypeScriptType (Proxy :: Proxy (Complex Int)), A.encode ((Record { testOne = 3, testTwo = True, testThree = Product "test" 'A' 123}) :: Complex Int))]
+                              , (getTypeScriptType (Proxy :: Proxy (Complex Int)), A.encode ((Record { testOne = 3, testTwo = True, testThree = Product "test" 'A' 123}) :: Complex Int))
+                              , (getTypeScriptType (Proxy :: Proxy Optional), A.encode (Optional { optionalInt = Nothing }))
+                              , (getTypeScriptType (Proxy :: Proxy Optional), A.encode (Optional { optionalInt = Just 1 }))]
                            |]
 
   declarations :: Exp <- [e|getTypeScriptDeclarations (Proxy :: Proxy Unit)
@@ -63,6 +67,7 @@ testDeclarations testName aesonOptions = do
                          <> getTypeScriptDeclarations (Proxy :: Proxy Hybrid)
                          <> getTypeScriptDeclarations (Proxy :: Proxy TwoConstructor)
                          <> getTypeScriptDeclarations (Proxy :: Proxy Complex)
+                         <> getTypeScriptDeclarations (Proxy :: Proxy Optional)
                          |]
 
   tests <- [d|tests = describe $(return $ LitE $ StringL testName) $ it "type checks everything with tsc" $ testTypeCheckDeclarations $(return declarations) $(return typesAndValues)|]

test/Util.hs

@@ -70,7 +70,7 @@ testTypeCheckDeclarations tsDeclarations typesAndVals = withSystemTempDirectory
   writeFile tsFile contents
 
   tsc <- getTSC
-  (code, output, err) <- readProcessWithExitCode tsc ["--noEmit", "--skipLibCheck", "--traceResolution", "--noResolve", tsFile] ""
+  (code, output, err) <- readProcessWithExitCode tsc ["--strict", "--noEmit", "--skipLibCheck", "--traceResolution", "--noResolve", tsFile] ""
 
   when (code /= ExitSuccess) $ do
     error [i|TSC check failed: #{output}. File contents were\n\n#{contents}|]