transloadit 4.0.7 → 4.1.2

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,183 @@
+import { z } from 'zod'
+import type { Steps } from '../alphalib/types/template.ts'
+import { optionalStepsSchema } from '../alphalib/types/template.ts'
+import type { BillResponse, ListedTemplate, TemplateResponse } from '../apiTypes.ts'
+import type { AssemblyStatus, Transloadit } from '../Transloadit.ts'
+import type { IOutputCtl } from './OutputCtl.ts'
+
+// Re-export transloadit types for CLI use
+export type { AssemblyStatus, BillResponse, ListedTemplate, TemplateResponse }
+export type { Transloadit }
+export type { CreateAssemblyOptions } from '../Transloadit.ts'
+
+// Zod schemas for runtime validation
+export const APIErrorSchema = z.object({
+  error: z.string(),
+  message: z.string(),
+})
+export type APIError = z.infer<typeof APIErrorSchema>
+
+export 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
+}
+
+// Template list item (from API)
+export interface TemplateListItem {
+  id: string
+  modified: string
+  name?: string
+}
+
+// CLI Invocation types
+export interface BaseInvocation {
+  error?: boolean
+  message?: string
+  mode: string
+  action?: string
+  logLevel?: number
+  jsonMode?: boolean
+}
+
+export interface AssemblyInvocation extends BaseInvocation {
+  mode: 'assemblies'
+  action?: 'create' | 'get' | 'list' | 'delete' | 'replay'
+  inputs: string[]
+  output?: string
+  recursive?: boolean
+  watch?: boolean
+  del?: boolean
+  reprocessStale?: boolean
+  steps?: string
+  template?: string
+  fields?: Record<string, string>
+  assemblies?: string[]
+  before?: string
+  after?: string
+  keywords?: string[]
+  notify_url?: string
+  reparse?: boolean
+}
+
+export interface TemplateInvocation extends BaseInvocation {
+  mode: 'templates'
+  action?: 'create' | 'get' | 'list' | 'delete' | 'modify' | 'sync'
+  templates?: string[]
+  template?: string
+  name?: string
+  file?: string
+  files?: string[]
+  before?: string
+  after?: string
+  order?: 'asc' | 'desc'
+  sort?: string
+  fields?: string[]
+  recursive?: boolean
+}
+
+export interface BillInvocation extends BaseInvocation {
+  mode: 'bills'
+  action?: 'get'
+  months: string[]
+}
+
+export interface NotificationInvocation extends BaseInvocation {
+  mode: 'assembly-notifications'
+  action?: 'list' | 'replay'
+  assemblies?: string[]
+  notify_url?: string
+  type?: string
+  assembly_id?: string
+  pagesize?: number
+}
+
+export interface HelpInvocation extends BaseInvocation {
+  mode: 'help' | 'version' | 'register'
+}
+
+export type Invocation =
+  | AssemblyInvocation
+  | TemplateInvocation
+  | BillInvocation
+  | NotificationInvocation
+  | HelpInvocation
+
+// Command handler type
+export type CommandHandler<T extends BaseInvocation = BaseInvocation> = (
+  output: IOutputCtl,
+  client: Transloadit | undefined,
+  invocation: T,
+) => void | Promise<void>
+
+// Type guard for Error
+export function isError(value: unknown): value is Error {
+  return value instanceof Error
+}
+
+// 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
+}
+
+// Safe array access helper
+export function safeGet<T>(arr: T[], index: number): T | undefined {
+  return arr[index]
+}
+
+// Assert defined helper
+export function assertDefined<T>(value: T | undefined | null, message: string): T {
+  if (value === undefined || value === null) {
+    throw new Error(message)
+  }
+  return value
+}

package/src/cli.ts

@@ -4,310 +4,8 @@ import { realpathSync } from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
-import { type ZodIssue, z } from 'zod'
-import {
-  assemblyAuthInstructionsSchema,
-  assemblyInstructionsSchema,
-} from './alphalib/types/template.ts'
-import type { OptionalAuthParams } from './apiTypes.ts'
-import { Transloadit } from './Transloadit.ts'
-
-type UrlParamPrimitive = string | number | boolean
-type UrlParamArray = UrlParamPrimitive[]
-type NormalizedUrlParams = Record<string, UrlParamPrimitive | UrlParamArray>
-
-interface RunSigOptions {
-  providedInput?: string
-  algorithm?: string
-}
-
-interface RunSmartSigOptions {
-  providedInput?: string
-}
-
-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()
-
-export 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
-}
-
-function fail(message: string): void {
-  console.error(message)
-  process.exitCode = 1
-}
-
-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
-}
-
-function ensureCredentials(): { authKey: string; authSecret: string } | null {
-  const authKey = process.env.TRANSLOADIT_KEY || process.env.TRANSLOADIT_AUTH_KEY
-  const authSecret = process.env.TRANSLOADIT_SECRET || process.env.TRANSLOADIT_AUTH_SECRET
-
-  if (!authKey || !authSecret) {
-    fail(
-      'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.',
-    )
-    return null
-  }
-
-  return { authKey, authSecret }
-}
-
-export async function runSig(options: RunSigOptions = {}): Promise<void> {
-  const credentials = ensureCredentials()
-  if (credentials == null) return
-  const { authKey, authSecret } = credentials
-  const { providedInput, algorithm } = options
-
-  const rawInput = providedInput ?? (await readStdin())
-  const input = rawInput.trim()
-  let params: Record<string, unknown>
-
-  if (input === '') {
-    params = { auth: { key: authKey } }
-  } else {
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(input)
-    } catch (error) {
-      fail(`Failed to parse JSON from stdin: ${(error as Error).message}`)
-      return
-    }
-
-    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-      fail('Invalid params provided via stdin. Expected a JSON object.')
-      return
-    }
-
-    const parsedResult = cliSignatureParamsSchema.safeParse(parsed)
-    if (!parsedResult.success) {
-      fail(`Invalid params: ${formatIssues(parsedResult.error.issues)}`)
-      return
-    }
-
-    const parsedParams = parsedResult.data as Record<string, unknown>
-    const existingAuth =
-      typeof parsedParams.auth === 'object' &&
-      parsedParams.auth != null &&
-      !Array.isArray(parsedParams.auth)
-        ? (parsedParams.auth as Record<string, unknown>)
-        : {}
-
-    params = {
-      ...parsedParams,
-      auth: {
-        ...existingAuth,
-        key: authKey,
-      },
-    }
-  }
-
-  const client = new Transloadit({ authKey, authSecret })
-  try {
-    const signature = client.calcSignature(params as OptionalAuthParams, algorithm)
-    process.stdout.write(`${JSON.stringify(signature)}\n`)
-  } catch (error) {
-    fail(`Failed to generate signature: ${(error as Error).message}`)
-  }
-}
-
-export async function runSmartSig(options: RunSmartSigOptions = {}): Promise<void> {
-  const credentials = ensureCredentials()
-  if (credentials == null) return
-  const { authKey, authSecret } = credentials
-
-  const rawInput = options.providedInput ?? (await readStdin())
-  const input = rawInput.trim()
-  if (input === '') {
-    fail(
-      'Missing params provided via stdin. Expected a JSON object with workspace, template, input, and optional Smart CDN parameters.',
-    )
-    return
-  }
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(input)
-  } catch (error) {
-    fail(`Failed to parse JSON from stdin: ${(error as Error).message}`)
-    return
-  }
-
-  if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    fail('Invalid params provided via stdin. Expected a JSON object.')
-    return
-  }
-
-  const parsedResult = smartCdnParamsSchema.safeParse(parsed)
-  if (!parsedResult.success) {
-    fail(`Invalid params: ${formatIssues(parsedResult.error.issues)}`)
-    return
-  }
-
-  const { workspace, template, input: inputFieldRaw, url_params, expire_at_ms } = parsedResult.data
-  const urlParams = normalizeUrlParams(url_params as Record<string, unknown> | undefined)
-
-  let expiresAt: number | undefined
-  if (typeof expire_at_ms === 'string') {
-    const parsedNumber = Number.parseInt(expire_at_ms, 10)
-    if (Number.isNaN(parsedNumber)) {
-      fail('Invalid params: expire_at_ms must be a number.')
-      return
-    }
-    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,
-    })
-    process.stdout.write(`${signedUrl}\n`)
-  } catch (error) {
-    fail(`Failed to generate Smart CDN URL: ${(error as Error).message}`)
-  }
-}
-
-function parseSigArguments(args: string[]): { algorithm?: string } {
-  let algorithm: string | undefined
-  let index = 0
-  while (index < args.length) {
-    const arg = args[index]
-    if (arg === '--algorithm' || arg === '-a') {
-      const next = args[index + 1]
-      if (next == null || next.startsWith('-')) {
-        throw new Error('Missing value for --algorithm option')
-      }
-      algorithm = next
-      index += 2
-      continue
-    }
-    if (arg.startsWith('--algorithm=')) {
-      const [, value] = arg.split('=', 2)
-      if (value === undefined || value === '') {
-        throw new Error('Missing value for --algorithm option')
-      }
-      algorithm = value
-      index += 1
-      continue
-    }
-    throw new Error(`Unknown option: ${arg}`)
-  }
-
-  return { algorithm }
-}
-
-export async function main(args = process.argv.slice(2)): Promise<void> {
-  const [command, ...commandArgs] = args
-
-  switch (command) {
-    case 'smart_sig': {
-      await runSmartSig()
-      break
-    }
-
-    case 'sig': {
-      try {
-        const { algorithm } = parseSigArguments(commandArgs)
-        await runSig({ algorithm })
-      } catch (error) {
-        fail((error as Error).message)
-      }
-      break
-    }
-
-    case '-h':
-    case '--help':
-    case undefined: {
-      process.stdout.write(
-        [
-          'Usage:',
-          '  npx transloadit smart_sig    Read Smart CDN params JSON from stdin and output a signed URL.',
-          '  npx transloadit sig [--algorithm <name>]    Read params JSON from stdin and output signed payload JSON.',
-          '',
-          'Required JSON fields:',
-          '  smart_sig: workspace, template, input',
-          '  sig: none (object is optional)',
-          'Optional JSON fields:',
-          '  smart_sig: expire_at_ms, url_params',
-          '  sig: auth.expires and any supported assembly params',
-          '',
-          'Environment variables:',
-          '  TRANSLOADIT_KEY, TRANSLOADIT_SECRET',
-        ].join('\n'),
-      )
-      if (command === undefined) process.exitCode = 1
-      break
-    }
-
-    default: {
-      fail(`Unknown command: ${command}`)
-    }
-  }
-}
+import 'dotenv/config'
+import { createCli } from './cli/commands/index.ts'
 
 const currentFile = realpathSync(fileURLToPath(import.meta.url))
 
@@ -326,11 +24,20 @@ export function shouldRunCli(invoked?: string): boolean {
   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) => {
-    fail((error as Error).message)
+    console.error((error as Error).message)
+    process.exitCode = 1
   })
 }