@videxo/sdk 0.1.0 → 0.2.0

package/dist/client.js

@@ -1,12 +1,10 @@
 import createClient, {} from 'openapi-fetch';
+import { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT } from "./defaults.js";
 import { VidexoError, errorFromResponse, sdkError } from "./errors.js";
 import { abortableSleep, redacted, runtimeFetch, send } from "./transport.js";
 import { sendUpload, sizeOf } from "./uploads.js";
 import { verifyWebhook } from "./webhooks.js";
-export const DEFAULT_BASE_URL = 'https://api.videxo.io';
-export const DEFAULT_MAX_RETRIES = 2;
-export const DEFAULT_TIMEOUT_MS = 60_000;
-export const DEFAULT_WAIT = Object.freeze({ timeoutMs: 10 * 60_000, intervalMs: 2_000 });
+export { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT };
 const TERMINAL = new Set(['succeeded', 'failed', 'cancelled']);
 const OUTPUT_ALIAS = /^out_[A-Za-z0-9_]{1,48}$/;
 /** What an API key may hold: printable ASCII without spaces (the `Authorization` header carries it as is). */
@@ -28,6 +26,7 @@ export class Videxo {
     uploads;
     outputs;
     webhooks;
+    clientTokens;
     /** @internal */
     transport;
     /** @internal */
@@ -57,6 +56,7 @@ export class Videxo {
         this.uploads = new Uploads(this);
         this.outputs = new Outputs(this);
         this.webhooks = new Webhooks();
+        this.clientTokens = new ClientTokens(this);
     }
     /** @internal The per-request `fetch` that openapi-fetch calls: the transport with this call's policy. */
     fetchFor(retry, options = {}) {
@@ -112,6 +112,29 @@ export class Videxo {
     concat(body, options) {
         return this.createAt('/v1/concat', body, options);
     }
+    /** `POST /v1/slideshow`: the still `images` as one video, each held for a time, with an optional motion. */
+    slideshow(body, options) {
+        return this.createAt('/v1/slideshow', body, options);
+    }
+    /**
+     * `POST /v1/probe`: the container, duration and streams of `input`, read with ffprobe. The api waits
+     * up to 25 seconds; a job still running then is waited for here (`wait`), and its document read from
+     * its output file. A job that failed is answered, not thrown: `probe` is null and `error` says why.
+     */
+    async probe(body, options = {}) {
+        const answer = await this.createAt('/v1/probe', body, options);
+        if (TERMINAL.has(answer.state))
+            return answer;
+        const job = await this.jobs.wait(answer.id, { ...options.wait, signal: options.signal });
+        if (job.state !== 'succeeded')
+            return { ...job, probe: null };
+        const file = await this.outputs.download(job.id, 'out_metadata', { signal: options.signal });
+        return { ...job, probe: (await file.json()) };
+    }
+    /** `POST /v1/scenes`: the scenes of `input`, with their times and scores, as a JSON file. */
+    scenes(body, options) {
+        return this.createAt('/v1/scenes', body, options);
+    }
 }
 export class Jobs {
     #videxo;
@@ -323,6 +346,55 @@ export class Outputs {
         throw sdkError('output_ambiguous', `Several files of job ${jobId} are named ${output}: ${aliases.join(', ')}.`);
     }
 }
+/**
+ * Client tokens for apps and web pages (ADR 016): short-lived, narrowly scoped, minted here on your
+ * server. Hand the answer's `token` and `id` to the app, which uses `@videxo/sdk/client`. Minting
+ * supersedes nothing, so a lost answer is retried by minting again.
+ */
+export class ClientTokens {
+    #videxo;
+    constructor(videxo) {
+        this.#videxo = videxo;
+    }
+    /** `POST /v1/client-tokens`: a token with the grant you describe; `continues` refreshes a chain. */
+    create(grant, options = {}) {
+        const videxo = this.#videxo;
+        return videxo.unwrap(videxo.client.POST('/v1/client-tokens', { body: grant, fetch: videxo.fetchFor('safe', options) }));
+    }
+    /** A token for one upload by `subject`: what an app needs before it knows of any job. */
+    forUpload({ subject, maxSizeBytes, contentTypes, ttlSeconds, ...options }) {
+        return this.create({
+            subject,
+            uploads: { max_count: 1, max_size_bytes: maxSizeBytes, ...(contentTypes ? { content_types: contentTypes } : {}) },
+            ...(ttlSeconds === undefined ? {} : { ttl_seconds: ttlSeconds }),
+        }, options);
+    }
+    /** A token that reads one job: a new one, or with `continues` the next of the app's chain, adding the job. */
+    forJob(jobId, { subject, continues, ttlSeconds, ...options } = {}) {
+        return this.create({
+            jobs: { read: [jobId] },
+            ...(subject === undefined ? {} : { subject }),
+            ...(continues === undefined ? {} : { continues }),
+            ...(ttlSeconds === undefined ? {} : { ttl_seconds: ttlSeconds }),
+        }, options);
+    }
+    /** `DELETE /v1/client-tokens/{id}`: ends the token and its whole chain. Revoking again is fine. */
+    async revoke(id, options = {}) {
+        const videxo = this.#videxo;
+        const pending = videxo.client.DELETE('/v1/client-tokens/{id}', { params: { path: { id } }, fetch: videxo.fetchFor('safe', options) });
+        const { response, error } = (await pending.catch((failure) => {
+            throw redacted(videxo.transport, failure);
+        }));
+        if (!response.ok)
+            throw errorFromResponse(response, error);
+    }
+    /** `POST /v1/client-tokens/revoke`: ends every chain of the end user; answers how many tokens. */
+    async revokeSubject(subject, options = {}) {
+        const videxo = this.#videxo;
+        const { revoked } = await videxo.unwrap(videxo.client.POST('/v1/client-tokens/revoke', { body: { subject }, fetch: videxo.fetchFor('safe', options) }));
+        return revoked;
+    }
+}
 export class Webhooks {
     /** Checks a delivery's Standard Webhooks signature and answers its event (`verifyWebhook`). */
     verify(body, headers, secret, options) {

package/dist/defaults.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_BASE_URL = "https://api.videxo.io";
+export declare const DEFAULT_MAX_RETRIES = 2;
+export declare const DEFAULT_TIMEOUT_MS = 60000;
+export declare const DEFAULT_WAIT: Readonly<{
+    timeoutMs: number;
+    intervalMs: 2000;
+}>;

package/dist/defaults.js

@@ -0,0 +1,6 @@
+// The defaults the keyed client and the app client share, apart from both so that one can be
+// bundled without the other.
+export const DEFAULT_BASE_URL = 'https://api.videxo.io';
+export const DEFAULT_MAX_RETRIES = 2;
+export const DEFAULT_TIMEOUT_MS = 60_000;
+export const DEFAULT_WAIT = Object.freeze({ timeoutMs: 10 * 60_000, intervalMs: 2_000 });