@transloadit/node 4.1.3

package/src/cli/template-last-modified.ts

@@ -0,0 +1,156 @@
+import type { Transloadit } from '../Transloadit.ts'
+import { ensureError } from './types.ts'
+
+interface TemplateItem {
+  id: string
+  modified: string
+}
+
+type FetchCallback<T> = (err: Error | null, result?: T) => void
+type PageFetcher<T> = (page: number, pagesize: number, cb: FetchCallback<T[]>) => void
+
+class MemoizedPagination<T> {
+  private pagesize: number
+  private fetch: PageFetcher<T>
+  private cache: (T | undefined)[]
+
+  constructor(pagesize: number, fetch: PageFetcher<T>) {
+    this.pagesize = pagesize
+    this.fetch = fetch
+    this.cache = []
+  }
+
+  get(i: number, cb: FetchCallback<T>): void {
+    const cached = this.cache[i]
+    if (cached !== undefined) {
+      process.nextTick(() => cb(null, cached))
+      return
+    }
+
+    const page = Math.floor(i / this.pagesize) + 1
+    const start = (page - 1) * this.pagesize
+
+    this.fetch(page, this.pagesize, (err, result) => {
+      if (err) {
+        cb(err)
+        return
+      }
+      if (!result) {
+        cb(new Error('No result returned from fetch'))
+        return
+      }
+      for (let j = 0; j < this.pagesize; j++) {
+        this.cache[start + j] = result[j]
+      }
+      cb(null, this.cache[i])
+    })
+  }
+}
+
+export default class ModifiedLookup {
+  private byOrdinal: MemoizedPagination<TemplateItem>
+
+  constructor(client: Transloadit, pagesize = 50) {
+    this.byOrdinal = new MemoizedPagination<TemplateItem>(pagesize, (page, pagesize, cb) => {
+      const params = {
+        sort: 'id' as const,
+        order: 'asc' as const,
+        fields: ['id', 'modified'] as ('id' | 'modified')[],
+        page,
+        pagesize,
+      }
+
+      client
+        .listTemplates(params)
+        .then((result) => {
+          const items: TemplateItem[] = new Array(pagesize)
+          // Fill with sentinel value larger than any hex ID
+          items.fill({ id: 'gggggggggggggggggggggggggggggggg', modified: '' })
+          for (let i = 0; i < result.items.length; i++) {
+            const item = result.items[i]
+            if (item) {
+              items[i] = { id: item.id, modified: item.modified }
+            }
+          }
+          cb(null, items)
+        })
+        .catch((err: unknown) => {
+          cb(ensureError(err))
+        })
+    })
+  }
+
+  private idByOrd(ord: number, cb: FetchCallback<string>): void {
+    this.byOrdinal.get(ord, (err, result) => {
+      if (err) {
+        cb(err)
+        return
+      }
+      if (!result) {
+        cb(new Error('No result found'))
+        return
+      }
+      cb(null, result.id)
+    })
+  }
+
+  byId(id: string, cb: FetchCallback<Date>): void {
+    const findUpperBound = (bound: number): void => {
+      this.idByOrd(bound, (err, idAtBound) => {
+        if (err) {
+          cb(err)
+          return
+        }
+        if (idAtBound === id) {
+          complete(bound)
+          return
+        }
+        if (idAtBound && idAtBound > id) {
+          refine(Math.floor(bound / 2), bound)
+          return
+        }
+        findUpperBound(bound * 2)
+      })
+    }
+
+    const refine = (lower: number, upper: number): void => {
+      if (lower >= upper - 1) {
+        cb(new Error(`Template ID ${id} not found in ModifiedLookup`))
+        return
+      }
+
+      const middle = Math.floor((lower + upper) / 2)
+      this.idByOrd(middle, (err, idAtMiddle) => {
+        if (err) {
+          cb(err)
+          return
+        }
+        if (idAtMiddle === id) {
+          complete(middle)
+          return
+        }
+        if (idAtMiddle && idAtMiddle < id) {
+          refine(middle, upper)
+          return
+        }
+        refine(lower, middle)
+      })
+    }
+
+    const complete = (ord: number): void => {
+      this.byOrdinal.get(ord, (err, result) => {
+        if (err) {
+          cb(err)
+          return
+        }
+        if (!result) {
+          cb(new Error('No result found'))
+          return
+        }
+        cb(null, new Date(result.modified))
+      })
+    }
+
+    findUpperBound(1)
+  }
+}

package/src/cli/types.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+import type { Steps } from '../alphalib/types/template.ts'
+import { optionalStepsSchema } from '../alphalib/types/template.ts'
+
+// Zod schemas for runtime validation
+const APIErrorSchema = z.object({
+  error: z.string(),
+  message: z.string(),
+})
+export type APIError = z.infer<typeof APIErrorSchema>
+
+const TransloaditAPIErrorSchema = z.object({
+  error: z.string().optional(),
+  message: z.string(),
+  code: z.string().optional(),
+  transloaditErrorCode: z.string().optional(),
+  response: z
+    .object({
+      body: z
+        .object({
+          error: z.string().optional(),
+        })
+        .optional(),
+      statusCode: z.number().optional(),
+    })
+    .optional(),
+})
+export type TransloaditAPIError = z.infer<typeof TransloaditAPIErrorSchema>
+
+// Template file data - explicit type to avoid TS inference limits
+export interface TemplateFileData {
+  transloadit_template_id?: string
+  steps?: Steps
+  [key: string]: unknown // passthrough
+}
+
+export const TemplateFileDataSchema: z.ZodType<TemplateFileData> = z
+  .object({
+    transloadit_template_id: z.string().optional(),
+    steps: optionalStepsSchema,
+  })
+  .passthrough() as z.ZodType<TemplateFileData>
+
+export interface TemplateFile {
+  file: string
+  data: TemplateFileData
+}
+
+// Helper to ensure error is Error type
+export function ensureError(value: unknown): Error {
+  if (value instanceof Error) {
+    return value
+  }
+  return new Error(`Non-error was thrown: ${String(value)}`)
+}
+
+// Type guard for APIError
+export function isAPIError(value: unknown): value is APIError {
+  return APIErrorSchema.safeParse(value).success
+}
+
+// Type guard for TransloaditAPIError
+export function isTransloaditAPIError(value: unknown): value is TransloaditAPIError {
+  return TransloaditAPIErrorSchema.safeParse(value).success
+}
+
+// Type guard for NodeJS.ErrnoException
+export function isErrnoException(value: unknown): value is NodeJS.ErrnoException {
+  return value instanceof Error && 'code' in value
+}

package/src/cli.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { realpathSync } from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import 'dotenv/config'
+import { createCli } from './cli/commands/index.ts'
+
+const currentFile = realpathSync(fileURLToPath(import.meta.url))
+
+function resolveInvokedPath(invoked?: string): string | null {
+  if (invoked == null) return null
+  try {
+    return realpathSync(invoked)
+  } catch {
+    return path.resolve(invoked)
+  }
+}
+
+export function shouldRunCli(invoked?: string): boolean {
+  const resolved = resolveInvokedPath(invoked)
+  if (resolved == null) return false
+  return resolved === currentFile
+}
+
+export async function main(args = process.argv.slice(2)): Promise<void> {
+  const cli = createCli()
+  const exitCode = await cli.run(args)
+  if (exitCode !== 0) {
+    process.exitCode = exitCode
+  }
+}
+
+export function runCliWhenExecuted(): void {
+  if (!shouldRunCli(process.argv[1])) return
+
+  void main().catch((error) => {
+    console.error((error as Error).message)
+    process.exitCode = 1
+  })
+}
+
+runCliWhenExecuted()

package/src/tus.ts

@@ -0,0 +1,168 @@
+import { stat } from 'node:fs/promises'
+import { basename } from 'node:path'
+import type { Readable } from 'node:stream'
+import debug from 'debug'
+import pMap from 'p-map'
+import type { OnSuccessPayload, UploadOptions } from 'tus-js-client'
+import { Upload } from 'tus-js-client'
+import type { AssemblyStatus } from './alphalib/types/assemblyStatus.ts'
+import type { UploadProgress } from './Transloadit.ts'
+
+const log = debug('transloadit')
+
+export interface Stream {
+  path?: string
+  stream: Readable
+}
+
+interface SendTusRequestOptions {
+  streamsMap: Record<string, Stream>
+  assembly: AssemblyStatus
+  requestedChunkSize: number
+  uploadConcurrency: number
+  onProgress: (options: UploadProgress) => void
+  signal?: AbortSignal
+}
+
+export async function sendTusRequest({
+  streamsMap,
+  assembly,
+  requestedChunkSize,
+  uploadConcurrency,
+  onProgress,
+  signal,
+}: SendTusRequestOptions) {
+  const streamLabels = Object.keys(streamsMap)
+
+  let totalBytes = 0
+  let lastEmittedProgress = 0
+
+  const sizes: Record<string, number> = {}
+
+  const haveUnknownLengthStreams = streamLabels.some((label) => !streamsMap[label]?.path)
+
+  // Initialize size data
+  await pMap(
+    streamLabels,
+    async (label) => {
+      // Check if aborted before each operation
+      if (signal?.aborted) throw new Error('Upload aborted')
+
+      const streamInfo = streamsMap[label]
+      if (!streamInfo) {
+        throw new Error(`Stream info not found for label: ${label}`)
+      }
+      const { path } = streamInfo
+
+      if (path) {
+        const { size } = await stat(path)
+        sizes[label] = size
+        totalBytes += size
+      }
+    },
+    { concurrency: 5, signal },
+  )
+
+  const uploadProgresses: Record<string, number> = {}
+
+  async function uploadSingleStream(label: string) {
+    uploadProgresses[label] = 0
+
+    const streamInfo = streamsMap[label]
+    if (!streamInfo) {
+      throw new Error(`Stream info not found for label: ${label}`)
+    }
+    const { stream, path } = streamInfo
+    const size = sizes[label]
+
+    let chunkSize = requestedChunkSize
+    let uploadLengthDeferred: boolean
+    const isStreamLengthKnown = !!path
+    if (!isStreamLengthKnown) {
+      // tus-js-client requires these options to be set for unknown size streams
+      // https://github.com/tus/tus-js-client/blob/master/docs/api.md#uploadlengthdeferred
+      uploadLengthDeferred = true
+      if (chunkSize === Number.POSITIVE_INFINITY) chunkSize = 50e6
+    }
+
+    const onTusProgress = (bytesUploaded: number): void => {
+      uploadProgresses[label] = bytesUploaded
+
+      // get all uploaded bytes for all files
+      let uploadedBytes = 0
+      for (const l of streamLabels) {
+        uploadedBytes += uploadProgresses[l] ?? 0
+      }
+
+      // don't send redundant progress
+      if (lastEmittedProgress < uploadedBytes) {
+        lastEmittedProgress = uploadedBytes
+        // If we have any unknown length streams, we cannot trust totalBytes
+        // totalBytes should then be undefined to mimic behavior of form uploads.
+        onProgress({
+          uploadedBytes,
+          totalBytes: haveUnknownLengthStreams ? undefined : totalBytes,
+        })
+      }
+    }
+
+    const filename = path ? basename(path) : label
+
+    await new Promise<OnSuccessPayload>((resolvePromise, rejectPromise) => {
+      if (!assembly.assembly_ssl_url) {
+        rejectPromise(new Error('assembly_ssl_url is not present in the assembly status'))
+        return
+      }
+
+      // Check if already aborted before starting
+      if (signal?.aborted) {
+        rejectPromise(new Error('Upload aborted'))
+        return
+      }
+
+      // Wrap resolve/reject to clean up abort listener
+      let abortHandler: (() => void) | undefined
+      const resolve = (payload: OnSuccessPayload) => {
+        if (abortHandler) signal?.removeEventListener('abort', abortHandler)
+        resolvePromise(payload)
+      }
+      const reject = (err: unknown) => {
+        if (abortHandler) signal?.removeEventListener('abort', abortHandler)
+        rejectPromise(err)
+      }
+
+      const tusOptions: UploadOptions = {
+        endpoint: assembly.tus_url,
+        metadata: {
+          assembly_url: assembly.assembly_ssl_url,
+          fieldname: label,
+          filename,
+        },
+        onError: reject,
+        onProgress: onTusProgress,
+        onSuccess: resolve,
+      }
+      // tus-js-client doesn't like undefined/null
+      if (size != null) tusOptions.uploadSize = size
+      if (chunkSize) tusOptions.chunkSize = chunkSize
+      if (uploadLengthDeferred) tusOptions.uploadLengthDeferred = uploadLengthDeferred
+
+      const tusUpload = new Upload(stream, tusOptions)
+
+      // Handle abort signal
+      if (signal) {
+        abortHandler = () => {
+          tusUpload.abort()
+          reject(new Error('Upload aborted'))
+        }
+        signal.addEventListener('abort', abortHandler, { once: true })
+      }
+
+      tusUpload.start()
+    })
+
+    log(label, 'upload done')
+  }
+
+  await pMap(streamLabels, uploadSingleStream, { concurrency: uploadConcurrency, signal })
+}