sanity-plugin-mux-input 3.0.5 → 4.0.1

package/src/actions/upload.ts

@@ -1,308 +0,0 @@
-import {uuid as generateUuid} from '@sanity/uuid'
-import {concat, defer, from, type Observable, of, throwError} from 'rxjs'
-import {catchError, mergeMap, mergeMapTo, switchMap} from 'rxjs/operators'
-import type {SanityClient} from 'sanity'
-
-import {createUpChunkObservable} from '../clients/upChunkObservable'
-import {formatDriveShareLink} from '../util/formatDriveShareLink'
-import {PLUGIN_VERSION_QUERY} from '../util/pluginVersion'
-import {roundPxString} from '../util/roundPxString'
-import type {MuxAsset, MuxNewAssetSettings, WatermarkConfig} from '../util/types'
-import {getAsset} from './assets'
-import {testSecretsObservable} from './secrets'
-
-function sanitizeOverlaySettingsInPlace(settings: MuxNewAssetSettings) {
-  const inputs = settings.input
-  if (!inputs) return
-  for (const input of inputs) {
-    const overlay = (input as {overlay_settings?: Record<string, unknown>}).overlay_settings
-    if (!overlay) continue
-
-    const hm = roundPxString(overlay['horizontal_margin'])
-    const vm = roundPxString(overlay['vertical_margin'])
-    const w = roundPxString(overlay['width'])
-
-    if (hm) overlay['horizontal_margin'] = hm
-    if (vm) overlay['vertical_margin'] = vm
-    if (w) overlay['width'] = w
-  }
-}
-
-function sanitizePxStringsInJson(json: string): string {
-  return json.replace(/"(-?\d+(?:\.\d+)?)px"/g, (_match, num) => {
-    const n = Number(num)
-    if (!Number.isFinite(n)) return _match
-    let rounded = Math.round(n)
-    if (rounded === 0) rounded = n < 0 ? -1 : 1
-    return `"${rounded}px"`
-  })
-}
-
-function cancelUpload(client: SanityClient, uuid: string) {
-  return client.observable.request({
-    url: `/addons/mux/uploads/${client.config().dataset}/${uuid}`,
-    withCredentials: true,
-    method: 'DELETE',
-    query: PLUGIN_VERSION_QUERY,
-  })
-}
-
-export function uploadUrl({
-  url,
-  settings,
-  client,
-}: {
-  url: string
-  settings: MuxNewAssetSettings
-  client: SanityClient
-  watermark?: WatermarkConfig
-}) {
-  return testUrl(url).pipe(
-    switchMap((validUrl) => {
-      return concat(
-        of({type: 'url' as const, url: validUrl}),
-        testSecretsObservable(client).pipe(
-          switchMap((json) => {
-            if (!json || !json.status) {
-              return throwError(new Error('Invalid credentials'))
-            }
-            const uuid = generateUuid()
-            const muxBody = settings
-            if (!muxBody.input) muxBody.input = [{type: 'video'}]
-            muxBody.input[0]!.url = validUrl
-            sanitizeOverlaySettingsInPlace(muxBody)
-
-            const query: Record<string, string> = {
-              muxBody: sanitizePxStringsInJson(JSON.stringify(muxBody)),
-            }
-            const filename = validUrl.split('/').slice(-1)[0]
-            if (filename) {
-              query['filename'] = filename
-            }
-
-            const dataset = client.config().dataset
-            return defer(() =>
-              client.observable.request({
-                url: `/addons/mux/assets/${dataset}`,
-                withCredentials: true,
-                method: 'POST',
-                headers: {
-                  'MUX-Proxy-UUID': uuid,
-                  'Content-Type': 'application/json',
-                },
-                query: {...query, ...PLUGIN_VERSION_QUERY},
-              }),
-            ).pipe(
-              mergeMap((result) => {
-                const asset =
-                  (result && result.results && result.results[0] && result.results[0].document) ||
-                  null
-
-                if (!asset) {
-                  return throwError(new Error('No asset document returned'))
-                }
-                return of({type: 'success' as const, id: uuid, asset})
-              }),
-            )
-          }),
-        ),
-      )
-    }),
-  )
-}
-
-export function uploadFile({
-  settings,
-  client,
-  file,
-  watermark,
-}: {
-  settings: MuxNewAssetSettings
-  client: SanityClient
-  file: File
-  watermark?: WatermarkConfig
-}) {
-  return testFile(file).pipe(
-    switchMap((fileOptions) => {
-      return concat(
-        of({type: 'file' as const, file: fileOptions}),
-        testSecretsObservable(client).pipe(
-          switchMap((json) => {
-            if (!json || !json.status) {
-              return throwError(() => new Error('Invalid credentials'))
-            }
-            const uuid = generateUuid()
-            const body = settings
-            sanitizeOverlaySettingsInPlace(body)
-
-            return concat(
-              of({type: 'uuid' as const, uuid}),
-              defer(() =>
-                client.observable.request<{
-                  sanityAssetId: string
-                  upload: {
-                    cors_origin: string
-                    id: string
-                    new_asset_settings: MuxNewAssetSettings
-                    status: 'waiting'
-                    timeout: number
-                    url: string
-                  }
-                }>({
-                  url: `/addons/mux/uploads/${client.config().dataset}`,
-                  withCredentials: true,
-                  method: 'POST',
-                  headers: {
-                    'MUX-Proxy-UUID': uuid,
-                    'Content-Type': 'application/json',
-                  },
-                  body,
-                  query: PLUGIN_VERSION_QUERY,
-                }),
-              ).pipe(
-                mergeMap((result) => {
-                  return createUpChunkObservable(uuid, result.upload.url, file).pipe(
-                    // @TODO type the observable events
-                    mergeMap((event) => {
-                      if (event.type !== 'success') {
-                        return of(event)
-                      }
-                      return from(updateAssetDocumentFromUpload(client, uuid, watermark)).pipe(
-                        mergeMap((doc) => of({...event, asset: doc})),
-                      )
-                    }),
-                    catchError((err) => {
-                      // Delete asset document
-                      return cancelUpload(client, uuid).pipe(mergeMapTo(throwError(err)))
-                    }),
-                  )
-                }),
-              ),
-            )
-          }),
-        ),
-      )
-    }),
-  )
-}
-
-type UploadResponse = {
-  data: {
-    asset_id: string
-    cors_origin: string
-    id: string
-    new_asset_settings: {
-      static_renditions?: {resolution: string}[]
-      passthrough: string
-      playback_policies: ['public' | 'signed' | 'drm']
-    }
-    status: string
-    timeout: number
-  }
-}
-function getUpload(client: SanityClient, assetId: string) {
-  const {dataset} = client.config()
-  return client.request<UploadResponse>({
-    url: `/addons/mux/uploads/${dataset}/${assetId}`,
-    withCredentials: true,
-    method: 'GET',
-    query: PLUGIN_VERSION_QUERY,
-  })
-}
-
-function pollUpload(client: SanityClient, uuid: string): Promise<UploadResponse> {
-  const maxTries = 10
-  let pollInterval: number
-  let tries = 0
-  let assetId: string
-  let upload: UploadResponse
-  return new Promise((resolve, reject) => {
-    pollInterval = (setInterval as typeof window.setInterval)(async () => {
-      try {
-        upload = await getUpload(client, uuid)
-      } catch (err) {
-        reject(err)
-        return
-      }
-      assetId = upload && upload.data && upload.data.asset_id
-      if (assetId) {
-        clearInterval(pollInterval)
-        resolve(upload)
-      }
-      if (tries > maxTries) {
-        clearInterval(pollInterval)
-        reject(new Error('Upload did not finish'))
-      }
-      tries++
-    }, 2000)
-  })
-}
-
-async function updateAssetDocumentFromUpload(
-  client: SanityClient,
-  uuid: string,
-  _watermark?: WatermarkConfig,
-) {
-  let upload: UploadResponse
-  let asset: {data: MuxAsset}
-  try {
-    upload = await pollUpload(client, uuid)
-  } catch (err) {
-    return Promise.reject(err)
-  }
-  try {
-    asset = await getAsset(client, upload.data.asset_id)
-  } catch (err) {
-    return Promise.reject(err)
-  }
-
-  const doc = {
-    _id: uuid,
-    _type: 'mux.videoAsset',
-    status: asset.data.status,
-    data: asset.data,
-    assetId: asset.data.id,
-    playbackId: asset.data.playback_ids[0]?.id,
-    uploadId: upload.data.id,
-  }
-  return client.createOrReplace(doc).then(() => {
-    return doc
-  })
-}
-
-function testFile(file: File) {
-  if (typeof window !== 'undefined' && file instanceof window.File) {
-    const fileOptions = optionsFromFile({}, file)
-    return of(fileOptions)
-  }
-  return throwError(new Error('Invalid file'))
-}
-
-function testUrl(url: string): Observable<string> {
-  const error = new Error('Invalid URL')
-  if (typeof url !== 'string') {
-    return throwError(error)
-  }
-  let formattedUrl = url.trim()
-  formattedUrl = formatDriveShareLink(formattedUrl)
-  let parsed
-  try {
-    parsed = new URL(formattedUrl)
-  } catch {
-    return throwError(error)
-  }
-  if (parsed && !parsed.protocol.match(/http:|https:/)) {
-    return throwError(error)
-  }
-  return of(formattedUrl)
-}
-
-function optionsFromFile(opts: {preserveFilename?: boolean}, file: File) {
-  if (typeof window === 'undefined' || !(file instanceof window.File)) {
-    return undefined
-  }
-  return {
-    name: opts.preserveFilename === false ? undefined : file.name,
-    type: file.type,
-  }
-}

package/src/clients/upChunkObservable.ts

@@ -1,54 +0,0 @@
-import {UpChunk} from '@mux/upchunk'
-import {Observable} from 'rxjs'
-
-export function createUpChunkObservable(uuid: string, uploadUrl: string, source: File) {
-  return new Observable<
-    | {type: 'pause' | 'resume'; id: string}
-    | {type: 'success'; id: string}
-    | {type: 'progress'; percent: number}
-  >((subscriber) => {
-    const upchunk = UpChunk.createUpload({
-      endpoint: uploadUrl,
-      file: source,
-      dynamicChunkSize: true, // changes the chunk size based on network speeds
-    })
-
-    const successHandler = () => {
-      subscriber.next({
-        type: 'success',
-        id: uuid,
-      })
-      subscriber.complete()
-    }
-
-    const errorHandler = (data: CustomEvent) => subscriber.error(new Error(data.detail.message))
-
-    const progressHandler = (data: CustomEvent) => {
-      return subscriber.next({type: 'progress', percent: data.detail})
-    }
-
-    const offlineHandler = () => {
-      upchunk.pause()
-      subscriber.next({
-        type: 'pause',
-        id: uuid,
-      })
-    }
-
-    const onlineHandler = () => {
-      upchunk.resume()
-      subscriber.next({
-        type: 'resume',
-        id: uuid,
-      })
-    }
-
-    upchunk.on('success', successHandler)
-    upchunk.on('error', errorHandler)
-    upchunk.on('progress', progressHandler)
-    upchunk.on('offline', offlineHandler)
-    upchunk.on('online', onlineHandler)
-
-    return () => upchunk.abort()
-  })
-}