Transforming a json escaped string

[nad-au]

I've got this payload which contains a Body which is a json escaped string

{
  "Data": {
    "req": {
      "Url": "http://localhost:7071/api/order",
      "Method": "POST",
      "Query": {},
      "Headers": {
        "Accept"         : ["application/json"                    ],
        "Connection"     : ["keep-alive"                          ],
        "Host"           : ["localhost:7071"                      ],
        "User-Agent"     : ["PostmanRuntime/7.43.0"               ],
        "Accept-Encoding": ["gzip, deflate, br"                   ],
        "Content-Type"   : ["application/json"                    ],
        "Content-Length" : ["45"                                  ],
        "Postman-Token"  : ["1107e3bb-3015-417e-ad97-082ce92c5b14"]
      },
      "Params": {},
      "Body": "{\n    \"productId\": \"abc\",\n    \"quantity\": 3\n}"
    }
  }
}

I'd need to unescape / transform / parse Body so that it ends up like:

{
  "Data": {
    "req": {
      "Url": "http://localhost:7071/api/order",
      "Method": "POST",
      "Query": {},
      "Headers": {
        "Accept"         : ["application/json"                    ],
        "Connection"     : ["keep-alive"                          ],
        "Host"           : ["localhost:7071"                      ],
        "User-Agent"     : ["PostmanRuntime/7.43.0"               ],
        "Accept-Encoding": ["gzip, deflate, br"                   ],
        "Content-Type"   : ["application/json"                    ],
        "Content-Length" : ["45"                                  ],
        "Postman-Token"  : ["1107e3bb-3015-417e-ad97-082ce92c5b14"]
      },
      "Params": {},
      "Body": {"productId": "abc", "quantity": 3}
    }
  }
}

I've tried a few ways such as:

export const orderItemSchema = t.Object({
    productId: t.String(),
    quantity: t.Number(),
})

const ProductOrder = t.Transform(t.String())
    .Decode(value => {
        const json = JSON.parse(value)
        return Value.Parse(orderItemSchema, json)
    })
    .Encode(value => JSON.stringify(value))

export const httpInputBindingSchema = t.Object({
    Url: t.String(),
    Method: t.Union([t.Literal('GET'), t.Literal('POST')]),
    Query: t.Record(t.String(), t.String()),
    Headers: t.Record(t.String(), t.Array(t.String())),
    Params: t.Record(t.String(), t.String()),
    Body: ProductOrder,
})

but Body always ends up as a string in the resulting payload. Any ideas?

[sinclairzx81]

@nad-au Hi,

The following seems to work ok (validating the Data.req part of the payload only)

import { Type as t } from '@sinclair/typebox'
import { Value } from '@sinclair/typebox/value'

export const orderItemSchema = t.Object({
  productId: t.String(),
  quantity: t.Number(),
})
const ProductOrder = t.Transform(t.String())
  .Decode(value => Value.Parse(orderItemSchema, JSON.parse(value)))
  .Encode(value => JSON.stringify(value))

export const httpInputBindingSchema = t.Object({
  Url: t.String(),
  Method: t.Union([t.Literal('GET'), t.Literal('POST')]),
  Query: t.Record(t.String(), t.String()),
  Headers: t.Record(t.String(), t.Array(t.String())),
  Params: t.Record(t.String(), t.String()),
  Body: ProductOrder,
})

const result = Value.Parse(httpInputBindingSchema, {
  "Url": "http://localhost:7071/api/order",
  "Method": "POST",
  "Query": {},
  "Headers": {
    "Accept": ["application/json"],
    "Connection": ["keep-alive"],
    "Host": ["localhost:7071"],
    "User-Agent": ["PostmanRuntime/7.43.0"],
    "Accept-Encoding": ["gzip, deflate, br"],
    "Content-Type": ["application/json"],
    "Content-Length": ["45"],
    "Postman-Token": ["1107e3bb-3015-417e-ad97-082ce92c5b14"]
  },
  "Params": {},
  "Body": "{\n    \"productId\": \"abc\",\n    \"quantity\": 3\n}"
})

console.log(result) // { ..., Body: { productId: 'abc', quantity: 3 } }

Your implementation of Transform is correct, and the above does seem to decode the Body ok. If you are seeing issues with the above and you are using a framework to receive the request, just be mindful that Transforms will only work if you are validating with TypeBox validation (either Parse or Decode). If you are using Ajv to validate (as many frameworks do), the Transform will be skipped and you will only see the string value. If this is the case, you may need to decode the Body manually inside your route handler.

Hope this helps
S

[nad-au]

Thankyou @sinclairzx81 indeed it is working, but only when running Value.Parse manually. I'm using https://elysiajs.com/ and it seems the transforms are not working as part of its built-in schema validations. A quick check on their issues and there seems to be a few outstanding relating to transforms.

I'll handle this manually for now.

[nad-au]

When using Type.Transform, validation errors in the transformed payload are not immediately apparent. Transform via Decode throws a TransformDecodeError which wraps the AssertError from the inner Parse. So one needs to dig out the inner AssertError. I've attempted to do this with a util included here if it helps anyone in future.

export const validateAndParseSchema = <Type extends TSchema, Output = StaticDecode<Type>, TResult extends Output = Output>(schema: TSchema, body: unknown): Result<TResult, ValueError[]> => {
    try {
        return Ok(Value.Parse(schema, body));
    } catch (e) {
        if (e instanceof AssertError) {
            const iterator = e.Errors()
            const errors = [...iterator]

            return Err(errors)
        }
        else if (e instanceof TransformDecodeError) {
            const innerError = e.error
            if (innerError instanceof AssertError) {
                const iterator = innerError.Errors()
                const errors = [...iterator]
    
                return Err(errors)    
            }
            return Err([{
                type: ValueErrorType.Object,
                schema: e.schema,
                path: e.path,
                value: e.value,
                message: e.message,
                errors: []
            }])
        }
        else if (e instanceof TypeBoxError) {
            throw new Error(`Unknown TypeBoxError: ${e.message}`, { cause: e })
        }
        throw e
    }
}