Media Service

// Step 1: Initiate — get presigned upload URL
const initResp = await mediaClient.initiateUpload({
  tenantId:         tenantID,
  ownerId:          userID,
  originalFileName: file.name,
  fileSizeBytes:    BigInt(file.size),
  mimeType:         file.type,
  title:            "Service Agreement v2",
  tags:             ["contract", "legal"],
  entityRef: { entityType: "ticket", entityId: ticketID },
});

const { file: asset, version, upload } = initResp;
// asset.lifecycleStatus === "PENDING_UPLOAD"

// Step 2: Upload bytes directly to cloud storage (not your backend)
await fetch(upload.uploadUrl, {
  method:  "PUT",
  body:    file,
  headers: Object.fromEntries(
    upload.requiredHeaders.map(h => [h.name, h.value])
  ),
});

// Step 3: Notify the service that upload is done
await mediaClient.completeUpload({
  uploadSessionId: upload.id,
  fileVersionId:   version.id,
});

// Step 4: Poll until READY (or FAILED / QUARANTINED)
const poll = setInterval(async () => {
  const { file } = await mediaClient.getFileAsset({ fileAssetId: asset.id });
  if (file.lifecycleStatus === "READY") {
    clearInterval(poll);
    setFileReady(file);
  } else if (["FAILED", "QUARANTINED"].includes(file.lifecycleStatus)) {
    clearInterval(poll);
    setFileError(file.lifecycleStatus);
  }
}, 2000);

resp, err := client.GenerateDownloadLink(ctx, connect.NewRequest(
    &mediav1.GenerateDownloadLinkRequest{
        FileAssetId: fileID,
        TenantId:    tenantID,
        Disposition: mediav1.Disposition_INLINE, // or ATTACHMENT
        // Optional: request a specific rendition (e.g., thumbnail)
        RenditionId: thumbnailRenditionID,
    },
))
if err != nil {
    return err
}

// Use resp.Url for the browser fetch / src attribute
// Never cache beyond resp.ExpiresAt
log.Printf("URL valid until: %s", resp.Msg.ExpiresAt.AsTime())

resp, err := client.CreateShareLink(ctx, connect.NewRequest(
    &mediav1.CreateShareLinkRequest{
        FileAssetId:      fileID,
        TenantId:         tenantID,
        ExpiresAt:        timestamppb.New(time.Now().Add(7 * 24 * time.Hour)),
        PasswordProtected: true,
        Password:          "s3cur3pass",
        MaxDownloads:      10,
        AllowDownload:     true,
        AllowPreview:      true,
        BandwidthLimitMb:  500,
        // Optional geo/IP/domain restrictions
        AllowedCountryCodes: []string{"US", "CA"},
    },
))
// resp.ShareLink.Url — the externally shareable link

// Manually trigger a specific processing job
resp, err := client.CreateProcessingJob(ctx, connect.NewRequest(
    &mediav1.CreateProcessingJobRequest{
        FileAssetId: fileID,
        TenantId:    tenantID,
        JobType:     mediav1.ProcessingJobType_OCR,
        // Optional: override default parameters
        OcrParams: &mediav1.OcrParams{
            Language: "en",
            OutputFormat: mediav1.OcrOutputFormat_SEARCHABLE_PDF,
        },
    },
))
jobID := resp.Msg.Job.Id

// Poll job status
for {
    status, _ := client.GetProcessingJob(ctx, connect.NewRequest(
        &mediav1.GetProcessingJobRequest{JobId: jobID},
    ))
    if status.Msg.Job.Status == mediav1.JobStatus_SUCCEEDED {
        // Retrieve OCR output
        text, _ := client.GetExtractedText(ctx, connect.NewRequest(
            &mediav1.GetExtractedTextRequest{FileAssetId: fileID},
        ))
        break
    }
    time.Sleep(2 * time.Second)
}