Swift SDK

// Package.swift
.package(url: "https://github.com/videxo-io/videxo-swift", from: "0.1.0")
// and in your target's dependencies:
.product(name: "Videxo", package: "videxo-swift")

Copy failed. The text is selected; copy it with your keyboard.

import Videxo

let videxo = try VidexoClient(token: minted.token, tokenId: minted.id)
let completed = try await videxo.uploads.upload(file: fileURL) { progress in
    print(progress.fraction)
}
// Send completed.inputURL to your backend, which creates the job with its API key.

Copy failed. The text is selected; copy it with your keyboard.

let completed = try await VidexoUpload().send(file: fileURL, to: uploadURL, contentType: "video/mp4") { progress in
    print(progress.fraction)
}

Copy failed. The text is selected; copy it with your keyboard.

let handle = try VidexoUpload().start(file: fileURL, to: uploadURL)
handle.pause()
handle.resume()
let completed = try await handle.value

Copy failed. The text is selected; copy it with your keyboard.

private(set) lazy var uploader = BackgroundUploader(identifier: "com.example.videxo.uploads") { [unowned self] event in
    switch event {
    case let .progress(upload):
        self.progress(upload.progress.fraction)
    case let .finished(upload, result):
        // The system no longer needs the file. The tag names the copy this app made.
        if let tag = upload.tag, let copy = try? Uploads.copy(named: tag) { try? FileManager.default.removeItem(at: copy) }
        self.finish(upload.id, result)
    }
}

Copy failed. The text is selected; copy it with your keyboard.

func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
    Uploads.shared.uploader.handleEvents(completionHandler: completionHandler)
}

Copy failed. The text is selected; copy it with your keyboard.

let upload = try await videxo.uploads.create(forFile: fileInYourContainer)
let started = try uploader.start(file: fileInYourContainer, to: upload.uploadURL, tag: "order-7")

Copy failed. The text is selected; copy it with your keyboard.

/// Uploads `file` and follows the job your backend creates from it. `file` is from a picker, so it
/// is copied first: the system reads it while the app is suspended.
func run(file: URL, onStatus: @Sendable @escaping (String) -> Void) async throws -> ClientJob {
    let minted = try await backend.uploadToken()
    // `getToken` refreshes a token when it is about to end, so a long flow keeps its uploads and jobs.
    let getToken: VidexoClient.GetToken = { [backend] request in try await backend.refresh(tokenId: request.tokenId) }
    let videxo = try VidexoClient(token: minted.token, tokenId: minted.id, baseURL: apiURL, getToken: getToken)

    onStatus("Uploading")
    let copy = try copyIntoContainer(file)
    let upload = try await videxo.uploads.create(forFile: copy)
    let started = try Uploads.shared.uploader.start(file: copy, to: upload.uploadURL, tag: copy.lastPathComponent)
    let completed = try await Uploads.shared.completion(of: started.id)

    // Only your backend creates the job, and answers a continuation that may read it. The token cannot.
    onStatus("Creating the job")
    let job = try await backend.createJob(continues: minted.id, inputURL: completed.inputURL)
    let follower = try VidexoClient(token: job.token, tokenId: job.id, baseURL: apiURL, getToken: getToken)
    onStatus("Job \(job.jobId): running")
    return try await follower.jobs.wait(job.jobId)
}

Copy failed. The text is selected; copy it with your keyboard.

do {
    _ = try await videxo.uploads.upload(file: fileURL)
} catch let error as VidexoError where error.code == .limitExceeded && error.reason == "token_uploads" {
    // Your backend's grant is used up: ask it for a new token.
} catch let error as VidexoError {
    print(error.detail, error.requestId ?? "")
}

Copy failed. The text is selected; copy it with your keyboard.

/// A new client token for one upload.
func uploadToken() async throws -> MintedToken {
    try await post("api/client-tokens", [:])
}

/// The next token of the chain. `VidexoClient` asks for it when the current one is about to end.
func refresh(tokenId: String?) async throws -> FreshToken {
    guard let tokenId else { throw URLError(.userAuthenticationRequired) }
    let next: MintedToken = try await post("api/client-tokens", ["continues": tokenId])
    return FreshToken(token: next.token, id: next.id)
}

/// Your backend creates the job from the upload, with its API key, and answers a continuation that may read it.
func createJob(continues tokenId: String, inputURL: String) async throws -> FollowedJob {
    try await post("api/client-tokens/jobs", ["continues": tokenId, "input_url": inputURL])
}

Copy failed. The text is selected; copy it with your keyboard.

/** What an upload token may do: one upload of a video. It spends nothing, and it cannot create a job. */
const UPLOAD_GRANT = { max_count: 1, max_size_bytes: 100_000_000, content_types: ['video/*'] };

export function uploadToken(subject: string): Promise<ClientToken> {
  return call((videxo) => videxo.clientTokens.create({ subject, uploads: UPLOAD_GRANT }));
}

/** A continuation of the app's token that may read the job too. */
export function followToken(continues: string, jobId: string): Promise<ClientToken> {
  return call((videxo) => videxo.clientTokens.forJob(jobId, { continues }));
}

/**
 * The next token of the chain. A section left out is not granted, and only read job ids carry over, so
 * a token that is still for its upload names the grant again; the count stays the chain's.
 */
export function refreshToken(continues: string, following: boolean): Promise<ClientToken> {
  return call((videxo) => videxo.clientTokens.create(following ? { continues } : { continues, uploads: UPLOAD_GRANT }));
}

Copy failed. The text is selected; copy it with your keyboard.

// For an app that holds a client token instead of asking this server for each step.

/**
 * The signed-in user, from your own sign-in. This example has none, so it refuses everyone: replace
 * the lookup with your session or JWT check. VIDEXO_EXAMPLE_TEST_SESSIONS (JSON, a session to its
 * user) is there for the example's own test and for trying it locally; never set it in production.
 */
function currentUser(req: Request): string {
  const sessions = JSON.parse(process.env.VIDEXO_EXAMPLE_TEST_SESSIONS ?? '{}') as Record<string, string>;
  const session = /^Bearer (.+)$/.exec(req.get('authorization') ?? '')?.[1];
  if (session && Object.hasOwn(sessions, session)) return sessions[session]!;
  throw new VidexoProblem({
    type: 'about:blank',
    title: 'Sign in first.',
    status: 401,
    detail: 'This route needs a signed-in user.',
    code: 'authentication_failed',
  });
}

/** The chains of tokens this server minted, by token id. Keep them in your database, so they outlive a restart. */
type Chain = { user: string; following: boolean };
const chains = new Map<string, Chain>();

/** The chain of a token id, only for the user it was minted for; any other answer is the same as an unknown id. */
function chainOf(tokenId: unknown, user: string): Chain {
  const chain = typeof tokenId === 'string' ? chains.get(tokenId) : undefined;
  if (chain?.user === user) return chain;
  throw new VidexoProblem({ type: 'about:blank', title: 'Not found.', status: 404, detail: 'No such client token.', code: 'not_found' });
}

// No `continues`: a new upload token for this user. With it: the next token of the user's own chain.
app.post('/api/client-tokens', async (req, res) => {
  const user = currentUser(req);
  const { continues } = req.body ?? {};
  const chain = continues === undefined ? { user, following: false } : chainOf(continues, user);
  const minted = continues === undefined ? await uploadToken(user) : await refreshToken(continues, chain.following);
  chains.set(minted.id, chain);
  res.status(201).json({ id: minted.id, token: minted.token, expires_at: minted.expires_at });
});

// Creates the job from the user's upload, and answers its id with a continuation that may read it. The
// app never names a job: this server made this one, so it is the user's.
app.post('/api/client-tokens/jobs', async (req, res) => {
  const chain = chainOf(req.body?.continues, currentUser(req));
  const { continues, input_url } = req.body;
  const upload = typeof input_url === 'string' ? UPLOAD.exec(input_url)?.[1] : undefined;
  if (!upload) throw badRequest('input_url must be the input_url of an upload.');
  const job = await transcode(input_url, `transcode-${upload}`);
  const minted = await followToken(continues, job.id);
  chain.following = true;
  chains.set(minted.id, chain);
  res.status(201).json({ job_id: job.id, id: minted.id, token: minted.token, expires_at: minted.expires_at });
});

Copy failed. The text is selected; copy it with your keyboard.