@transloadit/node 4.1.3

package/src/alphalib/lib/nativeGlobby.ts

@@ -0,0 +1,244 @@
+import type { GlobOptionsWithoutFileTypes } from 'node:fs'
+import * as fs from 'node:fs'
+import { glob as fsGlob, stat as statAsync } from 'node:fs/promises'
+import path from 'node:path'
+
+type PatternInput = string | readonly string[]
+const { globSync: fsGlobSync } = fs
+
+export interface NativeGlobbyOptions {
+  cwd?: string
+  absolute?: boolean
+  onlyFiles?: boolean
+  ignore?: readonly string[]
+}
+
+interface NormalizedOptions {
+  cwd?: string
+  absolute: boolean
+  onlyFiles: boolean
+  ignore?: readonly string[]
+}
+
+interface Candidate {
+  rawPath: string
+  absolutePath: string
+}
+
+const normalizeSlashes = (value: string) => value.replace(/\\/g, '/')
+
+const toAbsolutePath = (rawPath: string, cwd?: string): string => {
+  if (path.isAbsolute(rawPath)) {
+    return rawPath
+  }
+  if (cwd) {
+    return path.join(cwd, rawPath)
+  }
+  return path.resolve(rawPath)
+}
+
+const normalizeOptions = (options: NativeGlobbyOptions = {}): NormalizedOptions => ({
+  cwd: options.cwd ? path.resolve(options.cwd) : undefined,
+  absolute: options.absolute ?? false,
+  onlyFiles: options.onlyFiles ?? true,
+  ignore: options.ignore && options.ignore.length > 0 ? options.ignore : undefined,
+})
+
+const hasGlobMagic = (pattern: string) => /[*?[\]{}()!]/.test(pattern)
+
+const expandPatternAsync = async (pattern: string, options: NormalizedOptions) => {
+  if (hasGlobMagic(pattern)) {
+    return [pattern]
+  }
+
+  try {
+    const absolute = toAbsolutePath(pattern, options.cwd)
+    const stats = await statAsync(absolute)
+    if (stats.isDirectory()) {
+      const expanded = normalizeSlashes(path.join(pattern, '**/*'))
+      return [expanded]
+    }
+  } catch {
+    // ignore missing paths; fall back to original pattern
+  }
+
+  return [pattern]
+}
+
+const expandPatternSync = (pattern: string, options: NormalizedOptions) => {
+  if (hasGlobMagic(pattern)) {
+    return [pattern]
+  }
+
+  try {
+    const absolute = toAbsolutePath(pattern, options.cwd)
+    const stats = fs.statSync(absolute)
+    if (stats.isDirectory()) {
+      const expanded = normalizeSlashes(path.join(pattern, '**/*'))
+      return [expanded]
+    }
+  } catch {
+    // ignore missing paths; fall back to original pattern
+  }
+
+  return [pattern]
+}
+
+const splitPatterns = (patterns: PatternInput) => {
+  const list = Array.isArray(patterns) ? patterns : [patterns]
+  const positive: string[] = []
+  const negative: string[] = []
+
+  for (const pattern of list) {
+    if (pattern.startsWith('!')) {
+      const negated = pattern.slice(1)
+      if (negated) {
+        negative.push(negated)
+      }
+    } else {
+      positive.push(pattern)
+    }
+  }
+
+  return { positive, negative }
+}
+
+const toGlobOptions = (options: NormalizedOptions): GlobOptionsWithoutFileTypes => {
+  const globOptions: GlobOptionsWithoutFileTypes = { withFileTypes: false }
+  if (options.cwd) {
+    globOptions.cwd = options.cwd
+  }
+  if (options.ignore) {
+    // Node's glob implementation uses `exclude` for ignore patterns
+    globOptions.exclude = options.ignore
+  }
+  return globOptions
+}
+
+const filterFilesAsync = async (candidates: Candidate[], requireFiles: boolean) => {
+  if (!requireFiles) {
+    return candidates
+  }
+
+  const filtered = await Promise.all(
+    candidates.map(async (candidate) => {
+      try {
+        const stats = await statAsync(candidate.absolutePath)
+        return stats.isFile() ? candidate : null
+      } catch {
+        return null
+      }
+    }),
+  )
+
+  return filtered.filter(Boolean) as Candidate[]
+}
+
+const filterFilesSync = (candidates: Candidate[], requireFiles: boolean) => {
+  if (!requireFiles) {
+    return candidates
+  }
+
+  const filtered: Candidate[] = []
+  for (const candidate of candidates) {
+    try {
+      const stats = fs.statSync(candidate.absolutePath)
+      if (stats.isFile()) {
+        filtered.push(candidate)
+      }
+    } catch {
+      // Ignore files that cannot be stat'ed
+    }
+  }
+  return filtered
+}
+
+const formatResult = (candidate: Candidate, options: NormalizedOptions) => {
+  const output = options.absolute ? candidate.absolutePath : candidate.rawPath
+  return normalizeSlashes(output)
+}
+
+const collectMatchesAsync = async (pattern: string, options: NormalizedOptions) => {
+  const matches: Candidate[] = []
+  for await (const match of fsGlob(pattern, toGlobOptions(options))) {
+    matches.push({
+      rawPath: match as string,
+      absolutePath: toAbsolutePath(match as string, options.cwd),
+    })
+  }
+  const filtered = await filterFilesAsync(matches, options.onlyFiles)
+  return filtered.map((candidate) => formatResult(candidate, options))
+}
+
+const collectMatchesSync = (pattern: string, options: NormalizedOptions) => {
+  const matches = (fsGlobSync(pattern, toGlobOptions(options)) as string[]).map((match) => ({
+    rawPath: match,
+    absolutePath: toAbsolutePath(match, options.cwd),
+  }))
+  const filtered = filterFilesSync(matches, options.onlyFiles)
+  return filtered.map((candidate) => formatResult(candidate, options))
+}
+
+type GlobbyLike = {
+  (patterns: PatternInput, options?: NativeGlobbyOptions): Promise<string[]>
+  sync(patterns: PatternInput, options?: NativeGlobbyOptions): string[]
+}
+
+export const nativeGlobby: GlobbyLike = Object.assign(
+  async (patterns: PatternInput, options?: NativeGlobbyOptions) => {
+    const normalized = normalizeOptions(options)
+    const { positive, negative } = splitPatterns(patterns)
+    const expandedPositives = (
+      await Promise.all(positive.map((pattern) => expandPatternAsync(pattern, normalized)))
+    ).flat()
+    const expandedNegatives = (
+      await Promise.all(negative.map((pattern) => expandPatternAsync(pattern, normalized)))
+    ).flat()
+    const results = new Set<string>()
+
+    for (const pattern of expandedPositives) {
+      const matches = await collectMatchesAsync(pattern, normalized)
+      for (const match of matches) {
+        results.add(match)
+      }
+    }
+
+    for (const pattern of expandedNegatives) {
+      const matches = await collectMatchesAsync(pattern, normalized)
+      for (const match of matches) {
+        results.delete(match)
+      }
+    }
+
+    return Array.from(results)
+  },
+  {
+    sync(patterns: PatternInput, options?: NativeGlobbyOptions) {
+      const normalized = normalizeOptions(options)
+      const { positive, negative } = splitPatterns(patterns)
+      const expandedPositives = positive.flatMap((pattern) =>
+        expandPatternSync(pattern, normalized),
+      )
+      const expandedNegatives = negative.flatMap((pattern) =>
+        expandPatternSync(pattern, normalized),
+      )
+      const results = new Set<string>()
+
+      for (const pattern of expandedPositives) {
+        const matches = collectMatchesSync(pattern, normalized)
+        for (const match of matches) {
+          results.add(match)
+        }
+      }
+
+      for (const pattern of expandedNegatives) {
+        const matches = collectMatchesSync(pattern, normalized)
+        for (const match of matches) {
+          results.delete(match)
+        }
+      }
+
+      return Array.from(results)
+    },
+  },
+)

package/src/alphalib/mcache.ts

@@ -0,0 +1,184 @@
+import type { SevLogger } from '@transloadit/sev-logger'
+import type { Schema } from 'zod'
+
+export interface McacheOpts {
+  ttlMs?: number
+  zodSchema?: Schema
+  logger?: SevLogger
+  /**
+   * Maximum number of entries in the cache. When exceeded, oldest entries are removed.
+   * Defaults to 10,000 entries.
+   */
+  maxSize?: number
+  /**
+   * Custom key generator function. If not provided, uses JSON.stringify.
+   */
+  keyFn?: (...args: unknown[]) => string
+}
+
+interface CacheEntry<T> {
+  value: T
+  timestamp: number
+}
+
+/**
+ * Memory cache abstraction to help cache function results in-process.
+ *
+ * Example:
+ *
+ *   const cache = new Mcache<Instance[]>({ ttlMs: 1000 * 60 * 10 })
+ *
+ *   async function fetchInstances(region: string): Promise<Instance[]> {
+ *     return cache.get(region, async () => {
+ *       // Do work, e.g. fetch instances from AWS
+ *       return await this._fetchInstances(region)
+ *     })
+ *   }
+ */
+export class Mcache<T> {
+  #cache: Map<string, CacheEntry<T>>
+  #opts: Required<Omit<McacheOpts, 'logger' | 'zodSchema' | 'keyFn'>> &
+    Pick<McacheOpts, 'logger' | 'zodSchema' | 'keyFn'>
+
+  constructor(opts: McacheOpts = {}) {
+    this.#cache = new Map()
+    this.#opts = {
+      ttlMs: opts.ttlMs ?? Number.POSITIVE_INFINITY,
+      maxSize: opts.maxSize ?? 10_000,
+      zodSchema: opts.zodSchema,
+      logger: opts.logger,
+      keyFn: opts.keyFn,
+    }
+  }
+
+  /**
+   * Get a value from cache, or compute it using the provided function.
+   * The cache key is generated from the args using JSON.stringify by default,
+   * or using the custom keyFn if provided.
+   */
+  async get(producer: () => Promise<T> | T, ...args: unknown[]): Promise<T> {
+    const key = this.#opts.keyFn ? this.#opts.keyFn(...args) : JSON.stringify(args)
+    const cached = this.#cache.get(key)
+
+    if (cached) {
+      const age = Date.now() - cached.timestamp
+      if (age <= this.#opts.ttlMs || this.#opts.ttlMs === Number.POSITIVE_INFINITY) {
+        this.#opts.logger?.debug(`Cache hit for key ${key} (age: ${age}ms)`)
+        return cached.value
+      }
+
+      this.#opts.logger?.debug(
+        `Cache expired for key ${key} (age: ${age}ms > ${this.#opts.ttlMs}ms)`,
+      )
+      this.#cache.delete(key)
+    }
+
+    this.#opts.logger?.debug(`Cache miss for key ${key}, computing value`)
+    const value = await producer()
+
+    // Validate if schema provided
+    if (this.#opts.zodSchema) {
+      this.#opts.zodSchema.parse(value)
+    }
+
+    this.#set(key, value)
+    return value
+  }
+
+  /**
+   * Set a value in the cache directly.
+   */
+  set(value: T, ...args: unknown[]): void {
+    const key = this.#opts.keyFn ? this.#opts.keyFn(...args) : JSON.stringify(args)
+
+    // Validate if schema provided
+    if (this.#opts.zodSchema) {
+      this.#opts.zodSchema.parse(value)
+    }
+
+    this.#set(key, value)
+  }
+
+  /**
+   * Check if a key exists in cache and is not expired.
+   */
+  has(...args: unknown[]): boolean {
+    const key = this.#opts.keyFn ? this.#opts.keyFn(...args) : JSON.stringify(args)
+    const cached = this.#cache.get(key)
+
+    if (!cached) {
+      return false
+    }
+
+    const age = Date.now() - cached.timestamp
+    if (age > this.#opts.ttlMs && this.#opts.ttlMs !== Number.POSITIVE_INFINITY) {
+      this.#cache.delete(key)
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Clear all entries from the cache.
+   */
+  clear(): void {
+    this.#cache.clear()
+  }
+
+  /**
+   * Delete a specific entry from the cache.
+   */
+  delete(...args: unknown[]): boolean {
+    const key = this.#opts.keyFn ? this.#opts.keyFn(...args) : JSON.stringify(args)
+    return this.#cache.delete(key)
+  }
+
+  /**
+   * Get the current size of the cache.
+   */
+  get size(): number {
+    return this.#cache.size
+  }
+
+  /**
+   * Clean up expired entries and enforce size limit.
+   */
+  cleanup(): void {
+    const now = Date.now()
+
+    // Remove expired entries
+    if (this.#opts.ttlMs !== Number.POSITIVE_INFINITY) {
+      for (const [key, entry] of this.#cache.entries()) {
+        if (now - entry.timestamp > this.#opts.ttlMs) {
+          this.#cache.delete(key)
+        }
+      }
+    }
+
+    // Enforce size limit by removing oldest entries
+    if (this.#cache.size > this.#opts.maxSize) {
+      const entries = Array.from(this.#cache.entries())
+      entries.sort((a, b) => a[1].timestamp - b[1].timestamp)
+      const toRemove = entries.slice(0, this.#cache.size - this.#opts.maxSize)
+      for (const [key] of toRemove) {
+        this.#cache.delete(key)
+      }
+      this.#opts.logger?.debug(
+        `Cache size limit reached, removed ${toRemove.length} oldest entries`,
+      )
+    }
+  }
+
+  #set(key: string, value: T): void {
+    this.#cache.set(key, {
+      value,
+      timestamp: Date.now(),
+    })
+
+    // Trigger cleanup if we're over size limit
+    if (this.#cache.size > this.#opts.maxSize) {
+      this.cleanup()
+    }
+  }
+}

package/src/alphalib/tryCatch.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents a successful result where error is null and data is present
+ */
+export type Success<T> = [null, T]
+
+/**
+ * Represents a failure result where error contains an error instance and data is null
+ */
+export type Failure<E = Error> = [E, null]
+
+/**
+ * Represents the result of an operation that can either succeed with T or fail with E
+ */
+export type Result<T, E = Error> = Success<T> | Failure<E>
+
+/**
+ * Wraps a promise in a try-catch block and returns a tuple of [error, data]
+ * where exactly one value is non-null
+ *
+ * @param promise The promise to execute safely
+ * @returns A tuple of [error, data] where one is null
+ */
+export async function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>> {
+  try {
+    const data = await promise
+    return [null, data] as Success<T>
+  } catch (error) {
+    return [error as E, null] as Failure<E>
+  }
+}

package/src/alphalib/types/assembliesGet.ts

@@ -0,0 +1,42 @@
+import z from 'zod'
+
+import { assemblyAuthInstructionsSchema } from './template.ts'
+
+export const assembliesGetSchema = z
+  .object({
+    auth: assemblyAuthInstructionsSchema,
+    page: z
+      .number()
+      .int()
+      .default(1)
+      .describe('Specifies the current page, within the current pagination'),
+    pagesize: z
+      .number()
+      .int()
+      .min(1)
+      .max(5000)
+      .default(50)
+      .describe(
+        'Specifies how many Assemblies to be received per API request, which is useful for pagination.',
+      ),
+    type: z
+      .enum(['all', 'uploading', 'executing', 'canceled', 'completed', 'failed', 'request_aborted'])
+      .describe('Specifies the types of Assemblies to be retrieved.'),
+    fromdate: z
+      .string()
+      .describe(
+        'Specifies the minimum Assembly UTC creation date/time. Only Assemblies after this time will be retrieved. Use the format `Y-m-d H:i:s`.',
+      ),
+    todate: z
+      .string()
+      .default('NOW()')
+      .describe(
+        'Specifies the maximum Assembly UTC creation date/time. Only Assemblies before this time will be retrieved. Use the format `Y-m-d H:i:s`.',
+      ),
+    keywords: z
+      .array(z.string())
+      .describe(
+        'Specifies keywords to be matched in the Assembly Status. The Assembly fields checked include the `id`, `redirect_url`, `fields`, and `notify_url`, as well as error messages and files used.',
+      ),
+  })
+  .strict()

package/src/alphalib/types/assemblyReplay.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+import {
+  assemblyAuthInstructionsSchema,
+  fieldsSchema,
+  notifyUrlSchema,
+  optionalStepsSchema,
+  templateIdSchema,
+} from './template.ts'
+
+export const assemblyReplaySchema = z
+  .object({
+    auth: assemblyAuthInstructionsSchema,
+    steps: optionalStepsSchema as typeof optionalStepsSchema,
+    template_id: templateIdSchema,
+    notify_url: notifyUrlSchema,
+    fields: fieldsSchema,
+    reparse_template: z
+      .union([z.literal(0), z.literal(1)])
+      .describe(
+        'Specify `1` to reparse the Template used in your Assembly (useful if the Template changed in the meantime). Alternatively, `0` replays the identical Steps used in the Assembly.',
+      ),
+  })
+  .strict()

package/src/alphalib/types/assemblyReplayNotification.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+
+import { assemblyAuthInstructionsSchema, optionalStepsSchema } from './template.ts'
+
+export const assemblyReplayNotificationSchema = z
+  .object({
+    auth: assemblyAuthInstructionsSchema,
+    steps: optionalStepsSchema as typeof optionalStepsSchema,
+    wait: z
+      .boolean()
+      .default(true)
+      .describe(
+        'If it is provided with the value `false`, then the API request will return immediately even though the Notification is still in progress. This can be useful if your server takes some time to respond, but you do not want the replay API request to hang.',
+      ),
+  })
+  .strict()