@sanity/export 5.0.1 → 6.0.1

package/src/util/friendlyError.ts

@@ -0,0 +1,75 @@
+interface ErrorWithResponse {
+  response: {
+    body: NodeJS.ReadableStream
+    headers: Record<string, string>
+    statusCode?: number
+  }
+}
+
+interface ErrorBody {
+  error?: string
+  message?: string
+}
+
+function isRecord(thing: unknown): thing is Record<string, unknown> {
+  return typeof thing === 'object' && thing !== null && !Array.isArray(thing)
+}
+
+function isErrorWithResponse(err: unknown): err is ErrorWithResponse {
+  if (!isRecord(err)) {
+    return false
+  }
+
+  if (!('response' in err) || !isRecord(err.response)) {
+    return false
+  }
+
+  const response = err.response
+  return (
+    'body' in response &&
+    isRecord(response.body) &&
+    'pipe' in response.body &&
+    'headers' in response &&
+    isRecord(response.headers)
+  )
+}
+
+async function readBody(req: NodeJS.ReadableStream): Promise<Buffer> {
+  const chunks: Buffer[] = []
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk as Uint8Array))
+  }
+  return Buffer.concat(chunks)
+}
+
+async function readBodyJson(req: NodeJS.ReadableStream): Promise<unknown> {
+  return JSON.parse((await readBody(req)).toString('utf8'))
+}
+
+export async function tryThrowFriendlyError(err: unknown): Promise<null> {
+  if (!isErrorWithResponse(err)) {
+    return null
+  }
+
+  const contentType = err.response.headers['content-type']
+  if (typeof contentType !== 'string' || !contentType.includes('application/json')) {
+    return null
+  }
+
+  const body = await readBodyJson(err.response.body)
+
+  if (!isRecord(body)) {
+    return null
+  }
+
+  const typedBody = body as ErrorBody
+  const status =
+    typeof err.response.statusCode === 'number' ? `HTTP ${err.response.statusCode}` : undefined
+  const error = typeof typedBody.error === 'string' ? typedBody.error : undefined
+  const message = typeof typedBody.message === 'string' ? typedBody.message : undefined
+  if (!error && !message) {
+    return null
+  }
+
+  throw new Error(['Export', status, error, message].filter(Boolean).join(': '))
+}

package/src/util/{streamHelpers.js → streamHelpers.ts}

@@ -1,63 +1,80 @@
-import {Transform} from 'node:stream'
+import {Transform, type TransformCallback, type Writable} from 'node:stream'
 
-export function through(transformFn) {
+type TransformFunction = (
+  chunk: Buffer,
+  encoding: BufferEncoding,
+  callback: TransformCallback,
+) => void
+
+type TransformObjFunction<T, R> = (
+  chunk: T,
+  encoding: BufferEncoding,
+  callback: TransformCallback,
+) => R
+
+export function through(transformFn: TransformFunction): Transform {
   return new Transform({
-    transform(chunk, encoding, callback) {
+    transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback) {
       transformFn(chunk, encoding, callback)
     },
   })
 }
 
-export function throughObj(transformFn) {
+export function throughObj<T = unknown, R = void>(
+  transformFn: TransformObjFunction<T, R>,
+): Transform {
   return new Transform({
     objectMode: true,
-    transform(chunk, encoding, callback) {
+    transform(chunk: T, encoding: BufferEncoding, callback: TransformCallback) {
       transformFn(chunk, encoding, callback)
     },
   })
 }
 
-export function isWritableStream(val) {
+export function isWritableStream(val: unknown): val is Writable {
   return (
     val !== null &&
     typeof val === 'object' &&
+    'pipe' in val &&
     typeof val.pipe === 'function' &&
+    '_write' in val &&
     typeof val._write === 'function' &&
+    '_writableState' in val &&
     typeof val._writableState === 'object'
   )
 }
 
-export function concat(onData) {
-  const chunks = []
+export function concat(onData: (chunks: unknown[]) => void): Transform {
+  const chunks: unknown[] = []
   return new Transform({
     objectMode: true,
-    transform(chunk, encoding, callback) {
+    transform(chunk: unknown, _encoding: BufferEncoding, callback: TransformCallback) {
       chunks.push(chunk)
       callback()
     },
-    flush(callback) {
+    flush(callback: TransformCallback) {
       try {
         onData(chunks)
         callback()
       } catch (err) {
-        callback(err)
+        callback(err as Error)
       }
     },
   })
 }
 
-export const split = (transformFn) => {
+export function split(transformFn?: (line: string) => unknown): Transform {
   let buffer = ''
   const splitRegex = /\r?\n/
 
   return new Transform({
-    objectMode: !!transformFn,
-    transform(chunk, encoding, callback) {
+    objectMode: Boolean(transformFn),
+    transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback) {
       buffer += chunk.toString()
       const lines = buffer.split(splitRegex)
 
       // Keep the last line in buffer as it might be incomplete
-      buffer = lines.pop() || ''
+      buffer = lines.pop() ?? ''
 
       for (const line of lines) {
         if (line.length === 0) continue
@@ -69,7 +86,7 @@ export const split = (transformFn) => {
               this.push(result)
             }
           } catch (err) {
-            callback(err)
+            callback(err as Error)
             return
           }
         } else {
@@ -78,7 +95,7 @@ export const split = (transformFn) => {
       }
       callback()
     },
-    flush(callback) {
+    flush(callback: TransformCallback) {
       if (buffer.length === 0) {
         callback()
         return
@@ -96,7 +113,7 @@ export const split = (transformFn) => {
         }
         callback()
       } catch (err) {
-        callback(err)
+        callback(err as Error)
       }
     },
   })

package/src/debug.js

@@ -1,3 +0,0 @@
-import debugIt from 'debug'
-
-export const debug = debugIt('sanity:export')

package/src/filterDocumentTypes.js

@@ -1,18 +0,0 @@
-import {throughObj} from './util/streamHelpers.js'
-
-export function filterDocumentTypes(allowedTypes) {
-  if (!allowedTypes || allowedTypes.length === 0) {
-    // Pass-through
-    return throughObj((doc, enc, callback) => callback(null, doc))
-  }
-
-  return throughObj(function docTypesFilter(doc, enc, callback) {
-    const type = doc && doc._type
-    if (allowedTypes.includes(type)) {
-      callback(null, doc)
-      return
-    }
-
-    callback()
-  })
-}

package/src/filterDocuments.js

@@ -1,33 +0,0 @@
-import {debug} from './debug.js'
-import {throughObj} from './util/streamHelpers.js'
-
-const isDraftOrVersion = (doc) =>
-  doc && doc._id && (doc._id.indexOf('drafts.') === 0 || doc._id.indexOf('versions.') === 0)
-
-const isSystemDocument = (doc) => doc && doc._id && doc._id.indexOf('_.') === 0
-const isReleaseDocument = (doc) => doc && doc._id && doc._id.indexOf('_.releases.') === 0
-const isCursor = (doc) => doc && !doc._id && doc.nextCursor !== undefined
-
-export function filterDocuments(drafts) {
-  return throughObj(function filterDocs(doc, enc, callback) {
-    if (isCursor(doc)) {
-      debug('%o is a cursor, skipping', doc)
-      return callback()
-    }
-
-    if (!drafts && isDraftOrVersion(doc)) {
-      debug('%s is a draft or version, skipping', doc && doc._id)
-      return callback()
-    }
-
-    if (isSystemDocument(doc)) {
-      if (drafts && isReleaseDocument(doc)) {
-        return callback(null, doc)
-      }
-      debug('%s is a system document, skipping', doc && doc._id)
-      return callback()
-    }
-
-    return callback(null, doc)
-  })
-}

package/src/rejectOnApiError.js

@@ -1,31 +0,0 @@
-import {throughObj} from './util/streamHelpers.js'
-
-export function rejectOnApiError() {
-  return throughObj((doc, enc, callback) => {
-    // check if the document passed contains a document attribtue first, and return early.
-    if (doc._id) {
-      callback(null, doc)
-      return
-    }
-
-    if (doc.error) {
-      // if we got a statusCode we can decorate the error with it
-      if (doc.statusCode) {
-        callback(
-          new Error(
-            ['Export', `HTTP ${doc.statusCode}`, doc.error, doc.message]
-              .filter((part) => typeof part === 'string')
-              .join(': '),
-          ),
-        )
-        return
-      }
-
-      // no statusCode, just serialize and return the error
-      callback(new Error(doc.error.description || doc.error.message || JSON.stringify(doc)))
-      return
-    }
-
-    callback(null, doc)
-  })
-}

package/src/requestStream.js

@@ -1,64 +0,0 @@
-import {getIt} from 'get-it'
-import {keepAlive, promise} from 'get-it/middleware'
-
-import {
-  DEFAULT_RETRY_DELAY,
-  DOCUMENT_STREAM_MAX_RETRIES,
-  REQUEST_READ_TIMEOUT,
-} from './constants.js'
-import {debug} from './debug.js'
-import {delay} from './util/delay.js'
-import {extractFirstError} from './util/extractFirstError.js'
-import {tryThrowFriendlyError} from './util/friendlyError.js'
-
-const request = getIt([keepAlive(), promise({onlyBody: true})])
-
-const CONNECTION_TIMEOUT = 15 * 1000 // 15 seconds
-
-/* eslint-disable no-await-in-loop, max-depth */
-export async function requestStream(options) {
-  const maxRetries =
-    typeof options.maxRetries === 'number' ? options.maxRetries : DOCUMENT_STREAM_MAX_RETRIES
-
-  const readTimeout =
-    typeof options.readTimeout === 'number' ? options.readTimeout : REQUEST_READ_TIMEOUT
-
-  const retryDelayMs =
-    typeof options.retryDelayMs === 'number' ? options.retryDelayMs : DEFAULT_RETRY_DELAY
-
-  let error
-
-  let i = 0
-  do {
-    i++
-
-    try {
-      return await request({
-        ...options,
-        stream: true,
-        maxRedirects: 0,
-        timeout: {connect: CONNECTION_TIMEOUT, socket: readTimeout},
-      })
-    } catch (err) {
-      error = extractFirstError(err) || err
-
-      if (maxRetries === 0) {
-        throw error
-      }
-
-      if (err.response && err.response.statusCode && err.response.statusCode < 500) {
-        break
-      }
-
-      if (i < maxRetries) {
-        debug('Error, retrying after %d ms: %s', retryDelayMs, error.message)
-        await delay(retryDelayMs)
-      }
-    }
-  } while (i < maxRetries)
-
-  await tryThrowFriendlyError(error)
-
-  error.message = `Export: Failed to fetch ${options.url}: ${error.message}`
-  throw error
-}

package/src/stringifyStream.js

@@ -1,5 +0,0 @@
-import {throughObj} from './util/streamHelpers.js'
-
-export function stringifyStream() {
-  return throughObj((doc, enc, callback) => callback(null, `${JSON.stringify(doc)}\n`))
-}

package/src/util/extractFirstError.js

@@ -1,14 +0,0 @@
-export function extractFirstError(err) {
-  if (
-    // eslint-disable-next-line no-undef
-    ((typeof AggregateError !== 'undefined' && err instanceof AggregateError) ||
-      ('name' in err && err.name === 'AggregateError')) &&
-    Array.isArray(err.errors) &&
-    err.errors.length > 0 &&
-    'message' in err.errors[0]
-  ) {
-    return err.errors[0]
-  }
-
-  return err
-}

package/src/util/friendlyError.js

@@ -1,58 +0,0 @@
-export async function tryThrowFriendlyError(err) {
-  if (!isRecord(err)) {
-    return null
-  }
-
-  if (!('response' in err) || !isRecord(err.response)) {
-    return null
-  }
-
-  if (
-    !('body' in err.response) ||
-    !('pipe' in err.response.body) ||
-    !('headers' in err.response) ||
-    !isRecord(err.response.headers)
-  ) {
-    return null
-  }
-
-  if (
-    typeof err.response.headers['content-type'] !== 'string' ||
-    !err.response.headers['content-type'].includes('application/json')
-  ) {
-    return null
-  }
-
-  const body = await readBodyJson(err.response.body)
-
-  if (!isRecord(body)) {
-    return null
-  }
-
-  // Look for Sanity API(ish) standard error shape
-  const status =
-    typeof err.response.statusCode === 'number' ? `HTTP ${err.response.statusCode}` : undefined
-  const error = typeof body.error === 'string' ? body.error : undefined
-  const message = typeof body.message === 'string' ? body.message : undefined
-  if (!error && !message) {
-    return null
-  }
-
-  throw new Error(['Export', status, error, message].filter(Boolean).join(': '))
-}
-
-function isRecord(thing) {
-  return typeof thing === 'object' && thing !== null && !Array.isArray(thing)
-}
-
-async function readBody(req) {
-  const chunks = []
-  for await (const chunk of req) {
-    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk)
-  }
-  return Buffer.concat(chunks)
-}
-
-async function readBodyJson(req) {
-  return JSON.parse((await readBody(req)).toString('utf8'))
-}

package/src/validateOptions.js

@@ -1,113 +0,0 @@
-import {
-  ASSET_DOWNLOAD_MAX_RETRIES,
-  DOCUMENT_STREAM_MAX_RETRIES,
-  MODE_CURSOR,
-  MODE_STREAM,
-  REQUEST_READ_TIMEOUT,
-} from './constants.js'
-
-const clientMethods = ['getUrl', 'config']
-const booleanFlags = ['assets', 'raw', 'compress', 'drafts']
-const numberFlags = ['maxAssetRetries', 'maxRetries', 'assetConcurrency', 'readTimeout']
-const exportDefaults = {
-  compress: true,
-  drafts: true,
-  assets: true,
-  assetsMap: true,
-  raw: false,
-  mode: MODE_STREAM,
-  maxRetries: DOCUMENT_STREAM_MAX_RETRIES,
-  maxAssetRetries: ASSET_DOWNLOAD_MAX_RETRIES,
-  readTimeout: REQUEST_READ_TIMEOUT,
-  filterDocument: () => true,
-  transformDocument: (doc) => doc,
-}
-
-export function validateOptions(opts) {
-  const options = {...exportDefaults, ...opts}
-
-  const resources = [options.dataset, options.mediaLibraryId].filter(
-    (resource) => typeof resource === 'string' && resource.length !== 0,
-  )
-
-  if (resources.length === 0) {
-    throw new Error(
-      'either `options.dataset` or `options.mediaLibraryId` must be specified, got neither',
-    )
-  }
-
-  if (resources.length === 2) {
-    throw new Error(
-      'either `options.dataset` or `options.mediaLibraryId` must be specified, got both',
-    )
-  }
-
-  if (
-    typeof options.mode !== 'string' ||
-    (options.mode !== MODE_STREAM && options.mode !== MODE_CURSOR)
-  ) {
-    throw new Error(
-      `options.mode must be either "${MODE_STREAM}" or "${MODE_CURSOR}", got "${options.mode}"`,
-    )
-  }
-
-  if (options.onProgress && typeof options.onProgress !== 'function') {
-    throw new Error(`options.onProgress must be a function`)
-  }
-
-  if (!options.client) {
-    throw new Error('`options.client` must be set to an instance of @sanity/client')
-  }
-
-  const missing = clientMethods.find((key) => typeof options.client[key] !== 'function')
-  if (missing) {
-    throw new Error(
-      `\`options.client\` is not a valid @sanity/client instance - no "${missing}" method found`,
-    )
-  }
-
-  const clientConfig = options.client.config()
-  if (!clientConfig.token) {
-    throw new Error('Client is not instantiated with a `token`')
-  }
-
-  booleanFlags.forEach((flag) => {
-    if (typeof options[flag] !== 'boolean') {
-      throw new Error(`Flag ${flag} must be a boolean (true/false)`)
-    }
-  })
-
-  numberFlags.forEach((flag) => {
-    if (typeof options[flag] !== 'undefined' && typeof options[flag] !== 'number') {
-      throw new Error(`Flag ${flag} must be a number if specified`)
-    }
-  })
-
-  if (!options.outputPath) {
-    throw new Error('outputPath must be specified (- for stdout)')
-  }
-
-  if (options.assetConcurrency && (options.assetConcurrency < 1 || options.assetConcurrency > 24)) {
-    throw new Error('`assetConcurrency` must be between 1 and 24')
-  }
-
-  if (
-    typeof options.filterDocument !== 'undefined' &&
-    typeof options.filterDocument !== 'function'
-  ) {
-    throw new Error('`filterDocument` must be a function')
-  }
-
-  if (
-    typeof options.transformDocument !== 'undefined' &&
-    typeof options.transformDocument !== 'function'
-  ) {
-    throw new Error('`transformDocument` must be a function')
-  }
-
-  if (typeof assetsMap !== 'undefined' && typeof assetsMap !== 'boolean') {
-    throw new Error('`assetsMap` must be a boolean')
-  }
-
-  return options
-}