purescript-amqp/src/Node/AMQP/Types/Internal.purs

244 lines
12 KiB
Plaintext

module Node.AMQP.Types.Internal where
import Node.AMQP.Types
import Prelude
import Control.Monad.Eff (kind Effect)
import Data.DateTime.Instant (instant, unInstant)
import Data.Foreign (Foreign)
import Data.Foreign.Class (class Encode, encode)
import Data.Foreign.Generic (defaultOptions, genericEncode)
import Data.Foreign.NullOrUndefined (NullOrUndefined(..))
import Data.Generic.Rep (class Generic)
import Data.Int (floor, hexadecimal, toStringAs)
import Data.Newtype (unwrap)
import Data.Nullable (Nullable, toMaybe)
import Data.StrMap as StrMap
import Data.Time.Duration (Milliseconds(..), Seconds(..))
import Node.Buffer (Buffer)
connectUrl :: String -> ConnectOptions -> String
connectUrl url { frameMax, channelMax, heartbeat : (Seconds heartbeat) } =
url <> "?frame_max=0x" <> toStringAs hexadecimal frameMax
<> "&channel_max=" <> show channelMax
<> "&heartbeat=" <> show (floor heartbeat)
encodeQueueOptions :: QueueOptions -> Foreign
encodeQueueOptions = fromQueueOptions >>> encode
encodeDeleteQueueOptions :: DeleteQueueOptions -> Foreign
encodeDeleteQueueOptions = fromDeleteQueueOptions >>> encode
encodeExchangeOptions :: ExchangeOptions -> Foreign
encodeExchangeOptions = fromExchangeOptions >>> encode
encodeDeleteExchangeOptions :: DeleteExchangeOptions -> Foreign
encodeDeleteExchangeOptions = fromDeleteExchangeOptions >>> encode
encodePublishOptions :: PublishOptions -> Foreign
encodePublishOptions = fromPublishOptions >>> encode
encodeConsumeOptions :: ConsumeOptions -> Foreign
encodeConsumeOptions = fromConsumeOptions >>> encode
encodeGetOptions :: GetOptions -> Foreign
encodeGetOptions = fromGetOptions >>> encode
newtype QueueOptions' = QueueOptions'
{ exclusive :: NullOrUndefined Boolean
, durable :: NullOrUndefined Boolean
, autoDelete :: NullOrUndefined Boolean
, arguments :: StrMap.StrMap Foreign
, messageTtl :: NullOrUndefined Number
, expires :: NullOrUndefined Number
, deadLetterExchange :: NullOrUndefined String
, deadLetterRoutingKey :: NullOrUndefined String
, maxLength :: NullOrUndefined Int
, maxPriority :: NullOrUndefined Int
}
derive instance genericQueueOptions' :: Generic QueueOptions' _
instance encodeQueueOptions' :: Encode QueueOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromQueueOptions :: QueueOptions -> QueueOptions'
fromQueueOptions opts = QueueOptions'
{ exclusive : NullOrUndefined opts.exclusive
, durable : NullOrUndefined opts.durable
, autoDelete : NullOrUndefined opts.autoDelete
, arguments : opts.arguments
, messageTtl : NullOrUndefined (unwrap <$> opts.messageTTL)
, expires : NullOrUndefined (unwrap <$> opts.expires)
, deadLetterExchange : NullOrUndefined opts.deadLetterExchange
, deadLetterRoutingKey: NullOrUndefined opts.deadLetterRoutingKey
, maxLength : NullOrUndefined opts.maxLength
, maxPriority : NullOrUndefined opts.maxPriority
}
newtype DeleteQueueOptions' = DeleteQueueOptions'
{ ifUnused :: NullOrUndefined Boolean
, ifEmpty :: NullOrUndefined Boolean }
derive instance genericDeleteQueueOptions' :: Generic DeleteQueueOptions' _
instance encodeDeleteQueueOptions' :: Encode DeleteQueueOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromDeleteQueueOptions :: DeleteQueueOptions -> DeleteQueueOptions'
fromDeleteQueueOptions opts = DeleteQueueOptions'
{ ifUnused: NullOrUndefined opts.ifUnused
, ifEmpty : NullOrUndefined opts.ifEmpty
}
newtype ExchangeOptions' = ExchangeOptions'
{ durable :: NullOrUndefined Boolean
, internal :: NullOrUndefined Boolean
, autoDelete :: NullOrUndefined Boolean
, alternateExchange :: NullOrUndefined String
, arguments :: StrMap.StrMap Foreign
}
derive instance genericExchangeOptions' :: Generic ExchangeOptions' _
instance encodeExchangeOptions' :: Encode ExchangeOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromExchangeOptions :: ExchangeOptions -> ExchangeOptions'
fromExchangeOptions opts = ExchangeOptions'
{ durable : NullOrUndefined opts.durable
, internal : NullOrUndefined opts.internal
, autoDelete : NullOrUndefined opts.autoDelete
, alternateExchange: NullOrUndefined opts.alternateExchange
, arguments : opts.arguments
}
newtype DeleteExchangeOptions' = DeleteExchangeOptions' { ifUnused :: NullOrUndefined Boolean }
derive instance genericDeleteExchangeOptions' :: Generic DeleteExchangeOptions' _
instance encodeDeleteExchangeOptions' :: Encode DeleteExchangeOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromDeleteExchangeOptions :: DeleteExchangeOptions -> DeleteExchangeOptions'
fromDeleteExchangeOptions opts = DeleteExchangeOptions' { ifUnused: NullOrUndefined opts.ifUnused }
newtype PublishOptions' = PublishOptions'
{ expiration :: NullOrUndefined String
, userId :: NullOrUndefined String
, "CC" :: Array RoutingKey
, "BCC" :: Array RoutingKey
, priority :: NullOrUndefined Int
, persistent :: NullOrUndefined Boolean
, mandatory :: NullOrUndefined Boolean
, contentType :: NullOrUndefined String
, contentEncoding :: NullOrUndefined String
, headers :: StrMap.StrMap Foreign
, correlationId :: NullOrUndefined String
, replyTo :: NullOrUndefined QueueName
, messageId :: NullOrUndefined String
, timestamp :: NullOrUndefined Number
, type :: NullOrUndefined String
, appId :: NullOrUndefined String
}
derive instance genericPublishOptions' :: Generic PublishOptions' _
instance encodePublishOptions' :: Encode PublishOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromPublishOptions :: PublishOptions -> PublishOptions'
fromPublishOptions opts = PublishOptions'
{ expiration : NullOrUndefined (show <$> opts.expiration)
, userId : NullOrUndefined opts.userId
, "CC" : opts.cc
, "BCC" : opts.bcc
, priority : NullOrUndefined opts.priority
, persistent : NullOrUndefined opts.persistent
, mandatory : NullOrUndefined opts.mandatory
, contentType : NullOrUndefined opts.contentType
, contentEncoding: NullOrUndefined opts.contentEncoding
, headers : opts.headers
, correlationId : NullOrUndefined opts.correlationId
, replyTo : NullOrUndefined opts.replyTo
, messageId : NullOrUndefined opts.messageId
, timestamp : NullOrUndefined ((unwrap <<< unInstant) <$> opts.timestamp)
, type : NullOrUndefined opts.type
, appId : NullOrUndefined opts.appId
}
newtype MessageProperties' = MessageProperties'
{ expiration :: Nullable Number
, userId :: Nullable String
, priority :: Nullable Int
, deliveryMode :: Nullable Int
, contentType :: Nullable String
, contentEncoding :: Nullable String
, headers :: StrMap.StrMap Foreign
, correlationId :: Nullable String
, replyTo :: Nullable QueueName
, messageId :: Nullable String
, timestamp :: Nullable Number
, type :: Nullable String
, appId :: Nullable String
}
newtype Message' = Message'
{ content :: Buffer
, fields :: MessageFields
, properties :: MessageProperties'
}
toMessage :: Message' -> Message
toMessage (Message' { content, fields, properties: (MessageProperties' props) }) =
{ content, fields, properties: msgProperties }
where
msgProperties = { expiration : Milliseconds <$> toMaybe props.expiration
, userId : toMaybe props.userId
, priority : toMaybe props.priority
, persistent : (_ == 2) <$> toMaybe props.deliveryMode
, contentType : toMaybe props.contentType
, contentEncoding : toMaybe props.contentEncoding
, headers : props.headers
, correlationId : toMaybe props.correlationId
, replyTo : toMaybe props.replyTo
, messageId : toMaybe props.messageId
, timestamp : join $ instant <$> (Milliseconds <$> toMaybe props.timestamp)
, type : toMaybe props.type
, appId : toMaybe props.appId
}
newtype ConsumeOptions' = ConsumeOptions'
{ consumerTag :: NullOrUndefined String
, noLocal :: NullOrUndefined Boolean
, noAck :: NullOrUndefined Boolean
, exclusive :: NullOrUndefined Boolean
, priority :: NullOrUndefined Int
, arguments :: StrMap.StrMap Foreign
}
derive instance genericConsumeOptions' :: Generic ConsumeOptions' _
instance encodeConsumeOptions' :: Encode ConsumeOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromConsumeOptions :: ConsumeOptions -> ConsumeOptions'
fromConsumeOptions opts = ConsumeOptions'
{ consumerTag: NullOrUndefined opts.consumerTag
, noLocal : NullOrUndefined opts.noLocal
, noAck : NullOrUndefined opts.noAck
, exclusive : NullOrUndefined opts.exclusive
, priority : NullOrUndefined opts.priority
, arguments : opts.arguments
}
newtype GetOptions' = GetOptions' { noAck :: NullOrUndefined Boolean }
derive instance genericGetOptions' :: Generic GetOptions' _
instance encodeGetOptions' :: Encode GetOptions' where
encode = genericEncode $ defaultOptions { unwrapSingleConstructors = true }
fromGetOptions :: GetOptions -> GetOptions'
fromGetOptions opts = GetOptions' { noAck: NullOrUndefined opts.noAck }