@transloadit/node 4.1.9 → 4.3.0

package/src/cli/helpers.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import fsp from 'node:fs/promises'
 import type { Readable } from 'node:stream'
 import { isAPIError } from './types.ts'
 
@@ -24,6 +25,55 @@ export async function streamToBuffer(stream: Readable): Promise<Buffer> {
   return Buffer.concat(chunks)
 }
 
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) return ''
+
+  process.stdin.setEncoding('utf8')
+  let data = ''
+
+  for await (const chunk of process.stdin) {
+    data += chunk
+  }
+
+  return data
+}
+
+export interface CliInputResult {
+  content: string | null
+  isStdin: boolean
+  path?: string
+}
+
+export interface ReadCliInputOptions {
+  inputPath?: string
+  providedInput?: string
+  allowStdinWhenNoPath?: boolean
+}
+
+export async function readCliInput(options: ReadCliInputOptions): Promise<CliInputResult> {
+  const { inputPath, providedInput, allowStdinWhenNoPath = false } = options
+  const canUseProvided = providedInput != null && (inputPath == null || inputPath === '-')
+
+  if (canUseProvided) {
+    return { content: providedInput, isStdin: inputPath === '-' || inputPath == null }
+  }
+
+  if (inputPath === '-') {
+    return { content: await readStdin(), isStdin: true }
+  }
+
+  if (inputPath != null) {
+    const content = await fsp.readFile(inputPath, 'utf8')
+    return { content, isStdin: false, path: inputPath }
+  }
+
+  if (allowStdinWhenNoPath && !process.stdin.isTTY) {
+    return { content: await readStdin(), isStdin: true }
+  }
+
+  return { content: null, isStdin: false }
+}
+
 export function formatAPIError(err: unknown): string {
   if (isAPIError(err)) {
     return `${err.error}: ${err.message}`

package/src/lintAssemblyInput.ts

@@ -0,0 +1,89 @@
+import { getIndentation } from './alphalib/stepParsing.ts'
+import { mergeTemplateContent } from './alphalib/templateMerge.ts'
+import type { AssemblyInstructionsInput, StepsInput } from './alphalib/types/template.ts'
+import type { ResponseTemplateContent, TemplateContent } from './apiTypes.ts'
+
+const DEFAULT_INDENT = '  '
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+export interface BuildLintInputResult {
+  lintContent: string
+  wasStepsOnly: boolean
+  indent: string
+}
+
+export const unwrapStepsOnly = (content: string, indent: string): string => {
+  try {
+    const parsed = JSON.parse(content)
+    if (isRecord(parsed) && 'steps' in parsed) {
+      return JSON.stringify((parsed as { steps?: unknown }).steps ?? {}, null, indent)
+    }
+  } catch (_err) {
+    return content
+  }
+  return content
+}
+
+export const buildLintInput = (
+  assemblyInstructions?: AssemblyInstructionsInput | StepsInput | string,
+  template?: TemplateContent | ResponseTemplateContent,
+): BuildLintInputResult => {
+  let inputString: string | undefined
+  let parsedInput: unknown | undefined
+  let parseFailed = false
+  let indent = DEFAULT_INDENT
+
+  if (typeof assemblyInstructions === 'string') {
+    inputString = assemblyInstructions
+    indent = getIndentation(assemblyInstructions)
+    try {
+      parsedInput = JSON.parse(assemblyInstructions)
+    } catch (_err) {
+      parseFailed = true
+    }
+  } else if (assemblyInstructions != null) {
+    parsedInput = assemblyInstructions
+  }
+
+  let wasStepsOnly = false
+  let instructions: AssemblyInstructionsInput | undefined
+
+  if (parsedInput !== undefined) {
+    if (isRecord(parsedInput)) {
+      if ('steps' in parsedInput) {
+        instructions = parsedInput as AssemblyInstructionsInput
+      } else {
+        instructions = { steps: parsedInput as StepsInput }
+        wasStepsOnly = true
+      }
+    } else {
+      instructions = { steps: parsedInput as StepsInput }
+      wasStepsOnly = true
+    }
+  }
+
+  const shouldMergeTemplate = template != null && !parseFailed
+  if (shouldMergeTemplate) {
+    instructions = mergeTemplateContent(template, instructions)
+  }
+
+  let lintContent = ''
+  if (instructions != null) {
+    if (
+      typeof assemblyInstructions === 'string' &&
+      !wasStepsOnly &&
+      !parseFailed &&
+      !shouldMergeTemplate
+    ) {
+      lintContent = assemblyInstructions
+    } else {
+      lintContent = JSON.stringify(instructions, null, indent)
+    }
+  } else if (inputString != null) {
+    lintContent = inputString
+  }
+
+  return { lintContent, wasStepsOnly, indent }
+}

package/src/lintAssemblyInstructions.ts

@@ -0,0 +1,72 @@
+import type { HydratedLintIssue } from './alphalib/assembly-linter.lang.en.ts'
+import { hydrateLintIssues } from './alphalib/assembly-linter.lang.en.ts'
+import { applyFix, parseAndLint } from './alphalib/assembly-linter.ts'
+import type { AssemblyInstructionsInput, StepsInput } from './alphalib/types/template.ts'
+import type { ResponseTemplateContent, TemplateContent } from './apiTypes.ts'
+import { buildLintInput, unwrapStepsOnly } from './lintAssemblyInput.ts'
+
+export type LintFatalLevel = 'error' | 'warning'
+
+export interface LintAssemblyInstructionsInput {
+  /**
+   * Assembly Instructions as a JSON string, a full instructions object, or a steps-only object.
+   */
+  assemblyInstructions?: AssemblyInstructionsInput | StepsInput | string
+  /**
+   * Optional template content to merge with the provided instructions.
+   */
+  template?: TemplateContent | ResponseTemplateContent
+  /**
+   * Treat issues at this level or above as fatal. Defaults to "error".
+   */
+  fatal?: LintFatalLevel
+  /**
+   * Apply auto-fixes where possible and return the fixed JSON.
+   */
+  fix?: boolean
+}
+
+export interface LintAssemblyInstructionsResult {
+  success: boolean
+  issues: HydratedLintIssue[]
+  fixedInstructions?: string
+}
+
+export async function lintAssemblyInstructions(
+  options: LintAssemblyInstructionsInput,
+): Promise<LintAssemblyInstructionsResult> {
+  const { assemblyInstructions, template, fix = false, fatal = 'error' } = options
+
+  if (assemblyInstructions == null && template == null) {
+    throw new Error('Provide assemblyInstructions or template content to lint.')
+  }
+
+  const { lintContent, wasStepsOnly, indent } = buildLintInput(assemblyInstructions, template)
+
+  let issues = await parseAndLint(lintContent)
+  let fixedContent = lintContent
+
+  if (fix) {
+    for (const issue of issues) {
+      if (!issue.fixId) continue
+      // applyFix validates fixData against the fix schema for the fixId.
+      fixedContent = applyFix(fixedContent, issue.fixId, issue.fixData as never)
+    }
+    issues = await parseAndLint(fixedContent)
+  }
+
+  const describedIssues = hydrateLintIssues(issues)
+  const fatalTypes = fatal === 'warning' ? new Set(['warning', 'error']) : new Set(['error'])
+  const success = !describedIssues.some((issue) => fatalTypes.has(issue.type))
+
+  const result: LintAssemblyInstructionsResult = {
+    success,
+    issues: describedIssues,
+  }
+
+  if (fix) {
+    result.fixedInstructions = wasStepsOnly ? unwrapStepsOnly(fixedContent, indent) : fixedContent
+  }
+
+  return result
+}

package/src/tus.ts

@@ -22,6 +22,7 @@ interface SendTusRequestOptions {
   uploadConcurrency: number
   onProgress: (options: UploadProgress) => void
   signal?: AbortSignal
+  uploadUrls?: Record<string, string>
 }
 
 export async function sendTusRequest({
@@ -31,6 +32,7 @@ export async function sendTusRequest({
   uploadConcurrency,
   onProgress,
   signal,
+  uploadUrls,
 }: SendTusRequestOptions) {
   const streamLabels = Object.keys(streamsMap)
 
@@ -133,6 +135,7 @@ export async function sendTusRequest({
 
       const tusOptions: UploadOptions = {
         endpoint: assembly.tus_url,
+        uploadUrl: uploadUrls?.[label],
         metadata: {
           assembly_url: assembly.assembly_ssl_url,
           fieldname: label,