File - Object Storage

import { Tenzro } from 'tenzro';

const tenzro = new Tenzro({ apiKey: 'your-api-key' });

// Create a file bucket
const bucket = await tenzro.file.create({
  projectId: 'project-id',
  bucket_name: 'my-files',
  storageClass: 'STANDARD',
});

// Get signed upload URL
const { uploadUrl, fileId } = await tenzro.file.getUploadUrl(bucket.bucket_id, {
  fileName: 'document.pdf',
  contentType: 'application/pdf',
  folderPath: 'documents/',
});

// Upload file directly to signed URL (client-side)
await fetch(uploadUrl, {
  method: 'PUT',
  body: fileData,
  headers: { 'Content-Type': 'application/pdf' },
});

// Get signed download URL
const { url } = await tenzro.file.getSignedUrl(bucket.bucket_id, fileId, {
  action: 'read',
  expiresIn: 3600,  // 1 hour
});

console.log(url);  // Time-limited download URL

const bucket = await tenzro.file.create({
  projectId: string,
  bucket_name: string,
  description?: string,
  storageClass?: 'STANDARD' | 'NEARLINE' | 'COLDLINE' | 'ARCHIVE',
});

const { data, count } = await tenzro.file.list(projectId);

const stats = await tenzro.file.getStats(bucketId);
// Returns: { fileCount, totalSize, folderCount }

const folder = await tenzro.file.createFolder(
  bucketId,
  'documents/reports/2024/',
  'Annual reports'
);

const { data } = await tenzro.file.listFolders(bucketId, 'documents/');

await tenzro.file.deleteFolder(bucketId, 'old-folder/');
// Deletes folder and all contents

const { uploadUrl, fileId, expiresAt } = await tenzro.file.getUploadUrl(
  bucketId,
  {
    fileName: string,      // Required
    contentType: string,   // Required: MIME type
    folderPath?: string,   // Optional: folder path
    expiresIn?: number,    // Seconds until URL expires (default: 3600)
  }
);

const { url, expiresIn } = await tenzro.file.getSignedUrl(
  bucketId,
  fileId,
  {
    action?: 'read' | 'write',  // Default: 'read'
    expiresIn?: number,         // Seconds (default: 3600)
    contentType?: string,       // Required for 'write'
  }
);

const { data, count } = await tenzro.file.listFiles(bucketId, {
  prefix?: string,     // Filter by path prefix
  maxResults?: number, // Default: 100
});

const file = await tenzro.file.getFileMetadata(bucketId, fileId);
// Returns: { fileId, fileName, contentType, size, createdAt, ... }

const copiedFile = await tenzro.file.copyFile(bucketId, fileId, {
  destBucketId?: string,   // Default: same bucket
  destFileName?: string,   // Default: same name
  destFolderPath?: string, // Destination folder
});

const movedFile = await tenzro.file.moveFile(bucketId, fileId, {
  destBucketId?: string,
  destFileName?: string,
  destFolderPath?: string,
});

await tenzro.file.deleteFile(bucketId, fileId);

// React component example
async function uploadDocument(file: File) {
  // 1. Get signed upload URL from your backend
  const { uploadUrl, fileId } = await fetch('/api/upload-url', {
    method: 'POST',
    body: JSON.stringify({
      fileName: file.name,
      contentType: file.type,
    }),
  }).then(r => r.json());

  // 2. Upload directly to GCS
  await fetch(uploadUrl, {
    method: 'PUT',
    body: file,
    headers: {
      'Content-Type': file.type,
    },
  });

  return fileId;
}

// Backend API route
async function handleUploadUrl(req: Request) {
  const { fileName, contentType } = await req.json();

  const result = await tenzro.file.getUploadUrl(bucketId, {
    fileName,
    contentType,
    folderPath: 'uploads/',
  });

  return Response.json(result);
}

// Store ML model
async function saveModel(modelName: string, modelData: ArrayBuffer) {
  const { uploadUrl, fileId } = await tenzro.file.getUploadUrl(bucketId, {
    fileName: `${modelName}.onnx`,
    contentType: 'application/octet-stream',
    folderPath: 'models/',
  });

  await fetch(uploadUrl, {
    method: 'PUT',
    body: modelData,
    headers: { 'Content-Type': 'application/octet-stream' },
  });

  return fileId;
}

// Load model
async function loadModel(fileId: string) {
  const { url } = await tenzro.file.getSignedUrl(bucketId, fileId, {
    expiresIn: 3600,
  });

  const response = await fetch(url);
  return response.arrayBuffer();
}

// List images with thumbnails
async function getGalleryImages(folder = 'images/') {
  const { data: files } = await tenzro.file.listFiles(bucketId, {
    prefix: folder,
    maxResults: 50,
  });

  // Generate temporary URLs for each image
  const images = await Promise.all(
    files
      .filter(f => f.contentType?.startsWith('image/'))
      .map(async (file) => {
        const { url } = await tenzro.file.getSignedUrl(bucketId, file.file_id, {
          expiresIn: 3600,
        });
        return {
          id: file.file_id,
          name: file.file_name,
          url,
          size: file.size,
        };
      })
  );

  return images;
}

{
  "cors": [
    {
      "origin": ["https://your-app.com"],
      "method": ["GET", "PUT", "POST"],
      "responseHeader": ["Content-Type"],
      "maxAgeSeconds": 3600
    }
  ]
}