@transloadit/node 4.1.3

package/src/cli/commands/auth.ts

@@ -0,0 +1,354 @@
+import process from 'node:process'
+import { Command, Option } from 'clipanion'
+import type { ZodIssue } from 'zod'
+import { z } from 'zod'
+import {
+  assemblyAuthInstructionsSchema,
+  assemblyInstructionsSchema,
+} from '../../alphalib/types/template.ts'
+import type { OptionalAuthParams } from '../../apiTypes.ts'
+import { Transloadit } from '../../Transloadit.ts'
+import { getEnvCredentials } from '../helpers.ts'
+import { UnauthenticatedCommand } from './BaseCommand.ts'
+
+type UrlParamPrimitive = string | number | boolean
+type UrlParamArray = UrlParamPrimitive[]
+type NormalizedUrlParams = Record<string, UrlParamPrimitive | UrlParamArray>
+
+const smartCdnParamsSchema = z
+  .object({
+    workspace: z.string().min(1, 'workspace is required'),
+    template: z.string().min(1, 'template is required'),
+    input: z.union([z.string(), z.number(), z.boolean()]),
+    url_params: z.record(z.unknown()).optional(),
+    expire_at_ms: z.union([z.number(), z.string()]).optional(),
+  })
+  .passthrough()
+
+const cliSignatureParamsSchema = assemblyInstructionsSchema
+  .extend({ auth: assemblyAuthInstructionsSchema.partial().optional() })
+  .partial()
+  .passthrough()
+
+type CliSignatureParams = z.infer<typeof cliSignatureParamsSchema>
+
+function formatIssues(issues: ZodIssue[]): string {
+  return issues
+    .map((issue) => {
+      const path = issue.path.join('.') || '(root)'
+      return `${path}: ${issue.message}`
+    })
+    .join('; ')
+}
+
+function normalizeUrlParam(value: unknown): UrlParamPrimitive | UrlParamArray | undefined {
+  if (value == null) return undefined
+  if (Array.isArray(value)) {
+    const normalized = value.filter(
+      (item): item is UrlParamPrimitive =>
+        typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean',
+    )
+    return normalized.length > 0 ? normalized : undefined
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value
+  }
+  return undefined
+}
+
+function normalizeUrlParams(params?: Record<string, unknown>): NormalizedUrlParams | undefined {
+  if (params == null) return undefined
+  let normalized: NormalizedUrlParams | undefined
+  for (const [key, value] of Object.entries(params)) {
+    const normalizedValue = normalizeUrlParam(value)
+    if (normalizedValue === undefined) continue
+    if (normalized == null) normalized = {}
+    normalized[key] = normalizedValue
+  }
+  return normalized
+}
+
+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
+}
+
+const getCredentials = getEnvCredentials
+
+// Result type for signature operations
+type SigResult = { ok: true; output: string } | { ok: false; error: string }
+
+// Core logic for signature generation
+function generateSignature(
+  input: string,
+  credentials: { authKey: string; authSecret: string },
+  algorithm?: string,
+): SigResult {
+  const { authKey, authSecret } = credentials
+  let params: CliSignatureParams
+
+  if (input === '') {
+    params = { auth: { key: authKey } }
+  } else {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(input)
+    } catch (error) {
+      return { ok: false, error: `Failed to parse JSON from stdin: ${(error as Error).message}` }
+    }
+
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { ok: false, error: 'Invalid params provided via stdin. Expected a JSON object.' }
+    }
+
+    const parsedResult = cliSignatureParamsSchema.safeParse(parsed)
+    if (!parsedResult.success) {
+      return { ok: false, error: `Invalid params: ${formatIssues(parsedResult.error.issues)}` }
+    }
+
+    const parsedParams = parsedResult.data
+    const existingAuth = parsedParams.auth ?? {}
+
+    params = {
+      ...parsedParams,
+      auth: {
+        ...existingAuth,
+        key: authKey,
+      },
+    }
+  }
+
+  const client = new Transloadit({ authKey, authSecret })
+  try {
+    const signature = client.calcSignature(params as OptionalAuthParams, algorithm)
+    return { ok: true, output: JSON.stringify(signature) }
+  } catch (error) {
+    return { ok: false, error: `Failed to generate signature: ${(error as Error).message}` }
+  }
+}
+
+// Core logic for Smart CDN URL generation
+function generateSmartCdnUrl(
+  input: string,
+  credentials: { authKey: string; authSecret: string },
+): SigResult {
+  const { authKey, authSecret } = credentials
+
+  if (input === '') {
+    return {
+      ok: false,
+      error:
+        'Missing params provided via stdin. Expected a JSON object with workspace, template, input, and optional Smart CDN parameters.',
+    }
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(input)
+  } catch (error) {
+    return { ok: false, error: `Failed to parse JSON from stdin: ${(error as Error).message}` }
+  }
+
+  if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return { ok: false, error: 'Invalid params provided via stdin. Expected a JSON object.' }
+  }
+
+  const parsedResult = smartCdnParamsSchema.safeParse(parsed)
+  if (!parsedResult.success) {
+    return { ok: false, error: `Invalid params: ${formatIssues(parsedResult.error.issues)}` }
+  }
+
+  const { workspace, template, input: inputFieldRaw, url_params, expire_at_ms } = parsedResult.data
+  const urlParams = normalizeUrlParams(url_params)
+
+  let expiresAt: number | undefined
+  if (typeof expire_at_ms === 'string') {
+    const parsedNumber = Number.parseInt(expire_at_ms, 10)
+    if (Number.isNaN(parsedNumber)) {
+      return { ok: false, error: 'Invalid params: expire_at_ms must be a number.' }
+    }
+    expiresAt = parsedNumber
+  } else {
+    expiresAt = expire_at_ms
+  }
+
+  const inputField = typeof inputFieldRaw === 'string' ? inputFieldRaw : String(inputFieldRaw)
+
+  const client = new Transloadit({ authKey, authSecret })
+  try {
+    const signedUrl = client.getSignedSmartCDNUrl({
+      workspace,
+      template,
+      input: inputField,
+      urlParams,
+      expiresAt,
+    })
+    return { ok: true, output: signedUrl }
+  } catch (error) {
+    return { ok: false, error: `Failed to generate Smart CDN URL: ${(error as Error).message}` }
+  }
+}
+
+// Testable helper functions exported for unit tests
+export interface RunSigOptions {
+  providedInput?: string
+  algorithm?: string
+}
+
+export interface RunSmartSigOptions {
+  providedInput?: string
+}
+
+export async function runSig(options: RunSigOptions = {}): Promise<void> {
+  const credentials = getCredentials()
+  if (credentials == null) {
+    console.error(
+      'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.',
+    )
+    process.exitCode = 1
+    return
+  }
+
+  const rawInput = options.providedInput ?? (await readStdin())
+  const result = generateSignature(rawInput.trim(), credentials, options.algorithm)
+
+  if (result.ok) {
+    process.stdout.write(`${result.output}\n`)
+  } else {
+    console.error(result.error)
+    process.exitCode = 1
+  }
+}
+
+export async function runSmartSig(options: RunSmartSigOptions = {}): Promise<void> {
+  const credentials = getCredentials()
+  if (credentials == null) {
+    console.error(
+      'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.',
+    )
+    process.exitCode = 1
+    return
+  }
+
+  const rawInput = options.providedInput ?? (await readStdin())
+  const result = generateSmartCdnUrl(rawInput.trim(), credentials)
+
+  if (result.ok) {
+    process.stdout.write(`${result.output}\n`)
+  } else {
+    console.error(result.error)
+    process.exitCode = 1
+  }
+}
+
+/**
+ * Generate a signature for assembly params
+ */
+export class SignatureCommand extends UnauthenticatedCommand {
+  static override paths = [
+    ['auth', 'signature'],
+    ['auth', 'sig'],
+    ['signature'],
+    ['sig'], // BC alias
+  ]
+
+  static override usage = Command.Usage({
+    category: 'Auth',
+    description: 'Generate a signature for assembly params',
+    details: `
+      Read params JSON from stdin and output signed payload JSON.
+      If no input is provided, generates a signature with default params.
+    `,
+    examples: [
+      ['Generate signature', 'echo \'{"steps":{}}\' | transloadit signature'],
+      ['With algorithm', 'echo \'{"steps":{}}\' | transloadit signature --algorithm sha384'],
+      ['Using alias', 'echo \'{"steps":{}}\' | transloadit sig'],
+    ],
+  })
+
+  algorithm = Option.String('--algorithm,-a', {
+    description: 'Signature algorithm to use (sha1, sha256, sha384, sha512)',
+  })
+
+  protected async run(): Promise<number | undefined> {
+    const credentials = getCredentials()
+    if (credentials == null) {
+      this.output.error(
+        'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.',
+      )
+      return 1
+    }
+
+    const rawInput = await readStdin()
+    const result = generateSignature(rawInput.trim(), credentials, this.algorithm)
+
+    if (result.ok) {
+      process.stdout.write(`${result.output}\n`)
+      return undefined
+    }
+
+    this.output.error(result.error)
+    return 1
+  }
+}
+
+/**
+ * Generate a signed Smart CDN URL
+ */
+export class SmartCdnSignatureCommand extends UnauthenticatedCommand {
+  static override paths = [
+    ['auth', 'smart-cdn'],
+    ['auth', 'smart_cdn'],
+    ['smart-cdn'],
+    ['smart_sig'], // BC alias
+  ]
+
+  static override usage = Command.Usage({
+    category: 'Auth',
+    description: 'Generate a signed Smart CDN URL',
+    details: `
+      Read Smart CDN params JSON from stdin and output a signed URL.
+      Required fields: workspace, template, input
+      Optional fields: expire_at_ms, url_params
+    `,
+    examples: [
+      [
+        'Generate Smart CDN URL',
+        'echo \'{"workspace":"w","template":"t","input":"i"}\' | transloadit smart-cdn',
+      ],
+      [
+        'Using alias',
+        'echo \'{"workspace":"w","template":"t","input":"i"}\' | transloadit smart_sig',
+      ],
+    ],
+  })
+
+  protected async run(): Promise<number | undefined> {
+    const credentials = getCredentials()
+    if (credentials == null) {
+      this.output.error(
+        'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.',
+      )
+      return 1
+    }
+
+    const rawInput = await readStdin()
+    const result = generateSmartCdnUrl(rawInput.trim(), credentials)
+
+    if (result.ok) {
+      process.stdout.write(`${result.output}\n`)
+      return undefined
+    }
+
+    this.output.error(result.error)
+    return 1
+  }
+}

package/src/cli/commands/bills.ts

@@ -0,0 +1,91 @@
+import { Command, Option } from 'clipanion'
+import { z } from 'zod'
+import { tryCatch } from '../../alphalib/tryCatch.ts'
+import type { Transloadit } from '../../Transloadit.ts'
+import { formatAPIError } from '../helpers.ts'
+import type { IOutputCtl } from '../OutputCtl.ts'
+import { AuthenticatedCommand } from './BaseCommand.ts'
+
+// --- Types and business logic ---
+
+export interface BillsGetOptions {
+  months: string[]
+}
+
+const BillResponseSchema = z.object({
+  total: z.number(),
+})
+
+export async function get(
+  output: IOutputCtl,
+  client: Transloadit,
+  { months }: BillsGetOptions,
+): Promise<void> {
+  const requests = months.map((month) => client.getBill(month))
+
+  const [err, results] = await tryCatch(Promise.all(requests))
+  if (err) {
+    output.error(formatAPIError(err))
+    return
+  }
+
+  for (const result of results) {
+    const parsed = BillResponseSchema.safeParse(result)
+    if (parsed.success) {
+      output.print(`$${parsed.data.total}`, result)
+    } else {
+      output.print('Unable to parse bill response', result)
+    }
+  }
+}
+
+// --- Command class ---
+
+export class BillsGetCommand extends AuthenticatedCommand {
+  static override paths = [
+    ['bills', 'get'],
+    ['bill', 'get'],
+    ['b', 'get'],
+    ['b', 'g'],
+  ]
+
+  static override usage = Command.Usage({
+    category: 'Bills',
+    description: 'Fetch billing information',
+    details: `
+      Fetch billing information for the specified months.
+      Months should be specified in YYYY-MM format.
+      If no month is specified, returns the current month.
+    `,
+    examples: [
+      ['Get current month billing', 'transloadit bills get'],
+      ['Get specific month', 'transloadit bills get 2024-01'],
+      ['Get multiple months', 'transloadit bills get 2024-01 2024-02'],
+    ],
+  })
+
+  months = Option.Rest()
+
+  protected async run(): Promise<number | undefined> {
+    const monthList: string[] = []
+
+    for (const month of this.months) {
+      if (!/^\d{4}-\d{1,2}$/.test(month)) {
+        this.output.error(`invalid date format '${month}' (YYYY-MM)`)
+        return 1
+      }
+      monthList.push(month)
+    }
+
+    // Default to current month if none specified
+    if (monthList.length === 0) {
+      const d = new Date()
+      monthList.push(`${d.getUTCFullYear()}-${d.getUTCMonth() + 1}`)
+    }
+
+    await get(this.output, this.client, {
+      months: monthList,
+    })
+    return undefined
+  }
+}

package/src/cli/commands/index.ts

@@ -0,0 +1,65 @@
+import { Builtins, Cli } from 'clipanion'
+
+import packageJson from '../../../package.json' with { type: 'json' }
+
+import {
+  AssembliesCreateCommand,
+  AssembliesDeleteCommand,
+  AssembliesGetCommand,
+  AssembliesListCommand,
+  AssembliesReplayCommand,
+} from './assemblies.ts'
+
+import { SignatureCommand, SmartCdnSignatureCommand } from './auth.ts'
+
+import { BillsGetCommand } from './bills.ts'
+
+import { NotificationsReplayCommand } from './notifications.ts'
+
+import {
+  TemplatesCreateCommand,
+  TemplatesDeleteCommand,
+  TemplatesGetCommand,
+  TemplatesListCommand,
+  TemplatesModifyCommand,
+  TemplatesSyncCommand,
+} from './templates.ts'
+
+export function createCli(): Cli {
+  const cli = new Cli({
+    binaryLabel: 'Transloadit CLI',
+    binaryName: 'transloadit',
+    binaryVersion: packageJson.version,
+  })
+
+  // Built-in commands
+  cli.register(Builtins.HelpCommand)
+  cli.register(Builtins.VersionCommand)
+
+  // Auth commands (signature generation)
+  cli.register(SignatureCommand)
+  cli.register(SmartCdnSignatureCommand)
+
+  // Assemblies commands
+  cli.register(AssembliesCreateCommand)
+  cli.register(AssembliesListCommand)
+  cli.register(AssembliesGetCommand)
+  cli.register(AssembliesDeleteCommand)
+  cli.register(AssembliesReplayCommand)
+
+  // Templates commands
+  cli.register(TemplatesCreateCommand)
+  cli.register(TemplatesGetCommand)
+  cli.register(TemplatesModifyCommand)
+  cli.register(TemplatesDeleteCommand)
+  cli.register(TemplatesListCommand)
+  cli.register(TemplatesSyncCommand)
+
+  // Bills commands
+  cli.register(BillsGetCommand)
+
+  // Notifications commands
+  cli.register(NotificationsReplayCommand)
+
+  return cli
+}

package/src/cli/commands/notifications.ts

@@ -0,0 +1,63 @@
+import { Command, Option } from 'clipanion'
+import { tryCatch } from '../../alphalib/tryCatch.ts'
+import type { Transloadit } from '../../Transloadit.ts'
+import type { IOutputCtl } from '../OutputCtl.ts'
+import { ensureError } from '../types.ts'
+import { AuthenticatedCommand } from './BaseCommand.ts'
+
+// --- Types and business logic ---
+
+interface NotificationsReplayOptions {
+  notify_url?: string
+  assemblies: string[]
+}
+
+async function replay(
+  output: IOutputCtl,
+  client: Transloadit,
+  { notify_url, assemblies }: NotificationsReplayOptions,
+): Promise<void> {
+  const promises = assemblies.map((id) => client.replayAssemblyNotification(id, { notify_url }))
+  const [err] = await tryCatch(Promise.all(promises))
+  if (err) {
+    output.error(ensureError(err).message)
+  }
+}
+
+// --- Command class ---
+
+export class NotificationsReplayCommand extends AuthenticatedCommand {
+  static override paths = [
+    ['assembly-notifications', 'replay'],
+    ['notifications', 'replay'],
+    ['notification', 'replay'],
+    ['n', 'replay'],
+    ['n', 'r'],
+  ]
+
+  static override usage = Command.Usage({
+    category: 'Notifications',
+    description: 'Replay notifications for assemblies',
+    examples: [
+      ['Replay notifications', 'transloadit assembly-notifications replay ASSEMBLY_ID'],
+      [
+        'Replay to a new URL',
+        'transloadit assembly-notifications replay --notify-url https://example.com/notify ASSEMBLY_ID',
+      ],
+    ],
+  })
+
+  notifyUrl = Option.String('--notify-url', {
+    description: 'Specify a new URL to send the notifications to',
+  })
+
+  assemblyIds = Option.Rest({ required: 1 })
+
+  protected async run(): Promise<number | undefined> {
+    await replay(this.output, this.client, {
+      notify_url: this.notifyUrl,
+      assemblies: this.assemblyIds,
+    })
+    return undefined
+  }
+}