hide-a-bed 6.0.0 → 7.0.0-beta.0

package/eslint.config.js

@@ -11,5 +11,10 @@ export default defineConfig([
     extends: ['js/recommended'],
     languageOptions: { globals: globals.browser }
   },
-  tseslint.configs.recommended
+  tseslint.configs.recommended,
+  {
+    rules: {
+      '@typescript-eslint/no-unused-vars': ['error', { ignoreRestSiblings: true }]
+    }
+  }
 ])

package/impl/bindConfig.mts

@@ -20,7 +20,34 @@ import { remove } from './remove.mts'
 import { createLock, removeLock } from './sugar/lock.mts'
 import { watchDocs } from './sugar/watch.mts'
 
-export type BoundInstance = ReturnType<typeof doBind> & {
+type BoundConfigMethod<T> = T extends (...args: infer Args) => infer Result
+  ? Args extends [unknown, ...infer Rest]
+    ? (...args: Rest) => Result
+    : never
+  : never
+
+type BoundMethods = {
+  bulkGet: BulkGetBound
+  bulkGetDictionary: BulkGetDictionaryBound
+  get: GetBound
+  getAtRev: GetAtRevBound
+  query: QueryBound
+  bulkRemove: BoundConfigMethod<typeof bulkRemove>
+  bulkRemoveMap: BoundConfigMethod<typeof bulkRemoveMap>
+  bulkSave: BoundConfigMethod<typeof bulkSave>
+  bulkSaveTransaction: BoundConfigMethod<typeof bulkSaveTransaction>
+  getDBInfo: BoundConfigMethod<typeof getDBInfo>
+  patch: BoundConfigMethod<typeof patch>
+  patchDangerously: BoundConfigMethod<typeof patchDangerously>
+  put: BoundConfigMethod<typeof put>
+  queryStream: BoundConfigMethod<typeof queryStream>
+  remove: BoundConfigMethod<typeof remove>
+  createLock: BoundConfigMethod<typeof createLock>
+  removeLock: BoundConfigMethod<typeof removeLock>
+  watchDocs: BoundConfigMethod<typeof watchDocs>
+}
+
+export type BoundInstance = BoundMethods & {
   options(overrides: Partial<z.input<typeof CouchConfig>>): BoundInstance
 }
 
@@ -81,7 +108,7 @@ export function getBoundWithRetry<
  * @param config The CouchDB configuration
  * @returns An object with CouchDB operations bound to the provided configuration
  */
-function doBind(config: CouchConfig) {
+function doBind(config: CouchConfig): BoundMethods {
   // Default retry options
   const retryOptions = {
     maxRetries: config.maxRetries ?? 10,
@@ -90,7 +117,7 @@ function doBind(config: CouchConfig) {
   }
 
   // Create the object without the config property first
-  const result = {
+  const result: BoundMethods = {
     /**
      * These functions use overloaded signatures when bound.
      * To preserve the overloads we need dedicated Bound types

package/impl/bulkGet.mts

@@ -1,8 +1,6 @@
-import needle from 'needle'
 import { CouchConfig, type CouchConfigInput } from '../schema/config.mts'
 import { createLogger } from './utils/logger.mts'
-import { mergeNeedleOpts } from './utils/mergeNeedleOpts.mts'
-import { RetryableError } from './utils/errors.mts'
+import { RetryableError, createResponseError } from './utils/errors.mts'
 import {
   ViewQueryResponse,
   type ViewQueryResponseValidated,
@@ -11,6 +9,15 @@ import {
 } from '../schema/couch/couch.output.schema.ts'
 import type { StandardSchemaV1 } from '../types/standard-schema.ts'
 import { parseRows, type OnInvalidDocAction } from './utils/parseRows.mts'
+import { fetchCouchJson } from './utils/fetch.mts'
+import { isSuccessStatusCode } from './utils/response.mts'
+import { createCouchPathUrl } from './utils/url.mts'
+
+type BulkGetBody = {
+  error?: string
+  reason?: string
+  rows?: unknown[]
+} & Record<string, unknown>
 
 export type BulkGetResponse<DocSchema extends StandardSchemaV1 = StandardSchemaV1<CouchDoc>> =
   ViewQueryResponseValidated<
@@ -39,13 +46,13 @@ export type BulkGetOptions<DocSchema extends StandardSchemaV1> = {
  * @returns The raw response body from CouchDB
  *
  * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
- * @throws {Error} When CouchDB returns a non-retryable error payload.
+ * @throws {OperationError} When CouchDB returns a non-retryable request-level failure.
  */
 async function executeBulkGet(
   _config: CouchConfigInput,
   ids: Array<string | undefined>,
   includeDocs: boolean
-) {
+): Promise<BulkGetBody | undefined> {
   const configParseResult = CouchConfig.safeParse(_config)
   const logger = createLogger(_config)
   logger.info(`Starting bulk get for ${ids.length} documents`)
@@ -56,30 +63,40 @@ async function executeBulkGet(
   }
 
   const config = configParseResult.data
-  const url = `${config.couch}/_all_docs${includeDocs ? '?include_docs=true' : ''}`
-  const payload = { keys: ids }
-  const opts = {
-    json: true,
-    headers: {
-      'Content-Type': 'application/json'
-    }
+  const url = createCouchPathUrl('_all_docs', config.couch)
+  if (includeDocs) {
+    url.searchParams.append('include_docs', 'true')
   }
-  const mergedOpts = mergeNeedleOpts(config, opts)
+  const payload = { keys: ids }
 
   try {
-    const resp = await needle('post', url, payload, mergedOpts)
+    const resp = await fetchCouchJson<BulkGetBody>({
+      auth: config.auth,
+      method: 'POST',
+      operation: 'request',
+      request: config.request,
+      url,
+      body: payload
+    })
     if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
       logger.warn(`Retryable status code received: ${resp.statusCode}`)
-      throw new RetryableError('retryable error during bulk get', resp.statusCode)
+      throw new RetryableError('Bulk get failed', resp.statusCode, {
+        operation: 'request'
+      })
     }
-    if (resp.statusCode !== 200) {
+    if (!isSuccessStatusCode('bulkGet', resp.statusCode)) {
       logger.error(`Unexpected status code: ${resp.statusCode}`)
-      throw new Error('could not fetch')
+      throw createResponseError({
+        body: resp.body,
+        defaultMessage: 'Bulk get failed',
+        operation: 'request',
+        statusCode: resp.statusCode
+      })
     }
     return resp.body
   } catch (err) {
     logger.error('Network error during bulk get:', err)
-    RetryableError.handleNetworkError(err)
+    RetryableError.handleNetworkError(err, 'request')
   }
 }
 
@@ -95,8 +112,8 @@ async function executeBulkGet(
  * @returns The bulk get response with rows optionally validated against the supplied document schema.
  *
  * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
- * @throws {Error<StandardSchemaV1.FailureResult["issues"]>} When the configuration or validation schemas fail to parse.
- * @throws {Error} When CouchDB returns a non-retryable error payload.
+ * @throws {ValidationError} When returned documents fail schema validation.
+ * @throws {OperationError} When CouchDB returns a non-retryable request-level failure.
  */
 async function _bulkGetWithOptions<DocSchema extends StandardSchemaV1 = typeof CouchDoc>(
   config: CouchConfigInput,
@@ -107,16 +124,22 @@ async function _bulkGetWithOptions<DocSchema extends StandardSchemaV1 = typeof C
   const body = await executeBulkGet(config, ids, includeDocs)
 
   if (!body) {
-    throw new RetryableError('no response', 503)
+    throw new RetryableError('Bulk get failed', 503, { operation: 'request' })
   }
 
   if (body.error) {
-    throw new Error(typeof body.reason === 'string' ? body.reason : 'could not fetch')
+    throw createResponseError({
+      body,
+      defaultMessage: 'Bulk get failed',
+      operation: 'request'
+    })
   }
 
   const docSchema = options.validate?.docSchema || CouchDoc
   const rows = await parseRows(body.rows, {
+    defaultMessage: 'Bulk get failed',
     onInvalidDoc: options.validate?.onInvalidDoc,
+    operation: 'request',
     docSchema
   })
 
@@ -144,8 +167,8 @@ async function _bulkGetWithOptions<DocSchema extends StandardSchemaV1 = typeof C
  * @returns The bulk get response with rows optionally validated against the supplied document schema.
  *
  * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
- * @throws {Error<StandardSchemaV1.FailureResult["issues"]>} When the configuration or validation schemas fail to parse.
- * @throws {Error} When CouchDB returns a non-retryable error payload.
+ * @throws {ValidationError} When returned documents fail schema validation.
+ * @throws {OperationError} When CouchDB returns a non-retryable request-level failure.
  */
 export async function bulkGet<DocSchema extends StandardSchemaV1 = typeof CouchDoc>(
   config: CouchConfigInput,
@@ -196,7 +219,7 @@ export type BulkGetDictionaryResult<
 /**
  * Bulk get documents by IDs and return a dictionary of found and not found documents.
  *
- * @template DocSchema - Schema used to validate each returned document, if provided. Note: if a document is found and it fails validation this will throw a Error<StandardSchemaV1.FailureResult["issues"]>.
+ * @template DocSchema - Schema used to validate each returned document, if provided. Note: if a document is found and it fails validation this will throw a ValidationError.
  *
  * @param config - CouchDB configuration data that is validated before use.
  * @param ids - Array of document IDs to retrieve.
@@ -205,8 +228,8 @@ export type BulkGetDictionaryResult<
  * @returns An object containing found documents and not found rows.
  *
  * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
- * @throws {Error<StandardSchemaV1.FailureResult["issues"]>} When the configuration or validation schemas fail to parse.
- * @throws {Error} When CouchDB returns a non-retryable error payload.
+ * @throws {ValidationError} When returned documents fail schema validation.
+ * @throws {OperationError} When CouchDB returns a non-retryable request-level failure.
  */
 export async function bulkGetDictionary<DocSchema extends StandardSchemaV1 = typeof CouchDoc>(
   config: CouchConfigInput,

package/impl/bulkRemove.mts

@@ -27,7 +27,8 @@ import { CouchConfig, type CouchConfigInput } from '../schema/config.mts'
  * console.log(results);
  * ```
  *
- * @throws Will throw an error if the provided configuration is invalid or if the bulk delete operation fails.
+ * @throws {RetryableError} When the bulk request fails with a retryable transport or HTTP error.
+ * @throws {OperationError} When CouchDB returns a non-retryable request-level failure.
  */
 export const bulkRemove = async (configInput: CouchConfigInput, ids: string[]) => {
   const config = CouchConfig.parse(configInput)
@@ -71,7 +72,8 @@ export const bulkRemove = async (configInput: CouchConfigInput, ids: string[]) =
  * console.log(results);
  * ```
  *
- * @throws Will throw an error if the provided configuration is invalid or if any delete operation fails.
+ * @throws {RetryableError} When a request-level transport or retryable HTTP failure occurs.
+ * @throws {OperationError} When a request fails in a non-retryable way.
  */
 export const bulkRemoveMap = async (configInput: CouchConfigInput, ids: string[]) => {
   const config = CouchConfig.parse(configInput)

package/impl/bulkSave.mts

@@ -1,6 +1,4 @@
-import needle from 'needle'
 import { createLogger } from './utils/logger.mts'
-import { mergeNeedleOpts } from './utils/mergeNeedleOpts.mts'
 import { bulkGetDictionary } from './bulkGet.mts'
 import { setupEmitter } from './utils/trackedEmitter.mts'
 import {
@@ -14,10 +12,18 @@ import {
   CouchDoc,
   type CouchDocInput
 } from '../schema/couch/couch.output.schema.ts'
-import type { CouchConfigInput } from '../schema/config.mts'
-import { RetryableError } from './utils/errors.mts'
+import { CouchConfig, type CouchConfigInput } from '../schema/config.mts'
+import {
+  ConflictError,
+  OperationError,
+  RetryableError,
+  createResponseError
+} from './utils/errors.mts'
 import { withRetry } from './retry.mts'
 import { put } from './put.mts'
+import { fetchCouchJson } from './utils/fetch.mts'
+import { isSuccessStatusCode } from './utils/response.mts'
+import { createCouchPathUrl } from './utils/url.mts'
 
 /**
  * Bulk saves documents to CouchDB using the _bulk_docs endpoint.
@@ -30,44 +36,54 @@ import { put } from './put.mts'
  * @returns {Promise<BulkSaveResponse>} - The response from CouchDB after the bulk save operation.
  *
  * @throws {RetryableError} When a retryable HTTP status code is encountered or no response is received.
- * @throws {Error} When CouchDB returns a non-retryable error payload.
+ * @throws {OperationError} When bulk save input is invalid or CouchDB returns a non-retryable request-level failure.
  */
 export const bulkSave = async (config: CouchConfigInput, docs: CouchDocInput[]) => {
-  const logger = createLogger(config)
+  const parsedConfig = CouchConfig.parse(config)
+  const logger = createLogger(parsedConfig)
 
   if (docs == null || !docs.length) {
     logger.error('bulkSave called with no docs')
-    throw new Error('no docs provided')
+    throw new OperationError('Bulk save requires at least one document', {
+      operation: 'request'
+    })
   }
 
   logger.info(`Starting bulk save of ${docs.length} documents`)
-  const url = `${config.couch}/_bulk_docs`
+  const url = createCouchPathUrl('_bulk_docs', parsedConfig.couch)
   const body = { docs }
-  const opts = {
-    json: true,
-    headers: {
-      'Content-Type': 'application/json'
-    }
-  }
-  const mergedOpts = mergeNeedleOpts(config, opts)
   let resp
   try {
-    resp = await needle('post', url, body, mergedOpts)
+    resp = await fetchCouchJson({
+      auth: parsedConfig.auth,
+      method: 'POST',
+      operation: 'request',
+      request: parsedConfig.request,
+      url,
+      body
+    })
   } catch (err) {
     logger.error('Network error during bulk save:', err)
-    RetryableError.handleNetworkError(err)
+    RetryableError.handleNetworkError(err, 'request')
   }
   if (!resp) {
     logger.error('No response received from bulk save request')
-    throw new RetryableError('no response', 503)
+    throw new RetryableError('Bulk save failed', 503, { operation: 'request' })
   }
   if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
     logger.warn(`Retryable status code received: ${resp.statusCode}`)
-    throw new RetryableError('retryable error during bulk save', resp.statusCode)
+    throw new RetryableError('Bulk save failed', resp.statusCode, {
+      operation: 'request'
+    })
   }
-  if (resp.statusCode !== 201) {
+  if (!isSuccessStatusCode('bulkSave', resp.statusCode)) {
     logger.error(`Unexpected status code: ${resp.statusCode}`)
-    throw new Error('could not save')
+    throw createResponseError({
+      body: resp.body,
+      defaultMessage: 'Bulk save failed',
+      operation: 'request',
+      statusCode: resp.statusCode
+    })
   }
   const results = resp?.body || []
   return BulkSaveResponse.parse(results)
@@ -151,18 +167,24 @@ export const bulkSaveTransaction = async (
   }
 
   // Save transaction document
-  let transactionResponse = await _put(transactionDoc)
+  let transactionResponse
+  try {
+    transactionResponse = await _put(transactionDoc)
+  } catch (error) {
+    if (error instanceof ConflictError) {
+      throw new TransactionSetupError('Failed to create transaction document', {
+        error: error.couchError,
+        response: error
+      })
+    }
+
+    throw error
+  }
   logger.debug('Transaction document created:', transactionDoc, transactionResponse)
   await emitter.emit('transaction-created', {
     transactionResponse,
     txnDoc: transactionDoc
   })
-  if (transactionResponse.error) {
-    throw new TransactionSetupError('Failed to create transaction document', {
-      error: transactionResponse.error,
-      response: transactionResponse
-    })
-  }
 
   // Get current revisions of all documents
   const existingDocs = await bulkGetDictionary(

package/impl/get.mts

@@ -1,11 +1,17 @@
-import needle from 'needle'
 import { z } from 'zod'
-import type { CouchConfigInput } from '../schema/config.mts'
 import { createLogger } from './utils/logger.mts'
-import { mergeNeedleOpts } from './utils/mergeNeedleOpts.mts'
-import { RetryableError, NotFoundError } from './utils/errors.mts'
+import {
+  RetryableError,
+  NotFoundError,
+  ValidationError,
+  createResponseError
+} from './utils/errors.mts'
 import type { StandardSchemaV1 } from '../types/standard-schema.ts'
 import { CouchDoc } from '../schema/couch/couch.output.schema.ts'
+import { fetchCouchJson } from './utils/fetch.mts'
+import { CouchConfig, type CouchConfigInput } from '../schema/config.mts'
+import { isSuccessStatusCode } from './utils/response.mts'
+import { createCouchDocUrl } from './utils/url.mts'
 
 export type GetOptions<DocSchema extends StandardSchemaV1> = {
   validate?: {
@@ -26,7 +32,7 @@ const ValidSchema = z.custom(
   }
 )
 
-export const CouchGetOptions = z.object({
+export const CouchGetOptions = z.strictObject({
   rev: z.string().optional().describe('the couch doc revision'),
   validate: z
     .object({
@@ -37,74 +43,74 @@ export const CouchGetOptions = z.object({
 })
 
 async function _getWithOptions<DocSchema extends StandardSchemaV1>(
-  config: CouchConfigInput,
+  configInput: CouchConfigInput,
   id: string,
   options: InternalGetOptions<DocSchema>
 ): Promise<StandardSchemaV1.InferOutput<DocSchema> | null> {
-  const parsedOptions = CouchGetOptions.parse({
-    rev: options.rev,
-    validate: options.validate
-  })
+  const config = CouchConfig.parse(configInput)
+  const parsedOptions = CouchGetOptions.parse(options)
 
   const logger = createLogger(config)
   const rev = parsedOptions.rev
-  const path = rev ? `${id}?rev=${rev}` : id
-  const url = `${config.couch}/${path}`
+  const operation = rev ? 'getAtRev' : 'get'
+  const url = createCouchDocUrl(id, config.couch)
 
-  const httpOptions = {
-    json: true,
-    headers: {
-      'Content-Type': 'application/json'
-    }
+  if (rev) {
+    url.searchParams.set('rev', rev)
   }
-
-  const requestOptions = mergeNeedleOpts(config, httpOptions)
   logger.info(`Getting document with id: ${id}, rev ${rev ?? 'latest'}`)
 
   try {
-    const resp = await needle('get', url, null, requestOptions)
+    const resp = await fetchCouchJson({
+      auth: config.auth,
+      method: 'GET',
+      operation,
+      request: config.request,
+      url
+    })
     if (!resp) {
       logger.error('No response received from get request')
-      throw new RetryableError('no response', 503)
+      throw new RetryableError('Request failed', 503, { operation })
     }
 
     const body = resp.body ?? null
 
     if (resp.statusCode === 404) {
-      if (config.throwOnGetNotFound) {
-        const reason = typeof body?.reason === 'string' ? body.reason : 'not_found'
-        logger.warn(`Document not found (throwing error): ${id}, rev ${rev ?? 'latest'}`)
-        throw new NotFoundError(id, reason)
+      logger.warn(`Document not found: ${id}, rev ${rev ?? 'latest'}`)
+      if (config.throwOnGetNotFound === false) {
+        return null
       }
-
-      logger.debug(`Document not found (returning undefined): ${id}, rev ${rev ?? 'latest'}`)
-      return null
-    }
-
-    if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
-      const reason = typeof body?.reason === 'string' ? body.reason : 'retryable error'
-      logger.warn(`Retryable status code received: ${resp.statusCode}`)
-      throw new RetryableError(reason, resp.statusCode)
+      throw new NotFoundError(id, { operation, statusCode: resp.statusCode })
     }
 
-    if (resp.statusCode !== 200) {
-      const reason = typeof body?.reason === 'string' ? body.reason : 'failed'
+    if (!isSuccessStatusCode('documentRead', resp.statusCode)) {
       logger.error(`Unexpected status code: ${resp.statusCode}`)
-      throw new Error(reason)
+      throw createResponseError({
+        body,
+        defaultMessage: 'Failed to fetch document',
+        docId: id,
+        operation,
+        statusCode: resp.statusCode
+      })
     }
 
     const docSchema = (parsedOptions.validate?.docSchema ?? CouchDoc) as DocSchema
     const typedDoc = await docSchema['~standard'].validate(body)
 
     if (typedDoc.issues) {
-      throw typedDoc.issues
+      throw new ValidationError({
+        docId: id,
+        issues: typedDoc.issues,
+        message: 'Document validation failed',
+        operation
+      })
     }
 
     logger.info(`Successfully retrieved document: ${id}, rev ${rev ?? 'latest'}`)
     return typedDoc.value
   } catch (err) {
     logger.error('Error during get operation:', err)
-    RetryableError.handleNetworkError(err)
+    RetryableError.handleNetworkError(err, operation)
   }
 }
 
@@ -127,7 +133,10 @@ export async function getAtRev<DocSchema extends StandardSchemaV1>(
   rev: string,
   options?: GetOptions<DocSchema>
 ): Promise<StandardSchemaV1.InferOutput<DocSchema> | null> {
-  return _getWithOptions<DocSchema>(config, id, { ...options, rev })
+  return _getWithOptions<DocSchema>(config, id, {
+    ...options,
+    rev
+  })
 }
 
 export type GetAtRevBound = <DocSchema extends StandardSchemaV1 = typeof CouchDoc>(

package/impl/getDBInfo.mts

@@ -1,9 +1,10 @@
-import needle, { type NeedleResponse } from 'needle'
-import { RetryableError } from './utils/errors.mts'
+import { RetryableError, createResponseError } from './utils/errors.mts'
 import { createLogger } from './utils/logger.mts'
-import { mergeNeedleOpts } from './utils/mergeNeedleOpts.mts'
 import { CouchConfig, type CouchConfigInput } from '../schema/config.mts'
 import { CouchDBInfo } from '../schema/couch/couch.output.schema.ts'
+import { fetchCouchJson } from './utils/fetch.mts'
+import { isSuccessStatusCode } from './utils/response.mts'
+import { createCouchDbUrl } from './utils/url.mts'
 
 /**
  * Fetches and returns CouchDB database information.
@@ -13,7 +14,7 @@ import { CouchDBInfo } from '../schema/couch/couch.output.schema.ts'
  * @param configInput - The CouchDB configuration input.
  * @returns A promise that resolves to the CouchDB database information.
  * @throws {RetryableError} `RetryableError` If a retryable error occurs during the request.
- * @throws {Error} `Error` For other non-retryable errors.
+ * @throws {OperationError} `OperationError` For other non-retryable response failures.
  *
  * @example
  * ```ts
@@ -33,35 +34,36 @@ import { CouchDBInfo } from '../schema/couch/couch.output.schema.ts'
 export const getDBInfo = async (configInput: CouchConfigInput) => {
   const config = CouchConfig.parse(configInput)
   const logger = createLogger(config)
-  const url = `${config.couch}`
+  const url = createCouchDbUrl(config.couch)
 
-  let resp: NeedleResponse | undefined
+  let resp
   try {
-    resp = await needle(
-      'get',
-      url,
-      mergeNeedleOpts(config, {
-        json: true,
-        headers: {
-          'Content-Type': 'application/json'
-        }
+    resp = await fetchCouchJson({
+      auth: config.auth,
+      method: 'GET',
+      operation: 'getDBInfo',
+      request: config.request,
+      url
+    })
+
+    if (!isSuccessStatusCode('database', resp.statusCode)) {
+      logger.error(`Non-success status code received: ${resp.statusCode}`)
+      throw createResponseError({
+        body: resp.body,
+        defaultMessage: 'Failed to fetch database info',
+        operation: 'getDBInfo',
+        statusCode: resp.statusCode
       })
-    )
+    }
   } catch (err) {
     logger.error('Error during get operation:', err)
-    RetryableError.handleNetworkError(err)
+    RetryableError.handleNetworkError(err, 'getDBInfo')
   }
 
   if (!resp) {
     logger.error('No response received from get request')
-    throw new RetryableError('no response', 503)
-  }
-
-  const result = resp.body
-  if (RetryableError.isRetryableStatusCode(resp.statusCode)) {
-    logger.warn(`Retryable status code received: ${resp.statusCode}`)
-    throw new RetryableError(result.reason ?? 'retryable error', resp.statusCode)
+    throw new RetryableError('Failed to fetch database info', 503, { operation: 'getDBInfo' })
   }
 
-  return CouchDBInfo.parse(result)
+  return CouchDBInfo.parse(resp.body)
 }