@transloadit/convex 0.0.1

package/README.md

@@ -0,0 +1,235 @@
+# Transloadit Convex Component
+
+A Convex component for creating Transloadit Assemblies, tracking their status/results, and supporting both form uploads and resumable tus uploads.
+
+## Features
+
+- Create Assemblies with templates or inline steps.
+- Generate signed upload params for browser form uploads.
+- Resumable uploads via tus (client-side hook).
+- Webhook ingestion with signature verification.
+- Persist Assembly status + results in Convex.
+- Typed API wrappers and React hooks.
+
+## Install
+
+```bash
+yarn add @transloadit/convex
+```
+
+## Setup
+
+### 1) Register the component
+
+```ts
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import transloadit from "@transloadit/convex/convex.config";
+
+const app = defineApp();
+app.use(transloadit);
+
+export default app;
+```
+
+### 2) Set environment variables
+
+Preferred names:
+
+```bash
+npx convex env set TRANSLOADIT_AUTH_KEY <your_auth_key>
+npx convex env set TRANSLOADIT_AUTH_SECRET <your_auth_secret>
+```
+
+Aliases also supported:
+
+```bash
+npx convex env set TRANSLOADIT_KEY <your_auth_key>
+npx convex env set TRANSLOADIT_SECRET <your_auth_secret>
+```
+
+### 3) Create a demo template (idempotent)
+
+We use the Transloadit CLI under the hood for the best DX and to avoid hand-rolling API calls.
+
+```bash
+yarn template:ensure
+```
+
+The script reads `TRANSLOADIT_KEY/TRANSLOADIT_SECRET` (or `TRANSLOADIT_AUTH_KEY/TRANSLOADIT_AUTH_SECRET`) from `.env`,
+creates or updates the template `convex-demo`, and prints the template id.
+Use that id as `VITE_TRANSLOADIT_TEMPLATE_ID` in `example/.env` when running the demo app.
+
+## Backend API
+
+```ts
+// convex/transloadit.ts
+import { makeTransloaditAPI } from "@transloadit/convex";
+import { components } from "./_generated/api";
+
+export const {
+  createAssembly,
+  generateUploadParams,
+  handleWebhook,
+  getAssemblyStatus,
+  listAssemblies,
+  listResults,
+  storeAssemblyMetadata,
+} = makeTransloaditAPI(components.transloadit);
+```
+
+Note: if you don’t supply `expires`, the component defaults it to 1 hour from now.
+
+## Webhook route
+
+Transloadit sends webhooks as `multipart/form-data` with `transloadit` (JSON) and `signature` fields.
+
+```ts
+// convex/http.ts
+import { httpAction, httpRouter } from "convex/server";
+import { api } from "./_generated/api";
+
+const http = httpRouter();
+
+http.route({
+  path: "/transloadit/webhook",
+  method: "POST",
+  handler: httpAction(async (ctx, request) => {
+    const formData = await request.formData();
+    const rawPayload = formData.get("transloadit");
+    const signature = formData.get("signature");
+
+    if (typeof rawPayload !== "string") {
+      return new Response("Missing payload", { status: 400 });
+    }
+
+    const payload = JSON.parse(rawPayload);
+
+    await ctx.runAction(api.transloadit.handleWebhook, {
+      payload,
+      rawBody: rawPayload,
+      signature: typeof signature === "string" ? signature : undefined,
+    });
+
+    return new Response(null, { status: 204 });
+  }),
+});
+
+export default http;
+```
+
+### Local webhook testing with cloudflared
+
+If you want to test webhooks locally, tunnel your Convex dev HTTP endpoint:
+
+```bash
+yarn tunnel
+```
+
+Use the generated public URL as `notifyUrl` when creating Assemblies or set
+`VITE_TRANSLOADIT_NOTIFY_URL` for the example app.
+
+You can also run `yarn tunnel --once` to print the URL and exit.
+
+### Full QA flow (template + tunnel + webhook)
+
+This runs an end-to-end webhook QA flow against Transloadit using a local webhook server
+and cloudflared (auto-downloaded if missing):
+
+```bash
+yarn qa:full
+```
+
+It prints a JSON summary including the assembly id, webhook status, and number of stored results.
+
+## React usage
+
+### Form upload
+
+```tsx
+import { useTransloaditUpload } from "@transloadit/convex/react";
+import { api } from "../convex/_generated/api";
+
+function UploadButton() {
+  const { upload, isUploading, progress, error } = useTransloaditUpload(
+    api.transloadit.generateUploadParams,
+  );
+
+  const handleUpload = async (file: File) => {
+    await upload(file, {
+      templateId: "template_id_here",
+      onProgress: (percent) => console.log(percent),
+    });
+  };
+
+  return (
+    <div>
+      <input type="file" onChange={(e) => handleUpload(e.target.files![0])} />
+      {isUploading && <p>Uploading: {progress}%</p>}
+      {error && <p>{error.message}</p>}
+    </div>
+  );
+}
+```
+
+### Resumable tus upload
+
+```tsx
+import { useTransloaditTusUpload } from "@transloadit/convex/react";
+import { api } from "../convex/_generated/api";
+
+function TusUpload() {
+  const { upload, isUploading, progress } = useTransloaditTusUpload(
+    api.transloadit.createAssembly,
+  );
+
+  const handleUpload = async (file: File) => {
+    await upload(file, {
+      templateId: "template_id_here",
+    });
+  };
+
+  return (
+    <div>
+      <input type="file" onChange={(e) => handleUpload(e.target.files![0])} />
+      {isUploading && <p>Uploading: {progress}%</p>}
+    </div>
+  );
+}
+```
+
+### Reactive status/results
+
+```tsx
+import { useAssemblyStatus, useTransloaditFiles } from "@transloadit/convex/react";
+import { api } from "../convex/_generated/api";
+
+function AssemblyStatus({ assemblyId }: { assemblyId: string }) {
+  const status = useAssemblyStatus(api.transloadit.getAssemblyStatus, assemblyId);
+  const results = useTransloaditFiles(api.transloadit.listResults, {
+    assemblyId,
+  });
+
+  if (!status) return null;
+  return (
+    <div>
+      <p>Status: {status.ok}</p>
+      <p>Results: {results?.length ?? 0}</p>
+    </div>
+  );
+}
+```
+
+## Smoke test
+
+Create a `.env` file in the repo root and run:
+
+```bash
+yarn smoke
+```
+
+Expected output: a JSON blob containing `assemblyId` and (when available) `tusUrl`.
+
+## Example app
+
+See `example/README.md` for setup and usage.

package/dist/client/index.d.ts

@@ -0,0 +1,244 @@
+import { type Infer } from "convex/values";
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { RunActionCtx, RunMutationCtx, RunQueryCtx } from "./types.js";
+export interface TransloaditConfig {
+    authKey: string;
+    authSecret: string;
+}
+export type TransloaditComponent = ComponentApi;
+export declare const vAssemblyResponse: import("convex/values").VObject<{
+    status?: string | undefined;
+    fields?: any;
+    ok?: string | undefined;
+    message?: string | undefined;
+    templateId?: string | undefined;
+    notifyUrl?: string | undefined;
+    numExpectedUploadFiles?: number | undefined;
+    uploads?: any;
+    results?: any;
+    error?: any;
+    raw?: any;
+    userId?: string | undefined;
+    _id: string;
+    _creationTime: number;
+    assemblyId: string;
+    createdAt: number;
+    updatedAt: number;
+}, {
+    _id: import("convex/values").VString<string, "required">;
+    _creationTime: import("convex/values").VFloat64<number, "required">;
+    assemblyId: import("convex/values").VString<string, "required">;
+    status: import("convex/values").VString<string | undefined, "optional">;
+    ok: import("convex/values").VString<string | undefined, "optional">;
+    message: import("convex/values").VString<string | undefined, "optional">;
+    templateId: import("convex/values").VString<string | undefined, "optional">;
+    notifyUrl: import("convex/values").VString<string | undefined, "optional">;
+    numExpectedUploadFiles: import("convex/values").VFloat64<number | undefined, "optional">;
+    fields: import("convex/values").VAny<any, "optional", string>;
+    uploads: import("convex/values").VAny<any, "optional", string>;
+    results: import("convex/values").VAny<any, "optional", string>;
+    error: import("convex/values").VAny<any, "optional", string>;
+    raw: import("convex/values").VAny<any, "optional", string>;
+    createdAt: import("convex/values").VFloat64<number, "required">;
+    updatedAt: import("convex/values").VFloat64<number, "required">;
+    userId: import("convex/values").VString<string | undefined, "optional">;
+}, "required", "_id" | "_creationTime" | "assemblyId" | "status" | "fields" | "ok" | "message" | "templateId" | "notifyUrl" | "numExpectedUploadFiles" | "uploads" | "results" | "error" | "raw" | "createdAt" | "updatedAt" | "userId" | `fields.${string}` | `uploads.${string}` | `results.${string}` | `error.${string}` | `raw.${string}`>;
+export type AssemblyResponse = Infer<typeof vAssemblyResponse>;
+export declare const vAssemblyResultResponse: import("convex/values").VObject<{
+    resultId?: string | undefined;
+    sslUrl?: string | undefined;
+    name?: string | undefined;
+    size?: number | undefined;
+    mime?: string | undefined;
+    _id: string;
+    _creationTime: number;
+    assemblyId: string;
+    raw: any;
+    createdAt: number;
+    stepName: string;
+}, {
+    _id: import("convex/values").VString<string, "required">;
+    _creationTime: import("convex/values").VFloat64<number, "required">;
+    assemblyId: import("convex/values").VString<string, "required">;
+    stepName: import("convex/values").VString<string, "required">;
+    resultId: import("convex/values").VString<string | undefined, "optional">;
+    sslUrl: import("convex/values").VString<string | undefined, "optional">;
+    name: import("convex/values").VString<string | undefined, "optional">;
+    size: import("convex/values").VFloat64<number | undefined, "optional">;
+    mime: import("convex/values").VString<string | undefined, "optional">;
+    raw: import("convex/values").VAny<any, "required", string>;
+    createdAt: import("convex/values").VFloat64<number, "required">;
+}, "required", "_id" | "_creationTime" | "assemblyId" | "raw" | "createdAt" | `raw.${string}` | "stepName" | "resultId" | "sslUrl" | "name" | "size" | "mime">;
+export type AssemblyResultResponse = Infer<typeof vAssemblyResultResponse>;
+export declare const vCreateAssemblyArgs: import("convex/values").VObject<{
+    fields?: any;
+    templateId?: string | undefined;
+    notifyUrl?: string | undefined;
+    numExpectedUploadFiles?: number | undefined;
+    userId?: string | undefined;
+    steps?: any;
+    expires?: string | undefined;
+    additionalParams?: any;
+}, {
+    templateId: import("convex/values").VString<string | undefined, "optional">;
+    steps: import("convex/values").VAny<any, "optional", string>;
+    fields: import("convex/values").VAny<any, "optional", string>;
+    notifyUrl: import("convex/values").VString<string | undefined, "optional">;
+    numExpectedUploadFiles: import("convex/values").VFloat64<number | undefined, "optional">;
+    expires: import("convex/values").VString<string | undefined, "optional">;
+    additionalParams: import("convex/values").VAny<any, "optional", string>;
+    userId: import("convex/values").VString<string | undefined, "optional">;
+}, "required", "fields" | "templateId" | "notifyUrl" | "numExpectedUploadFiles" | "userId" | `fields.${string}` | "steps" | "expires" | "additionalParams" | `steps.${string}` | `additionalParams.${string}`>;
+export declare class TransloaditClient {
+    component: TransloaditComponent;
+    config: TransloaditConfig;
+    constructor(component: TransloaditComponent, config?: Partial<TransloaditConfig>);
+    static create(component: TransloaditComponent, config: TransloaditConfig): TransloaditClient;
+    createAssembly(ctx: RunActionCtx, args: Infer<typeof vCreateAssemblyArgs>): Promise<{
+        assemblyId: string;
+        data: any;
+    }>;
+    generateUploadParams(ctx: RunActionCtx, args: Infer<typeof vCreateAssemblyArgs>): Promise<{
+        params: string;
+        signature: string;
+        url: string;
+    }>;
+    handleWebhook(ctx: RunActionCtx, args: {
+        payload: unknown;
+        rawBody?: string;
+        signature?: string;
+        verifySignature?: boolean;
+    }): Promise<{
+        assemblyId: string;
+        resultCount: number;
+    }>;
+    getAssemblyStatus(ctx: RunQueryCtx, assemblyId: string): Promise<any>;
+    listAssemblies(ctx: RunQueryCtx, args?: {
+        status?: string;
+        userId?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    listResults(ctx: RunQueryCtx, args: {
+        assemblyId: string;
+        stepName?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    storeAssemblyMetadata(ctx: RunMutationCtx, args: {
+        assemblyId: string;
+        userId?: string;
+        fields?: unknown;
+    }): Promise<any>;
+    api(): {
+        createAssembly: import("convex/server").RegisteredAction<"public", {
+            fields?: any;
+            templateId?: string | undefined;
+            notifyUrl?: string | undefined;
+            numExpectedUploadFiles?: number | undefined;
+            userId?: string | undefined;
+            steps?: any;
+            expires?: string | undefined;
+            additionalParams?: any;
+        }, Promise<{
+            assemblyId: string;
+            data: any;
+        }>>;
+        generateUploadParams: import("convex/server").RegisteredAction<"public", {
+            fields?: any;
+            templateId?: string | undefined;
+            notifyUrl?: string | undefined;
+            numExpectedUploadFiles?: number | undefined;
+            userId?: string | undefined;
+            steps?: any;
+            expires?: string | undefined;
+            additionalParams?: any;
+        }, Promise<{
+            params: string;
+            signature: string;
+            url: string;
+        }>>;
+        handleWebhook: import("convex/server").RegisteredAction<"public", {
+            signature?: string | undefined;
+            rawBody?: string | undefined;
+            verifySignature?: boolean | undefined;
+            payload: any;
+        }, Promise<{
+            assemblyId: string;
+            resultCount: number;
+        }>>;
+        getAssemblyStatus: import("convex/server").RegisteredQuery<"public", {
+            assemblyId: string;
+        }, Promise<any>>;
+        listAssemblies: import("convex/server").RegisteredQuery<"public", {
+            status?: string | undefined;
+            userId?: string | undefined;
+            limit?: number | undefined;
+        }, Promise<any[]>>;
+        listResults: import("convex/server").RegisteredQuery<"public", {
+            stepName?: string | undefined;
+            limit?: number | undefined;
+            assemblyId: string;
+        }, Promise<any[]>>;
+        storeAssemblyMetadata: import("convex/server").RegisteredMutation<"public", {
+            fields?: any;
+            userId?: string | undefined;
+            assemblyId: string;
+        }, Promise<any>>;
+    };
+}
+export declare function makeTransloaditAPI(component: TransloaditComponent, config?: Partial<TransloaditConfig>): {
+    createAssembly: import("convex/server").RegisteredAction<"public", {
+        fields?: any;
+        templateId?: string | undefined;
+        notifyUrl?: string | undefined;
+        numExpectedUploadFiles?: number | undefined;
+        userId?: string | undefined;
+        steps?: any;
+        expires?: string | undefined;
+        additionalParams?: any;
+    }, Promise<{
+        assemblyId: string;
+        data: any;
+    }>>;
+    generateUploadParams: import("convex/server").RegisteredAction<"public", {
+        fields?: any;
+        templateId?: string | undefined;
+        notifyUrl?: string | undefined;
+        numExpectedUploadFiles?: number | undefined;
+        userId?: string | undefined;
+        steps?: any;
+        expires?: string | undefined;
+        additionalParams?: any;
+    }, Promise<{
+        params: string;
+        signature: string;
+        url: string;
+    }>>;
+    handleWebhook: import("convex/server").RegisteredAction<"public", {
+        signature?: string | undefined;
+        rawBody?: string | undefined;
+        verifySignature?: boolean | undefined;
+        payload: any;
+    }, Promise<{
+        assemblyId: string;
+        resultCount: number;
+    }>>;
+    getAssemblyStatus: import("convex/server").RegisteredQuery<"public", {
+        assemblyId: string;
+    }, Promise<any>>;
+    listAssemblies: import("convex/server").RegisteredQuery<"public", {
+        status?: string | undefined;
+        userId?: string | undefined;
+        limit?: number | undefined;
+    }, Promise<any[]>>;
+    listResults: import("convex/server").RegisteredQuery<"public", {
+        stepName?: string | undefined;
+        limit?: number | undefined;
+        assemblyId: string;
+    }, Promise<any[]>>;
+    storeAssemblyMetadata: import("convex/server").RegisteredMutation<"public", {
+        fields?: any;
+        userId?: string | undefined;
+        assemblyId: string;
+    }, Promise<any>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAK,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAYhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+UAkB5B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE/D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;8JAYlC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;8MAS9B,CAAC;AAEH,qBAAa,iBAAiB;IACpB,SAAS,EAAE,oBAAoB,CAAC;IAChC,MAAM,EAAE,iBAAiB,CAAC;gBAGhC,SAAS,EAAE,oBAAoB,EAC/B,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAarC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,oBAAoB,EAAE,MAAM,EAAE,iBAAiB;IAIlE,cAAc,CAClB,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,KAAK,CAAC,OAAO,mBAAmB,CAAC;;;;IAQnC,oBAAoB,CACxB,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,KAAK,CAAC,OAAO,mBAAmB,CAAC;;;;;IAQnC,aAAa,CACjB,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE;QACJ,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B;;;;IAQG,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM;IAItD,cAAc,CAClB,GAAG,EAAE,WAAW,EAChB,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAKvD,WAAW,CACf,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAK3D,qBAAqB,CACzB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;IAKjE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGJ;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,oBAAoB,EAC/B,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkGpC"}

package/dist/client/index.js

@@ -0,0 +1,196 @@
+import { actionGeneric, mutationGeneric, queryGeneric } from "convex/server";
+import { v } from "convex/values";
+function requireEnv(names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value) {
+            return value;
+        }
+    }
+    throw new Error(`Missing ${names.join(" or ")} environment variable`);
+}
+export const vAssemblyResponse = v.object({
+    _id: v.string(),
+    _creationTime: v.number(),
+    assemblyId: v.string(),
+    status: v.optional(v.string()),
+    ok: v.optional(v.string()),
+    message: v.optional(v.string()),
+    templateId: v.optional(v.string()),
+    notifyUrl: v.optional(v.string()),
+    numExpectedUploadFiles: v.optional(v.number()),
+    fields: v.optional(v.any()),
+    uploads: v.optional(v.any()),
+    results: v.optional(v.any()),
+    error: v.optional(v.any()),
+    raw: v.optional(v.any()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    userId: v.optional(v.string()),
+});
+export const vAssemblyResultResponse = v.object({
+    _id: v.string(),
+    _creationTime: v.number(),
+    assemblyId: v.string(),
+    stepName: v.string(),
+    resultId: v.optional(v.string()),
+    sslUrl: v.optional(v.string()),
+    name: v.optional(v.string()),
+    size: v.optional(v.number()),
+    mime: v.optional(v.string()),
+    raw: v.any(),
+    createdAt: v.number(),
+});
+export const vCreateAssemblyArgs = v.object({
+    templateId: v.optional(v.string()),
+    steps: v.optional(v.any()),
+    fields: v.optional(v.any()),
+    notifyUrl: v.optional(v.string()),
+    numExpectedUploadFiles: v.optional(v.number()),
+    expires: v.optional(v.string()),
+    additionalParams: v.optional(v.any()),
+    userId: v.optional(v.string()),
+});
+export class TransloaditClient {
+    constructor(component, config) {
+        this.component = component;
+        this.config = {
+            authKey: config?.authKey ??
+                requireEnv(["TRANSLOADIT_AUTH_KEY", "TRANSLOADIT_KEY"]),
+            authSecret: config?.authSecret ??
+                requireEnv(["TRANSLOADIT_AUTH_SECRET", "TRANSLOADIT_SECRET"]),
+        };
+    }
+    static create(component, config) {
+        return new TransloaditClient(component, config);
+    }
+    async createAssembly(ctx, args) {
+        return ctx.runAction(this.component.lib.createAssembly, {
+            ...args,
+            config: this.config,
+        });
+    }
+    async generateUploadParams(ctx, args) {
+        return ctx.runAction(this.component.lib.generateUploadParams, {
+            ...args,
+            config: this.config,
+        });
+    }
+    async handleWebhook(ctx, args) {
+        return ctx.runAction(this.component.lib.handleWebhook, {
+            ...args,
+            config: { authSecret: this.config.authSecret },
+        });
+    }
+    async getAssemblyStatus(ctx, assemblyId) {
+        return ctx.runQuery(this.component.lib.getAssemblyStatus, { assemblyId });
+    }
+    async listAssemblies(ctx, args) {
+        return ctx.runQuery(this.component.lib.listAssemblies, args ?? {});
+    }
+    async listResults(ctx, args) {
+        return ctx.runQuery(this.component.lib.listResults, args);
+    }
+    async storeAssemblyMetadata(ctx, args) {
+        return ctx.runMutation(this.component.lib.storeAssemblyMetadata, args);
+    }
+    api() {
+        return makeTransloaditAPI(this.component, this.config);
+    }
+}
+export function makeTransloaditAPI(component, config) {
+    const resolvedConfig = {
+        authKey: config?.authKey ??
+            requireEnv(["TRANSLOADIT_AUTH_KEY", "TRANSLOADIT_KEY"]),
+        authSecret: config?.authSecret ??
+            requireEnv(["TRANSLOADIT_AUTH_SECRET", "TRANSLOADIT_SECRET"]),
+    };
+    return {
+        createAssembly: actionGeneric({
+            args: vCreateAssemblyArgs,
+            returns: v.object({
+                assemblyId: v.string(),
+                data: v.any(),
+            }),
+            handler: async (ctx, args) => {
+                return ctx.runAction(component.lib.createAssembly, {
+                    ...args,
+                    config: resolvedConfig,
+                });
+            },
+        }),
+        generateUploadParams: actionGeneric({
+            args: vCreateAssemblyArgs,
+            returns: v.object({
+                params: v.string(),
+                signature: v.string(),
+                url: v.string(),
+            }),
+            handler: async (ctx, args) => {
+                return ctx.runAction(component.lib.generateUploadParams, {
+                    ...args,
+                    config: resolvedConfig,
+                });
+            },
+        }),
+        handleWebhook: actionGeneric({
+            args: {
+                payload: v.any(),
+                rawBody: v.optional(v.string()),
+                signature: v.optional(v.string()),
+                verifySignature: v.optional(v.boolean()),
+            },
+            returns: v.object({
+                assemblyId: v.string(),
+                resultCount: v.number(),
+            }),
+            handler: async (ctx, args) => {
+                return ctx.runAction(component.lib.handleWebhook, {
+                    ...args,
+                    config: { authSecret: resolvedConfig.authSecret },
+                });
+            },
+        }),
+        getAssemblyStatus: queryGeneric({
+            args: { assemblyId: v.string() },
+            returns: v.union(vAssemblyResponse, v.null()),
+            handler: async (ctx, args) => {
+                return ctx.runQuery(component.lib.getAssemblyStatus, args);
+            },
+        }),
+        listAssemblies: queryGeneric({
+            args: {
+                status: v.optional(v.string()),
+                userId: v.optional(v.string()),
+                limit: v.optional(v.number()),
+            },
+            returns: v.array(vAssemblyResponse),
+            handler: async (ctx, args) => {
+                return ctx.runQuery(component.lib.listAssemblies, args);
+            },
+        }),
+        listResults: queryGeneric({
+            args: {
+                assemblyId: v.string(),
+                stepName: v.optional(v.string()),
+                limit: v.optional(v.number()),
+            },
+            returns: v.array(vAssemblyResultResponse),
+            handler: async (ctx, args) => {
+                return ctx.runQuery(component.lib.listResults, args);
+            },
+        }),
+        storeAssemblyMetadata: mutationGeneric({
+            args: {
+                assemblyId: v.string(),
+                userId: v.optional(v.string()),
+                fields: v.optional(v.any()),
+            },
+            returns: v.union(vAssemblyResponse, v.null()),
+            handler: async (ctx, args) => {
+                return ctx.runMutation(component.lib.storeAssemblyMetadata, args);
+            },
+        }),
+    };
+}
+//# sourceMappingURL=index.js.map