-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | The Infernal Machine - An AWS Lambda Custom Runtime for Haskell
--   
--   Please see the README on GitHub at
--   <a>https://github.com/ejconlon/infernal#readme</a>
@package infernal
@version 0.2.0


-- | The Infernal Machine - An AWS Lambda Custom Runtime for Haskell
--   
--   See <a>runLambda</a> or <a>runSimpleLambda</a> for entrypoints to
--   build your Lambda function.
module Infernal

-- | User callbacks to be invoked by the main loop (see <a>runLambda</a>).
data CallbackConfig n
CallbackConfig :: !RunCallback n -> !InvokeErrorCallback n -> !UncaughtErrorCallback n -> CallbackConfig n

-- | See <a>RunCallback</a>
[_cbcRunCallback] :: CallbackConfig n -> !RunCallback n

-- | See <a>InvokeErrorCallback</a>
[_cbcInvokeErrorCallback] :: CallbackConfig n -> !InvokeErrorCallback n

-- | See <a>UncaughtErrorCallback</a>
[_cbcUncaughtErrorCallback] :: CallbackConfig n -> !UncaughtErrorCallback n

-- | Error mapper for init errors. The result will be <tt>POST</tt>ed to
--   the init error endpoint (<a>docs</a>). Exceptions of type
--   <a>LambdaError</a> will not trigger this callback, and <a>ExitCode</a>
--   will be rethrown after it executes.
type InitErrorCallback n = SomeException -> n LambdaError

-- | Error mapper for invocation errors. The result will be <tt>POST</tt>ed
--   to the invocation error endpoint (<a>docs</a>). Exceptions of type
--   <a>LambdaError</a> will not trigger this callback, and <a>ExitCode</a>
--   will be rethrown after it executes.
type InvokeErrorCallback n = LambdaRequest -> SomeException -> n LambdaError

-- | An error formatted to propagate to AWS (<a>docs</a>). Note that this
--   is an <a>Exception</a> so you can throw it to short-circuit processing
--   and report useful information. If you throw anything else a
--   <a>defaultLambdaError</a> will be reported with no useful information.
data LambdaError
LambdaError :: !Text -> !Text -> LambdaError

-- | The type of error that occurred. In this library is is often
--   <tt>StartCase</tt>-formated.
[_lerrErrorType] :: LambdaError -> !Text

-- | A useful error message
[_lerrErrorMessage] :: LambdaError -> !Text

-- | The UUID associated with a Lambda request.
newtype LambdaRequestId
LambdaRequestId :: Text -> LambdaRequestId
[_unLambdaRequestId] :: LambdaRequestId -> Text

-- | The request parsed from the "next invocation" API (<a>docs</a>)
data LambdaRequest
LambdaRequest :: !LambdaRequestId -> !Text -> !Text -> !Int -> !ByteString -> LambdaRequest

-- | From the <tt>Lambda-Runtime-Aws-Request-Id</tt> header
[_lreqId] :: LambdaRequest -> !LambdaRequestId

-- | From the <tt>Lambda-Runtime-Trace-Id</tt> header
[_lreqTraceId] :: LambdaRequest -> !Text

-- | From the <tt>Lambda-Runtime-Invoked-Function-Arn</tt> header
[_lreqFunctionArn] :: LambdaRequest -> !Text

-- | From the <tt>Lambda-Runtime-Deadline-Ms</tt> header, an epoch deadline
--   in ms
[_lreqDeadlineMs] :: LambdaRequest -> !Int

-- | The unparsed request body. Typically you will <a>decode</a> this.
[_lreqBody] :: LambdaRequest -> !ByteString

-- | Environment variables set by AWS (<a>docs</a>). You may not need to
--   read any of these, but the implementation needs the API endpoint var
--   to handle requests.
data LambdaVars
LambdaVars :: !Text -> !Text -> !Text -> !Text -> !Text -> !Text -> !Text -> !Text -> LambdaVars

-- | From the <tt>AWS_LAMBDA_LOG_GROUP_NAME</tt> env var
[_lvLogGroupName] :: LambdaVars -> !Text

-- | From the <tt>AWS_LAMBDA_LOG_STREAM_NAME</tt> env var
[_lvLogStreamName] :: LambdaVars -> !Text

-- | From the <tt>AWS_LAMBDA_FUNCTION_VERSION</tt> env var
[_lvFunctionVersion] :: LambdaVars -> !Text

-- | From the <tt>AWS_LAMBDA_FUNCTION_NAME</tt> env var
[_lvFunctionName] :: LambdaVars -> !Text

-- | From the <tt>LAMBDA_TASK_ROOT</tt> env var
[_lvTaskRoot] :: LambdaVars -> !Text

-- | From the <tt>AWS_LAMBDA_RUNTIME_API</tt> env var
[_lvApiEndpoint] :: LambdaVars -> !Text

-- | From the <tt>AWS_LAMBDA_FUNCTION_MEMORY_SIZE</tt> env var
[_lvFunctionMemory] :: LambdaVars -> !Text

-- | From the <tt>_HANDLER</tt> env var
[_lvHandlerName] :: LambdaVars -> !Text

-- | The "function" part of your Lambda: takes a request with a
--   JSON-encoded body and returns a JSON-encoded response body. You can
--   throw any <a>Exception</a> and the appropriate error callbacks will
--   process it. Most importantly, <a>LambdaError</a> will propagate a
--   formatted error to AWS, and <a>ExitCode</a> will halt the program.
--   Except for <a>ExitCode</a>, throwing exceptions here will not
--   terminate the main loop (see <a>runLambda</a>). Note that the AWS
--   custom runtime loop implemented in this library is single-threaded (as
--   required - we must finish an invocation before fetching the next) but
--   you are free to spawn threads in your callback.
type RunCallback n = LambdaRequest -> n ByteString

-- | A handler for otherwise uncaught errors (like failures to fetch next
--   invocation). These happen outside context in which we can report them
--   to AWS, so there is no need to return a <a>LambdaError</a>. Exceptions
--   of type <a>ExitCode</a> will be rethrown after this callback executes.
type UncaughtErrorCallback n = SomeException -> n ()

-- | A <a>CallbackConfig</a> that returns <a>defaultLambdaError</a> from
--   all error callbacks.
defaultCallbackConfig :: Applicative n => RunCallback n -> CallbackConfig n

-- | A <a>LambdaError</a> that indicates a vague <tt>InternalError</tt> to
--   AWS.
defaultLambdaError :: LambdaError

-- | A <a>InitErrorCallback</a> that always returns
--   <a>defaultLambdaError</a>.
defaultInitErrorCallback :: Applicative n => InitErrorCallback n

-- | The full-powered entrypoint underlying <a>runSimpleLambda</a> that
--   allows you to use any <a>UnliftIO</a>-capable monad for your
--   callbacks. This runs the main loop of our AWS Lambda Custom Runtime to
--   fetch invocations, process them, and report errors or results. Control
--   will not return from this function, and AWS Lambda will terminate the
--   process at its will.
runLambda :: (MonadCatch m, WithSimpleLog env m) => UnliftIO n -> InitErrorCallback n -> (LambdaVars -> n (CallbackConfig n)) -> m ()

-- | A simple entrypoint that delegates to <a>runLambda</a>. Use this as
--   the body of your <tt>main</tt> function if you want to get a Lambda
--   function up and running quickly. All you need to do is provide a
--   <a>RunCallback</a> that handles JSON-encoded requests and returns
--   JSON-encoded responses (or throws <a>LambdaError</a> exceptions). Your
--   callback has access to a simple logger (try <a>logDebug</a>, for
--   example) whose output will be collected by Lambda and published to
--   CloudWatch.
runSimpleLambda :: RunCallback (RIO App) -> IO ()
instance Infernal.HasLambdaEnv Infernal.LambdaEnv
instance Heart.App.Logging.HasSimpleLog Infernal.LambdaEnv
instance GHC.Generics.Generic Infernal.LambdaError
instance GHC.Show.Show Infernal.LambdaError
instance GHC.Classes.Eq Infernal.LambdaError
instance GHC.Show.Show Infernal.LambdaRequest
instance GHC.Classes.Eq Infernal.LambdaRequest
instance Data.Hashable.Class.Hashable Infernal.LambdaRequestId
instance Data.String.IsString Infernal.LambdaRequestId
instance GHC.Classes.Ord Infernal.LambdaRequestId
instance GHC.Show.Show Infernal.LambdaRequestId
instance GHC.Classes.Eq Infernal.LambdaRequestId
instance GHC.Exception.Type.Exception Infernal.LambdaError
instance Data.Aeson.Types.ToJSON.ToJSON Infernal.LambdaError